clang-format: IndentCaseLabels: false

14 files changed, 652 insertions, 654 deletions

diff --git a/.clang-format b/.clang-format
index b2ed423b..14e570af 100644
--- a/.clang-format
+++ b/.clang-format
@@ -3,12 +3,13 @@ AlignAfterOpenBracket: DontAlign
 AlignConsecutiveAssignments: true
 AlignConsecutiveDeclarations: true
 AlignConsecutiveMacros: true
-AlignEscapedNewlines: false
+AlignEscapedNewlines: Right
 AlignOperands: true
 AllowShortFunctionsOnASingleLine: false
 AlwaysBreakBeforeMultilineStrings: false
 ColumnLimit: 100
 ForEachMacros:
   - TAILQ_FOREACH_HF
+IndentCaseLabels: false
 IndentWidth: 4
 SpacesBeforeTrailingComments: 4
diff --git a/cmdline.c b/cmdline.c
index 61910e9c..d1620f32 100644
--- a/cmdline.c
+++ b/cmdline.c
@@ -577,253 +577,253 @@ bool cmdlineParse(int argc, char* argv[], honggfuzz_t* hfuzz) {
         }
 
         switch (c) {
-            case '!':
-                LOG_HELP(PROG_NAME " " PROG_VERSION);
-                exit(0);
-            case 'h':
-                cmdlineUsage(argv[0], custom_opts);
-                break;
-            case '?':
-                cmdlineHelp(argv[0], custom_opts);
-                return false;
-            case 'i':
-            case 'f': /* Synonym for -i, stands for -f(iles) */
-                hfuzz->io.inputDir = optarg;
-                break;
-            case 'x':
-                hfuzz->feedback.dynFileMethod = _HF_DYNFILE_NONE;
-                break;
-            case 'Q':
-                hfuzz->exe.nullifyStdio = false;
-                break;
-            case 'v':
-                hfuzz->display.useScreen = false;
-                break;
-            case 'V':
-                hfuzz->cfg.useVerifier = true;
-                break;
-            case 's':
-                hfuzz->exe.fuzzStdin = true;
-                break;
-            case 'u':
-                hfuzz->io.saveUnique = false;
-                break;
-            case 'U':
-                hfuzz->io.saveSmaller = true;
-                break;
-            case 'l':
-                logfile = optarg;
-                break;
-            case 'd':
-                ll = DEBUG;
-                break;
-            case 'q':
-                ll = WARNING;
-                break;
-            case 'e':
-                hfuzz->io.fileExtn = optarg;
-                break;
-            case 'W':
-                snprintf(hfuzz->io.workDir, sizeof(hfuzz->io.workDir), "%s", optarg);
-                break;
-            case 0x600:
-                hfuzz->io.crashDir = optarg;
-                break;
-            case 'o':
-                hfuzz->io.outputDir = optarg;
-                break;
-            case 0x602:
-                hfuzz->io.covDirNew = optarg;
-                break;
-            case 'r':
-                hfuzz->mutate.mutationsPerRun = strtoul(optarg, NULL, 10);
-                break;
-            case 'c':
-                hfuzz->exe.externalCommand = optarg;
-                break;
-            case 'S':
-                hfuzz->sanitizer.enable = true;
-                break;
-            case 0x10F:
-                hfuzz->sanitizer.del_report = cmdlineParseTrueFalse(opts[opt_index].name, optarg);
-                break;
-            case 0x10B:
-                hfuzz->socketFuzzer.enabled = true;
-                hfuzz->timing.tmOut         = 0; /* Disable process timeout checks */
-                break;
-            case 0x10C:
-                hfuzz->exe.netDriver = true;
-                break;
-            case 0x10D:
-                hfuzz->cfg.only_printable = true;
-                break;
-            case 0x10E:
-                hfuzz->io.exportFeedback = true;
-                break;
-            case 0x112:
-                hfuzz->feedback.cmpFeedback = cmdlineParseTrueFalse(opts[opt_index].name, optarg);
-                break;
-            case 'z':
-                hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_SOFT;
-                break;
-            case 'M':
-                hfuzz->cfg.minimize = true;
-                break;
-            case 'F':
-                hfuzz->io.maxFileSz = strtoul(optarg, NULL, 0);
-                break;
-            case 't':
-                hfuzz->timing.tmOut = atol(optarg);
-                break;
-            case 'R':
-                hfuzz->cfg.reportFile = optarg;
-                break;
-            case 'n':
-                if (optarg[0] == 'a') {
-                    long ncpus                = sysconf(_SC_NPROCESSORS_ONLN);
-                    hfuzz->threads.threadsMax = (ncpus < 1 ? 1 : ncpus);
-                } else {
-                    if (!util_isANumber(optarg)) {
-                        LOG_E("'-n %s' is not a number", optarg);
-                        return false;
-                    }
-                    hfuzz->threads.threadsMax = strtoul(optarg, NULL, 0);
-                }
-                break;
-            case 0x109: {
-                time_t p = atol(optarg);
-                if (p > 0) {
-                    hfuzz->timing.runEndTime = time(NULL) + p;
-                }
-            } break;
-            case 0x10A:
-                hfuzz->timing.exitOnTime = atol(optarg);
-                break;
-            case 'N':
-                hfuzz->mutate.mutationsMax = atol(optarg);
-                break;
-            case 0x100:
-                hfuzz->exe.asLimit = strtoull(optarg, NULL, 0);
-                break;
-            case 0x101:
-                hfuzz->exe.rssLimit = strtoull(optarg, NULL, 0);
-                break;
-            case 0x102:
-                hfuzz->exe.dataLimit = strtoull(optarg, NULL, 0);
-                break;
-            case 0x103:
-                hfuzz->exe.coreLimit = strtoull(optarg, NULL, 0);
-                break;
-            case 0x104:
-                hfuzz->exe.stackLimit = strtoull(optarg, NULL, 0);
-                break;
-            case 0x111:
-                hfuzz->exe.postExternalCommand = optarg;
-                break;
-            case 0x110:
-                hfuzz->exe.feedbackMutateCommand = optarg;
-                break;
-            case 0x106:
-                hfuzz->feedback.skipFeedbackOnTimeout = true;
-                break;
-            case 0x107:
-                hfuzz->cfg.exitUponCrash = true;
-                break;
-            case 0x113:
-                hfuzz->cfg.exitCodeUponCrash = strtoul(optarg, NULL, 0);
-                break;
-            case 0x114:
-                hfuzz->threads.pinThreadToCPUs = strtoul(optarg, NULL, 0);
-                break;
-            case 0x108:
-                hfuzz->exe.clearEnv = true;
-                break;
-            case 'P':
-                hfuzz->exe.persistent = true;
-                break;
-            case 'T':
-                hfuzz->timing.tmoutVTALRM = true;
-                break;
-            case 'E':
-                if (!cmdlineAddEnv(hfuzz, optarg)) {
+        case '!':
+            LOG_HELP(PROG_NAME " " PROG_VERSION);
+            exit(0);
+        case 'h':
+            cmdlineUsage(argv[0], custom_opts);
+            break;
+        case '?':
+            cmdlineHelp(argv[0], custom_opts);
+            return false;
+        case 'i':
+        case 'f': /* Synonym for -i, stands for -f(iles) */
+            hfuzz->io.inputDir = optarg;
+            break;
+        case 'x':
+            hfuzz->feedback.dynFileMethod = _HF_DYNFILE_NONE;
+            break;
+        case 'Q':
+            hfuzz->exe.nullifyStdio = false;
+            break;
+        case 'v':
+            hfuzz->display.useScreen = false;
+            break;
+        case 'V':
+            hfuzz->cfg.useVerifier = true;
+            break;
+        case 's':
+            hfuzz->exe.fuzzStdin = true;
+            break;
+        case 'u':
+            hfuzz->io.saveUnique = false;
+            break;
+        case 'U':
+            hfuzz->io.saveSmaller = true;
+            break;
+        case 'l':
+            logfile = optarg;
+            break;
+        case 'd':
+            ll = DEBUG;
+            break;
+        case 'q':
+            ll = WARNING;
+            break;
+        case 'e':
+            hfuzz->io.fileExtn = optarg;
+            break;
+        case 'W':
+            snprintf(hfuzz->io.workDir, sizeof(hfuzz->io.workDir), "%s", optarg);
+            break;
+        case 0x600:
+            hfuzz->io.crashDir = optarg;
+            break;
+        case 'o':
+            hfuzz->io.outputDir = optarg;
+            break;
+        case 0x602:
+            hfuzz->io.covDirNew = optarg;
+            break;
+        case 'r':
+            hfuzz->mutate.mutationsPerRun = strtoul(optarg, NULL, 10);
+            break;
+        case 'c':
+            hfuzz->exe.externalCommand = optarg;
+            break;
+        case 'S':
+            hfuzz->sanitizer.enable = true;
+            break;
+        case 0x10F:
+            hfuzz->sanitizer.del_report = cmdlineParseTrueFalse(opts[opt_index].name, optarg);
+            break;
+        case 0x10B:
+            hfuzz->socketFuzzer.enabled = true;
+            hfuzz->timing.tmOut         = 0; /* Disable process timeout checks */
+            break;
+        case 0x10C:
+            hfuzz->exe.netDriver = true;
+            break;
+        case 0x10D:
+            hfuzz->cfg.only_printable = true;
+            break;
+        case 0x10E:
+            hfuzz->io.exportFeedback = true;
+            break;
+        case 0x112:
+            hfuzz->feedback.cmpFeedback = cmdlineParseTrueFalse(opts[opt_index].name, optarg);
+            break;
+        case 'z':
+            hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_SOFT;
+            break;
+        case 'M':
+            hfuzz->cfg.minimize = true;
+            break;
+        case 'F':
+            hfuzz->io.maxFileSz = strtoul(optarg, NULL, 0);
+            break;
+        case 't':
+            hfuzz->timing.tmOut = atol(optarg);
+            break;
+        case 'R':
+            hfuzz->cfg.reportFile = optarg;
+            break;
+        case 'n':
+            if (optarg[0] == 'a') {
+                long ncpus                = sysconf(_SC_NPROCESSORS_ONLN);
+                hfuzz->threads.threadsMax = (ncpus < 1 ? 1 : ncpus);
+            } else {
+                if (!util_isANumber(optarg)) {
+                    LOG_E("'-n %s' is not a number", optarg);
                     return false;
                 }
-                break;
-            case 'w':
-                hfuzz->mutate.dictionaryFile = optarg;
-                break;
-            case 'B':
-                hfuzz->feedback.blocklistFile = optarg;
-                break;
+                hfuzz->threads.threadsMax = strtoul(optarg, NULL, 0);
+            }
+            break;
+        case 0x109: {
+            time_t p = atol(optarg);
+            if (p > 0) {
+                hfuzz->timing.runEndTime = time(NULL) + p;
+            }
+        } break;
+        case 0x10A:
+            hfuzz->timing.exitOnTime = atol(optarg);
+            break;
+        case 'N':
+            hfuzz->mutate.mutationsMax = atol(optarg);
+            break;
+        case 0x100:
+            hfuzz->exe.asLimit = strtoull(optarg, NULL, 0);
+            break;
+        case 0x101:
+            hfuzz->exe.rssLimit = strtoull(optarg, NULL, 0);
+            break;
+        case 0x102:
+            hfuzz->exe.dataLimit = strtoull(optarg, NULL, 0);
+            break;
+        case 0x103:
+            hfuzz->exe.coreLimit = strtoull(optarg, NULL, 0);
+            break;
+        case 0x104:
+            hfuzz->exe.stackLimit = strtoull(optarg, NULL, 0);
+            break;
+        case 0x111:
+            hfuzz->exe.postExternalCommand = optarg;
+            break;
+        case 0x110:
+            hfuzz->exe.feedbackMutateCommand = optarg;
+            break;
+        case 0x106:
+            hfuzz->feedback.skipFeedbackOnTimeout = true;
+            break;
+        case 0x107:
+            hfuzz->cfg.exitUponCrash = true;
+            break;
+        case 0x113:
+            hfuzz->cfg.exitCodeUponCrash = strtoul(optarg, NULL, 0);
+            break;
+        case 0x114:
+            hfuzz->threads.pinThreadToCPUs = strtoul(optarg, NULL, 0);
+            break;
+        case 0x108:
+            hfuzz->exe.clearEnv = true;
+            break;
+        case 'P':
+            hfuzz->exe.persistent = true;
+            break;
+        case 'T':
+            hfuzz->timing.tmoutVTALRM = true;
+            break;
+        case 'E':
+            if (!cmdlineAddEnv(hfuzz, optarg)) {
+                return false;
+            }
+            break;
+        case 'w':
+            hfuzz->mutate.dictionaryFile = optarg;
+            break;
+        case 'B':
+            hfuzz->feedback.blocklistFile = optarg;
+            break;
 #if defined(_HF_ARCH_LINUX)
-            case 0x500:
-                hfuzz->arch_linux.ignoreAddr = (void*)strtoul(optarg, NULL, 0);
-                break;
-            case 0x501:
-                hfuzz->arch_linux.disableRandomization = false;
-                break;
-            case 0x503:
-                hfuzz->arch_linux.dynamicCutOffAddr = strtoull(optarg, NULL, 0);
-                break;
-            case 0x504:
-                hfuzz->arch_linux.symsBlFile = optarg;
-                break;
-            case 0x505:
-                hfuzz->arch_linux.symsWlFile = optarg;
-                break;
-            case 0x510:
-                hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_INSTR_COUNT;
-                break;
-            case 0x511:
-                hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_BRANCH_COUNT;
-                break;
-            case 0x513:
-                hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_BTS_EDGE;
-                break;
-            case 0x514:
-                hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_IPT_BLOCK;
-                break;
-            case 0x515:
-                hfuzz->arch_linux.kernelOnly = true;
-                break;
-            case 0x530:
-                hfuzz->arch_linux.useNetNs = cmdlineParseTriState(opts[opt_index].name, optarg);
-                if (hfuzz->arch_linux.useNetNs == HF_YES) {
-                    hfuzz->arch_linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWNET);
-                }
-                break;
-            case 0x531:
-                hfuzz->arch_linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWPID);
-                break;
-            case 0x532:
-                hfuzz->arch_linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWIPC);
-                break;
+        case 0x500:
+            hfuzz->arch_linux.ignoreAddr = (void*)strtoul(optarg, NULL, 0);
+            break;
+        case 0x501:
+            hfuzz->arch_linux.disableRandomization = false;
+            break;
+        case 0x503:
+            hfuzz->arch_linux.dynamicCutOffAddr = strtoull(optarg, NULL, 0);
+            break;
+        case 0x504:
+            hfuzz->arch_linux.symsBlFile = optarg;
+            break;
+        case 0x505:
+            hfuzz->arch_linux.symsWlFile = optarg;
+            break;
+        case 0x510:
+            hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_INSTR_COUNT;
+            break;
+        case 0x511:
+            hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_BRANCH_COUNT;
+            break;
+        case 0x513:
+            hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_BTS_EDGE;
+            break;
+        case 0x514:
+            hfuzz->feedback.dynFileMethod |= _HF_DYNFILE_IPT_BLOCK;
+            break;
+        case 0x515:
+            hfuzz->arch_linux.kernelOnly = true;
+            break;
+        case 0x530:
+            hfuzz->arch_linux.useNetNs = cmdlineParseTriState(opts[opt_index].name, optarg);
+            if (hfuzz->arch_linux.useNetNs == HF_YES) {
+                hfuzz->arch_linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWNET);
+            }
+            break;
+        case 0x531:
+            hfuzz->arch_linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWPID);
+            break;
+        case 0x532:
+            hfuzz->arch_linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWIPC);
+            break;
 #endif /* defined(_HF_ARCH_LINUX) */
 #if defined(_HF_ARCH_NETBSD)
-            case 0x500:
-                hfuzz->arch_netbsd.ignoreAddr = (void*)strtoul(optarg, NULL, 0);
-                break;
-            case 0x504:
-                hfuzz->arch_netbsd.symsBlFile = optarg;
-                break;
-            case 0x505:
-                hfuzz->arch_netbsd.symsWlFile = optarg;
-                break;
+        case 0x500:
+            hfuzz->arch_netbsd.ignoreAddr = (void*)strtoul(optarg, NULL, 0);
+            break;
+        case 0x504:
+            hfuzz->arch_netbsd.symsBlFile = optarg;
+            break;
+        case 0x505:
+            hfuzz->arch_netbsd.symsWlFile = optarg;
+            break;
 #endif /* defined(_HF_ARCH_NETBSD) */
 #if defined(__FreeBSD__)
-            case 0x501:
-                hfuzz->arch_linux.disableRandomization = false;
-                break;
+        case 0x501:
+            hfuzz->arch_linux.disableRandomization = false;
+            break;
 #endif
-            case 0x115:
-                hfuzz->io.dynamicInputDir = optarg;
-                break;
-            case 0x116:
-                hfuzz->io.statsFileName = optarg;
-                break;
-            default:
-                cmdlineHelp(argv[0], custom_opts);
-                return false;
+        case 0x115:
+            hfuzz->io.dynamicInputDir = optarg;
+            break;
+        case 0x116:
+            hfuzz->io.statsFileName = optarg;
+            break;
+        default:
+            cmdlineHelp(argv[0], custom_opts);
+            return false;
         }
     }
 
diff --git a/display.c b/display.c
index 55961fd0..54644acb 100644
--- a/display.c
+++ b/display.c
@@ -330,29 +330,29 @@ void display_display(honggfuzz_t* hfuzz) {
             hfuzz->mutate.mutationsMax, exeProgress);
     }
     switch (ATOMIC_GET(hfuzz->feedback.state)) {
-        case _HF_STATE_STATIC:
-            display_put("\n        Mode : " ESC_BOLD "Static" ESC_RESET "\n");
-            break;
-        case _HF_STATE_DYNAMIC_DRY_RUN: {
-            if (ATOMIC_GET(hfuzz->cfg.switchingToFDM)) {
-                display_put("\n  Mode [2/3] : " ESC_BOLD
-                            "Switching to the Feedback Driven Mode" ESC_RESET " [%zu/%zu]\n",
-                    hfuzz->io.testedFileCnt, hfuzz->io.fileCnt);
-            } else {
-                display_put("\n  Mode [1/3] : " ESC_BOLD "Feedback Driven Dry Run" ESC_RESET
-                            " [%zu/%zu]\n",
-                    hfuzz->io.testedFileCnt, hfuzz->io.fileCnt);
-            }
-        } break;
-        case _HF_STATE_DYNAMIC_MAIN:
-            display_put("\n  Mode [3/3] : " ESC_BOLD "Feedback Driven Mode" ESC_RESET "\n");
-            break;
-        case _HF_STATE_DYNAMIC_MINIMIZE:
-            display_put("\n  Mode [3/3] : " ESC_BOLD "Corpus Minimization" ESC_RESET "\n");
-            break;
-        default:
-            display_put("\n        Mode : " ESC_BOLD "Unknown" ESC_RESET "\n");
-            break;
+    case _HF_STATE_STATIC:
+        display_put("\n        Mode : " ESC_BOLD "Static" ESC_RESET "\n");
+        break;
+    case _HF_STATE_DYNAMIC_DRY_RUN: {
+        if (ATOMIC_GET(hfuzz->cfg.switchingToFDM)) {
+            display_put("\n  Mode [2/3] : " ESC_BOLD
+                        "Switching to the Feedback Driven Mode" ESC_RESET " [%zu/%zu]\n",
+                hfuzz->io.testedFileCnt, hfuzz->io.fileCnt);
+        } else {
+            display_put("\n  Mode [1/3] : " ESC_BOLD "Feedback Driven Dry Run" ESC_RESET
+                        " [%zu/%zu]\n",
+                hfuzz->io.testedFileCnt, hfuzz->io.fileCnt);
+        }
+    } break;
+    case _HF_STATE_DYNAMIC_MAIN:
+        display_put("\n  Mode [3/3] : " ESC_BOLD "Feedback Driven Mode" ESC_RESET "\n");
+        break;
+    case _HF_STATE_DYNAMIC_MINIMIZE:
+        display_put("\n  Mode [3/3] : " ESC_BOLD "Corpus Minimization" ESC_RESET "\n");
+        break;
+    default:
+        display_put("\n        Mode : " ESC_BOLD "Unknown" ESC_RESET "\n");
+        break;
     }
     display_put("      Target : " ESC_BOLD "%s" ESC_RESET "\n", hfuzz->display.cmdline_txt);
 
diff --git a/honggfuzz.h b/honggfuzz.h
index e0926fe3..75e27ebd 100644
--- a/honggfuzz.h
+++ b/honggfuzz.h
@@ -155,15 +155,15 @@ struct _dynfile_t {
     uint32_t           refs;
     fuzzState_t        phase;
     uint8_t*           data;
-    TAILQ_ENTRY(_dynfile_t) pointers;
+                       TAILQ_ENTRY(_dynfile_t) pointers;
 };
 
 typedef struct _dynfile_t dynfile_t;
 
 struct strings_t {
     size_t len;
-    TAILQ_ENTRY(strings_t) pointers;
-    char s[];
+           TAILQ_ENTRY(strings_t) pointers;
+    char   s[];
 };
 
 typedef struct {
@@ -215,7 +215,7 @@ typedef struct {
         size_t      dynfileqCnt;
         dynfile_t*  dynfileqCurrent;
         dynfile_t*  dynfileq2Current;
-        TAILQ_HEAD(dyns_t, _dynfile_t) dynfileq;
+                    TAILQ_HEAD(dyns_t, _dynfile_t) dynfileq;
         bool        exportFeedback;
         const char* dynamicInputDir;
         const char* statsFileName;
diff --git a/libhfcommon/util.c b/libhfcommon/util.c
index 9802e5a7..d3b2e3b4 100644
--- a/libhfcommon/util.c
+++ b/libhfcommon/util.c
@@ -477,47 +477,47 @@ size_t util_decodeCString(char* s) {
     size_t o = 0;
     for (size_t i = 0; s[i] != '\0' && s[i] != '"'; i++, o++) {
         switch (s[i]) {
-            case '\\': {
-                i++;
-                if (!s[i]) {
-                    continue;
-                }
-                switch (s[i]) {
-                    case 'a':
-                        s[o] = '\a';
-                        break;
-                    case 'r':
-                        s[o] = '\r';
-                        break;
-                    case 'n':
-                        s[o] = '\n';
-                        break;
-                    case 't':
-                        s[o] = '\t';
-                        break;
-                    case '0':
-                        s[o] = '\0';
-                        break;
-                    case 'x': {
-                        if (s[i + 1] && s[i + 2]) {
-                            char hex[] = {s[i + 1], s[i + 2], 0};
-                            s[o]       = strtoul(hex, NULL, 16);
-                            i += 2;
-                        } else {
-                            s[o] = s[i];
-                        }
-                        break;
-                    }
-                    default:
-                        s[o] = s[i];
-                        break;
+        case '\\': {
+            i++;
+            if (!s[i]) {
+                continue;
+            }
+            switch (s[i]) {
+            case 'a':
+                s[o] = '\a';
+                break;
+            case 'r':
+                s[o] = '\r';
+                break;
+            case 'n':
+                s[o] = '\n';
+                break;
+            case 't':
+                s[o] = '\t';
+                break;
+            case '0':
+                s[o] = '\0';
+                break;
+            case 'x': {
+                if (s[i + 1] && s[i + 2]) {
+                    char hex[] = {s[i + 1], s[i + 2], 0};
+                    s[o]       = strtoul(hex, NULL, 16);
+                    i += 2;
+                } else {
+                    s[o] = s[i];
                 }
                 break;
             }
-            default: {
+            default:
                 s[o] = s[i];
                 break;
             }
+            break;
+        }
+        default: {
+            s[o] = s[i];
+            break;
+        }
         }
     }
     s[o] = '\0';
diff --git a/libhfuzz/instrument.c b/libhfuzz/instrument.c
index f72f1f7b..839799ca 100644
--- a/libhfuzz/instrument.c
+++ b/libhfuzz/instrument.c
@@ -505,18 +505,18 @@ HF_REQUIRE_SSE42_POPCNT void __sanitizer_cov_trace_cmp(
     uint64_t SizeAndType, uint64_t Arg1, uint64_t Arg2) {
     uint64_t CmpSize = (SizeAndType >> 32) / 8;
     switch (CmpSize) {
-        case (sizeof(uint8_t)):
-            hfuzz_trace_cmp1_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
-            return;
-        case (sizeof(uint16_t)):
-            hfuzz_trace_cmp2_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
-            return;
-        case (sizeof(uint32_t)):
-            hfuzz_trace_cmp4_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
-            return;
-        case (sizeof(uint64_t)):
-            hfuzz_trace_cmp8_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
-            return;
+    case (sizeof(uint8_t)):
+        hfuzz_trace_cmp1_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
+        return;
+    case (sizeof(uint16_t)):
+        hfuzz_trace_cmp2_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
+        return;
+    case (sizeof(uint32_t)):
+        hfuzz_trace_cmp4_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
+        return;
+    case (sizeof(uint64_t)):
+        hfuzz_trace_cmp8_internal((uintptr_t)__builtin_return_address(0), Arg1, Arg2);
+        return;
     }
 }
 
diff --git a/linux/perf.c b/linux/perf.c
index b40474a6..7ae5a903 100644
--- a/linux/perf.c
+++ b/linux/perf.c
@@ -143,29 +143,29 @@ static bool arch_perfCreate(run_t* run, pid_t pid, dynFileMethod_t method, int*
     pe.type       = PERF_TYPE_HARDWARE;
 
     switch (method) {
-        case _HF_DYNFILE_INSTR_COUNT:
-            LOG_D("Using: PERF_COUNT_HW_INSTRUCTIONS for pid=%d", (int)pid);
-            pe.config  = PERF_COUNT_HW_INSTRUCTIONS;
-            pe.inherit = 1;
-            break;
-        case _HF_DYNFILE_BRANCH_COUNT:
-            LOG_D("Using: PERF_COUNT_HW_BRANCH_INSTRUCTIONS for pid=%d", (int)pid);
-            pe.config  = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
-            pe.inherit = 1;
-            break;
-        case _HF_DYNFILE_BTS_EDGE:
-            LOG_D("Using: (Intel BTS) type=%" PRIu32 " for pid=%d", perfIntelBtsPerfType, (int)pid);
-            pe.type = perfIntelBtsPerfType;
-            break;
-        case _HF_DYNFILE_IPT_BLOCK:
-            LOG_D("Using: (Intel PT) type=%" PRIu32 " for pid=%d", perfIntelPtPerfType, (int)pid);
-            pe.type   = perfIntelPtPerfType;
-            pe.config = RTIT_CTL_DISRETC;
-            break;
-        default:
-            LOG_E("Unknown perf mode: '%d' for pid=%d", method, (int)pid);
-            return false;
-            break;
+    case _HF_DYNFILE_INSTR_COUNT:
+        LOG_D("Using: PERF_COUNT_HW_INSTRUCTIONS for pid=%d", (int)pid);
+        pe.config  = PERF_COUNT_HW_INSTRUCTIONS;
+        pe.inherit = 1;
+        break;
+    case _HF_DYNFILE_BRANCH_COUNT:
+        LOG_D("Using: PERF_COUNT_HW_BRANCH_INSTRUCTIONS for pid=%d", (int)pid);
+        pe.config  = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
+        pe.inherit = 1;
+        break;
+    case _HF_DYNFILE_BTS_EDGE:
+        LOG_D("Using: (Intel BTS) type=%" PRIu32 " for pid=%d", perfIntelBtsPerfType, (int)pid);
+        pe.type = perfIntelBtsPerfType;
+        break;
+    case _HF_DYNFILE_IPT_BLOCK:
+        LOG_D("Using: (Intel PT) type=%" PRIu32 " for pid=%d", perfIntelPtPerfType, (int)pid);
+        pe.type   = perfIntelPtPerfType;
+        pe.config = RTIT_CTL_DISRETC;
+        break;
+    default:
+        LOG_E("Unknown perf mode: '%d' for pid=%d", method, (int)pid);
+        return false;
+        break;
     }
 
 #if !defined(PERF_FLAG_FD_CLOEXEC)
diff --git a/linux/pt.c b/linux/pt.c
index ff4d0969..b936771e 100644
--- a/linux/pt.c
+++ b/linux/pt.c
@@ -101,23 +101,23 @@ __attribute__((hot)) inline static void perf_ptAnalyzePkt(
 
     uint64_t ip;
     switch (packet->payload.ip.ipc) {
-        case pt_ipc_update_16:
-            ip = (*last_tip_ip & ~0xFFFFull) | (packet->payload.ip.ip & 0xFFFFull);
-            break;
-        case pt_ipc_update_32:
-            ip = (*last_tip_ip & ~0xFFFFFFFFull) | (packet->payload.ip.ip & 0xFFFFFFFFull);
-            break;
-        case pt_ipc_update_48:
-            ip = (*last_tip_ip & ~0xFFFFFFFFFFFFull) | (packet->payload.ip.ip & 0xFFFFFFFFFFFFull);
-            break;
-        case pt_ipc_sext_48:
-            ip = sext(packet->payload.ip.ip, 48);
-            break;
-        case pt_ipc_full:
-            ip = packet->payload.ip.ip;
-            break;
-        default:
-            return;
+    case pt_ipc_update_16:
+        ip = (*last_tip_ip & ~0xFFFFull) | (packet->payload.ip.ip & 0xFFFFull);
+        break;
+    case pt_ipc_update_32:
+        ip = (*last_tip_ip & ~0xFFFFFFFFull) | (packet->payload.ip.ip & 0xFFFFFFFFull);
+        break;
+    case pt_ipc_update_48:
+        ip = (*last_tip_ip & ~0xFFFFFFFFFFFFull) | (packet->payload.ip.ip & 0xFFFFFFFFFFFFull);
+        break;
+    case pt_ipc_sext_48:
+        ip = sext(packet->payload.ip.ip, 48);
+        break;
+    case pt_ipc_full:
+        ip = packet->payload.ip.ip;
+        break;
+    default:
+        return;
     }
 
     *last_tip_ip = ip;
diff --git a/linux/trace.c b/linux/trace.c
index 4696ba7e..ffe0fe8f 100644
--- a/linux/trace.c
+++ b/linux/trace.c
@@ -875,26 +875,24 @@ static void arch_traceSaveData(run_t* run, pid_t pid) {
 static void arch_traceEvent(int status, pid_t pid) {
     LOG_D("PID: %d, Ptrace event: %d", pid, __WEVENT(status));
     switch (__WEVENT(status)) {
-        case PTRACE_EVENT_EXIT: {
-            unsigned long event_msg;
-            if (ptrace(PTRACE_GETEVENTMSG, pid, NULL, &event_msg) == -1) {
-                PLOG_E("ptrace(PTRACE_GETEVENTMSG,%d) failed", pid);
-                return;
-            }
+    case PTRACE_EVENT_EXIT: {
+        unsigned long event_msg;
+        if (ptrace(PTRACE_GETEVENTMSG, pid, NULL, &event_msg) == -1) {
+            PLOG_E("ptrace(PTRACE_GETEVENTMSG,%d) failed", pid);
+            return;
+        }
 
-            if (WIFEXITED(event_msg)) {
-                LOG_D("PID: %d exited with exit_code: %lu", pid,
-                    (unsigned long)WEXITSTATUS(event_msg));
-            } else if (WIFSIGNALED(event_msg)) {
-                LOG_D(
-                    "PID: %d terminated with signal: %lu", pid, (unsigned long)WTERMSIG(event_msg));
-            } else {
-                LOG_D("PID: %d exited with unknown status: %lu (%s)", pid, event_msg,
-                    subproc_StatusToStr(event_msg));
-            }
-        } break;
-        default:
-            break;
+        if (WIFEXITED(event_msg)) {
+            LOG_D("PID: %d exited with exit_code: %lu", pid, (unsigned long)WEXITSTATUS(event_msg));
+        } else if (WIFSIGNALED(event_msg)) {
+            LOG_D("PID: %d terminated with signal: %lu", pid, (unsigned long)WTERMSIG(event_msg));
+        } else {
+            LOG_D("PID: %d exited with unknown status: %lu (%s)", pid, event_msg,
+                subproc_StatusToStr(event_msg));
+        }
+    } break;
+    default:
+        break;
     }
 
     ptrace(PTRACE_CONT, pid, 0, 0);
diff --git a/mac/arch.c b/mac/arch.c
index 533cefde..ced08330 100644
--- a/mac/arch.c
+++ b/mac/arch.c
@@ -127,26 +127,26 @@ __attribute__((constructor)) void arch_initSigs(void) {
 
 const char* exception_to_string(int exception) {
     switch (exception) {
-        case EXC_BAD_ACCESS:
-            return "EXC_BAD_ACCESS";
-        case EXC_BAD_INSTRUCTION:
-            return "EXC_BAD_INSTRUCTION";
-        case EXC_ARITHMETIC:
-            return "EXC_ARITHMETIC";
-        case EXC_EMULATION:
-            return "EXC_EMULATION";
-        case EXC_SOFTWARE:
-            return "EXC_SOFTWARE";
-        case EXC_BREAKPOINT:
-            return "EXC_BREAKPOINT";
-        case EXC_SYSCALL:
-            return "EXC_SYSCALL";
-        case EXC_MACH_SYSCALL:
-            return "EXC_MACH_SYSCALL";
-        case EXC_RPC_ALERT:
-            return "EXC_RPC_ALERT";
-        case EXC_CRASH:
-            return "EXC_CRASH";
+    case EXC_BAD_ACCESS:
+        return "EXC_BAD_ACCESS";
+    case EXC_BAD_INSTRUCTION:
+        return "EXC_BAD_INSTRUCTION";
+    case EXC_ARITHMETIC:
+        return "EXC_ARITHMETIC";
+    case EXC_EMULATION:
+        return "EXC_EMULATION";
+    case EXC_SOFTWARE:
+        return "EXC_SOFTWARE";
+    case EXC_BREAKPOINT:
+        return "EXC_BREAKPOINT";
+    case EXC_SYSCALL:
+        return "EXC_SYSCALL";
+    case EXC_MACH_SYSCALL:
+        return "EXC_MACH_SYSCALL";
+    case EXC_RPC_ALERT:
+        return "EXC_RPC_ALERT";
+    case EXC_CRASH:
+        return "EXC_CRASH";
     }
     return "UNKNOWN";
 }
diff --git a/mangle.c b/mangle.c
index 50ab6c99..64c9e916 100644
--- a/mangle.c
+++ b/mangle.c
@@ -563,55 +563,55 @@ static inline void mangle_AddSubWithRange(
     int64_t delta = (int64_t)util_rndGet(0, range * 2) - (int64_t)range;
 
     switch (varLen) {
-        case 1: {
-            run->dynfile->data[off] += delta;
-            break;
-        }
-        case 2: {
-            int16_t val;
-            util_memcpyInline(&val, &run->dynfile->data[off], sizeof(val));
-            if (util_rnd64() & 0x1) {
-                val += delta;
-            } else {
-                /* Foreign endianess */
-                val = __builtin_bswap16(val);
-                val += delta;
-                val = __builtin_bswap16(val);
-            }
-            mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
-            break;
-        }
-        case 4: {
-            int32_t val;
-            util_memcpyInline(&val, &run->dynfile->data[off], sizeof(val));
-            if (util_rnd64() & 0x1) {
-                val += delta;
-            } else {
-                /* Foreign endianess */
-                val = __builtin_bswap32(val);
-                val += delta;
-                val = __builtin_bswap32(val);
-            }
-            mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
-            break;
+    case 1: {
+        run->dynfile->data[off] += delta;
+        break;
+    }
+    case 2: {
+        int16_t val;
+        util_memcpyInline(&val, &run->dynfile->data[off], sizeof(val));
+        if (util_rnd64() & 0x1) {
+            val += delta;
+        } else {
+            /* Foreign endianess */
+            val = __builtin_bswap16(val);
+            val += delta;
+            val = __builtin_bswap16(val);
         }
-        case 8: {
-            int64_t val;
-            util_memcpyInline(&val, &run->dynfile->data[off], sizeof(val));
-            if (util_rnd64() & 0x1) {
-                val += delta;
-            } else {
-                /* Foreign endianess */
-                val = __builtin_bswap64(val);
-                val += delta;
-                val = __builtin_bswap64(val);
-            }
-            mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
-            break;
+        mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
+        break;
+    }
+    case 4: {
+        int32_t val;
+        util_memcpyInline(&val, &run->dynfile->data[off], sizeof(val));
+        if (util_rnd64() & 0x1) {
+            val += delta;
+        } else {
+            /* Foreign endianess */
+            val = __builtin_bswap32(val);
+            val += delta;
+            val = __builtin_bswap32(val);
         }
-        default: {
-            LOG_F("Unknown variable length size: %zu", varLen);
+        mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
+        break;
+    }
+    case 8: {
+        int64_t val;
+        util_memcpyInline(&val, &run->dynfile->data[off], sizeof(val));
+        if (util_rnd64() & 0x1) {
+            val += delta;
+        } else {
+            /* Foreign endianess */
+            val = __builtin_bswap64(val);
+            val += delta;
+            val = __builtin_bswap64(val);
         }
+        mangle_Overwrite(run, off, (uint8_t*)&val, varLen, printable);
+        break;
+    }
+    default: {
+        LOG_F("Unknown variable length size: %zu", varLen);
+    }
     }
 }
 
@@ -626,20 +626,20 @@ static void mangle_AddSub(run_t* run, bool printable) {
 
     uint64_t range;
     switch (varLen) {
-        case 1:
-            range = 16;
-            break;
-        case 2:
-            range = 4096;
-            break;
-        case 4:
-            range = 1048576;
-            break;
-        case 8:
-            range = 268435456;
-            break;
-        default:
-            LOG_F("Invalid operand size: %zu", varLen);
+    case 1:
+        range = 16;
+        break;
+    case 2:
+        range = 4096;
+        break;
+    case 4:
+        range = 1048576;
+        break;
+    case 8:
+        range = 268435456;
+        break;
+    default:
+        LOG_F("Invalid operand size: %zu", varLen);
     }
 
     mangle_AddSubWithRange(run, off, varLen, range, printable);
@@ -742,32 +742,32 @@ static void mangle_ASCIINumChange(run_t* run, bool printable) {
     }
 
     switch (util_rndGet(0, 7)) {
-        case 0:
-            val++;
-            break;
-        case 1:
-            val--;
-            break;
-        case 2:
-            val *= 2;
-            break;
-        case 3:
-            val /= 2;
-            break;
-        case 4:
-            val = util_rnd64();
-            break;
-        case 5:
-            val += util_rndGet(1, 256);
-            break;
-        case 6:
-            val -= util_rndGet(1, 256);
-            break;
-        case 7:
-            val = ~(val);
-            break;
-        default:
-            LOG_F("Invalid choice");
+    case 0:
+        val++;
+        break;
+    case 1:
+        val--;
+        break;
+    case 2:
+        val *= 2;
+        break;
+    case 3:
+        val /= 2;
+        break;
+    case 4:
+        val = util_rnd64();
+        break;
+    case 5:
+        val += util_rndGet(1, 256);
+        break;
+    case 6:
+        val -= util_rndGet(1, 256);
+        break;
+    case 7:
+        val = ~(val);
+        break;
+    default:
+        LOG_F("Invalid choice");
     };
 
     char buf[20];
@@ -805,27 +805,27 @@ static void mangle_Resize(run_t* run, bool printable) {
 
     uint64_t choice = util_rndGet(0, 32);
     switch (choice) {
-        case 0: /* Set new size arbitrarily */
-            newsz = (ssize_t)util_rndGet(1, run->global->mutate.maxInputSz);
-            break;
-        case 1 ... 4: /* Increase size by a small value */
-            newsz = oldsz + (ssize_t)util_rndGet(0, 8);
-            break;
-        case 5: /* Increase size by a larger value */
-            newsz = oldsz + (ssize_t)util_rndGet(9, 128);
-            break;
-        case 6 ... 9: /* Decrease size by a small value */
-            newsz = oldsz - (ssize_t)util_rndGet(0, 8);
-            break;
-        case 10: /* Decrease size by a larger value */
-            newsz = oldsz - (ssize_t)util_rndGet(9, 128);
-            break;
-        case 11 ... 32: /* Do nothing */
-            newsz = oldsz;
-            break;
-        default:
-            LOG_F("Illegal value from util_rndGet: %" PRIu64, choice);
-            break;
+    case 0: /* Set new size arbitrarily */
+        newsz = (ssize_t)util_rndGet(1, run->global->mutate.maxInputSz);
+        break;
+    case 1 ... 4: /* Increase size by a small value */
+        newsz = oldsz + (ssize_t)util_rndGet(0, 8);
+        break;
+    case 5: /* Increase size by a larger value */
+        newsz = oldsz + (ssize_t)util_rndGet(9, 128);
+        break;
+    case 6 ... 9: /* Decrease size by a small value */
+        newsz = oldsz - (ssize_t)util_rndGet(0, 8);
+        break;
+    case 10: /* Decrease size by a larger value */
+        newsz = oldsz - (ssize_t)util_rndGet(9, 128);
+        break;
+    case 11 ... 32: /* Do nothing */
+        newsz = oldsz;
+        break;
+    default:
+        LOG_F("Illegal value from util_rndGet: %" PRIu64, choice);
+        break;
     }
     if (newsz < 1) {
         newsz = 1;
diff --git a/netbsd/trace.c b/netbsd/trace.c
index 8073c845..da57ec5d 100644
--- a/netbsd/trace.c
+++ b/netbsd/trace.c
@@ -487,73 +487,72 @@ static void arch_traceEvent(run_t* run HF_ATTR_UNUSED, pid_t pid) {
         PLOG_E("ptrace(PT_GET_SIGINFO, pid=%d)", (int)pid);
     } else {
         switch (info.psi_siginfo.si_code) {
-            case TRAP_BRKPT:
-                /* Software breakpoint trap, pass it over to tracee */
-                sig = SIGTRAP;
-                LOG_D("PID: %d breakpoint software trap (TRAP_BRKPT)", pid);
-                break;
-            case TRAP_TRACE:
-                /* Single step unused */
-                LOG_E("PID: %d unexpected single step trace trap (TRAP_TRACE)", pid);
-                break;
-            case TRAP_EXEC:
-                /* exec(3) trap, ignore */
-                LOG_D("PID: %d breakpoint software trap (TRAP_EXEC)", pid);
-                break;
-            case TRAP_CHLD:
-            case TRAP_LWP:
-                /* Child/LWP trap, unused */
-                if (ptrace(PT_GET_PROCESS_STATE, pid, &state, sizeof(state)) != -1) {
-                    switch (state.pe_report_event) {
-                        case PTRACE_FORK:
-                            LOG_D("PID: %d child trap (TRAP_CHLD) : fork", (int)pid);
-                            break;
-                        case PTRACE_VFORK:
-                            LOG_D("PID: %d child trap (TRAP_CHLD) : vfork", (int)pid);
-                            break;
-                        case PTRACE_VFORK_DONE:
-                            LOG_D("PID: %d child trap (TRAP_CHLD) : vfork (PTRACE_VFORK_DONE)",
-                                (int)pid);
-                            break;
+        case TRAP_BRKPT:
+            /* Software breakpoint trap, pass it over to tracee */
+            sig = SIGTRAP;
+            LOG_D("PID: %d breakpoint software trap (TRAP_BRKPT)", pid);
+            break;
+        case TRAP_TRACE:
+            /* Single step unused */
+            LOG_E("PID: %d unexpected single step trace trap (TRAP_TRACE)", pid);
+            break;
+        case TRAP_EXEC:
+            /* exec(3) trap, ignore */
+            LOG_D("PID: %d breakpoint software trap (TRAP_EXEC)", pid);
+            break;
+        case TRAP_CHLD:
+        case TRAP_LWP:
+            /* Child/LWP trap, unused */
+            if (ptrace(PT_GET_PROCESS_STATE, pid, &state, sizeof(state)) != -1) {
+                switch (state.pe_report_event) {
+                case PTRACE_FORK:
+                    LOG_D("PID: %d child trap (TRAP_CHLD) : fork", (int)pid);
+                    break;
+                case PTRACE_VFORK:
+                    LOG_D("PID: %d child trap (TRAP_CHLD) : vfork", (int)pid);
+                    break;
+                case PTRACE_VFORK_DONE:
+                    LOG_D("PID: %d child trap (TRAP_CHLD) : vfork (PTRACE_VFORK_DONE)", (int)pid);
+                    break;
 #ifdef PTRACE_POSIX_SPAWN
-                        case PTRACE_POSIX_SPAWN:
-                            LOG_D("PID: %d child trap (TRAP_CHLD) : spawn (POSIX_SPAWN)", (int)pid);
-                            break;
+                case PTRACE_POSIX_SPAWN:
+                    LOG_D("PID: %d child trap (TRAP_CHLD) : spawn (POSIX_SPAWN)", (int)pid);
+                    break;
 #endif
-                        case PTRACE_LWP_CREATE:
-                            LOG_E("PID: %d unexpected lwp trap (TRAP_LWP) : create "
-                                  "(PTRACE_LWP_CREATE)",
-                                (int)pid);
-                            break;
-                        case PTRACE_LWP_EXIT:
-                            LOG_E("PID: %d unexpected lwp trap (TRAP_LWP) : exit (PTRACE_LWP_EXIT)",
-                                (int)pid);
-                            break;
-                        default:
-                            LOG_D("PID: %d unknown child/lwp trap (TRAP_LWP/TRAP_CHLD) : unknown "
-                                  "pe_report_event=%d",
-                                (int)pid, state.pe_report_event);
-                            break;
-                    }
+                case PTRACE_LWP_CREATE:
+                    LOG_E("PID: %d unexpected lwp trap (TRAP_LWP) : create "
+                          "(PTRACE_LWP_CREATE)",
+                        (int)pid);
+                    break;
+                case PTRACE_LWP_EXIT:
+                    LOG_E("PID: %d unexpected lwp trap (TRAP_LWP) : exit (PTRACE_LWP_EXIT)",
+                        (int)pid);
+                    break;
+                default:
+                    LOG_D("PID: %d unknown child/lwp trap (TRAP_LWP/TRAP_CHLD) : unknown "
+                          "pe_report_event=%d",
+                        (int)pid, state.pe_report_event);
+                    break;
                 }
-                break;
-            case TRAP_DBREG:
-                /* Debug Register trap unused */
-                LOG_E("PID: %d unexpected debug register trap (TRAP_DBREG)", pid);
-                break;
-            case TRAP_SCE:
-                /* Syscall Enter trap unused */
-                LOG_E("PID: %d unexpected syscall enter trap (TRAP_SCE)", pid);
-                break;
-            case TRAP_SCX:
-                /* Syscall Exit trap unused */
-                LOG_E("PID: %d unexpected syscall exit trap (TRAP_SCX)", pid);
-                break;
-            default:
-                /* Other trap, pass it over to tracee */
-                sig = SIGTRAP;
-                LOG_D("PID: %d other trap si_code=%d", pid, info.psi_siginfo.si_code);
-                break;
+            }
+            break;
+        case TRAP_DBREG:
+            /* Debug Register trap unused */
+            LOG_E("PID: %d unexpected debug register trap (TRAP_DBREG)", pid);
+            break;
+        case TRAP_SCE:
+            /* Syscall Enter trap unused */
+            LOG_E("PID: %d unexpected syscall enter trap (TRAP_SCE)", pid);
+            break;
+        case TRAP_SCX:
+            /* Syscall Exit trap unused */
+            LOG_E("PID: %d unexpected syscall exit trap (TRAP_SCX)", pid);
+            break;
+        default:
+            /* Other trap, pass it over to tracee */
+            sig = SIGTRAP;
+            LOG_D("PID: %d other trap si_code=%d", pid, info.psi_siginfo.si_code);
+            break;
         }
     }
 
diff --git a/socketfuzzer/vulnserver_cov.c b/socketfuzzer/vulnserver_cov.c
index a9d29cb1..ca8af8da 100644
--- a/socketfuzzer/vulnserver_cov.c
+++ b/socketfuzzer/vulnserver_cov.c
@@ -60,34 +60,34 @@ void doprocessing(int sock, int serversock) {
 
         printf("# vulnserver_cov: Received data with len: %i on state: %i\n", len, n);
         switch (data[0]) {
-            case 'A':
-                handleData0(data, len);
-                write(sock, "ok", 2);
-                break;
-            case 'B':
-                handleData1(data, len);
-                write(sock, "ok", 2);
-                break;
-            case 'C':
-                handleData2(data, len);
-                write(sock, "ok", 2);
-                break;
-            case 'D':
-                handleData3(data, len);
-                write(sock, "ok", 2);
-                break;
-            case 'E':
-                handleData4(data, len);
-                write(sock, "ok", 2);
-                break;
-            case 'F':
-                handleData5(data, len);
-                write(sock, "ok", 2);
-                // close the main server socket whoooops
-                close(serversock);
-                break;
-            default:
-                return;
+        case 'A':
+            handleData0(data, len);
+            write(sock, "ok", 2);
+            break;
+        case 'B':
+            handleData1(data, len);
+            write(sock, "ok", 2);
+            break;
+        case 'C':
+            handleData2(data, len);
+            write(sock, "ok", 2);
+            break;
+        case 'D':
+            handleData3(data, len);
+            write(sock, "ok", 2);
+            break;
+        case 'E':
+            handleData4(data, len);
+            write(sock, "ok", 2);
+            break;
+        case 'F':
+            handleData5(data, len);
+            write(sock, "ok", 2);
+            // close the main server socket whoooops
+            close(serversock);
+            break;
+        default:
+            return;
         }
 
         n++;
diff --git a/subproc.c b/subproc.c
index b7be807f..3def3954 100644
--- a/subproc.c
+++ b/subproc.c
@@ -80,42 +80,42 @@ const char* subproc_StatusToStr(int status) {
 #define __LINUX_WPTRACEEVENT(x) ((x & 0xff0000) >> 16)
     if (WSTOPSIG(status) == SIGTRAP && __LINUX_WPTRACEEVENT(status) != 0) {
         switch (__LINUX_WPTRACEEVENT(status)) {
-            case PTRACE_EVENT_FORK:
-                snprintf(str, sizeof(str), "EVENT (Linux) - fork - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            case PTRACE_EVENT_VFORK:
-                snprintf(str, sizeof(str), "EVENT (Linux) - vfork - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            case PTRACE_EVENT_CLONE:
-                snprintf(str, sizeof(str), "EVENT (Linux) - clone - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            case PTRACE_EVENT_EXEC:
-                snprintf(str, sizeof(str), "EVENT (Linux) - exec - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            case PTRACE_EVENT_VFORK_DONE:
-                snprintf(str, sizeof(str), "EVENT (Linux) - vfork_done - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            case PTRACE_EVENT_EXIT:
-                snprintf(str, sizeof(str), "EVENT (Linux) - exit - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            case PTRACE_EVENT_SECCOMP:
-                snprintf(str, sizeof(str), "EVENT (Linux) - seccomp - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            case PTRACE_EVENT_STOP:
-                snprintf(str, sizeof(str), "EVENT (Linux) - stop - with signal: %d (%s)",
-                    WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
-            default:
-                snprintf(str, sizeof(str), "EVENT (Linux) UNKNOWN (%d): with signal: %d (%s)",
-                    __LINUX_WPTRACEEVENT(status), WSTOPSIG(status), strsignal(WSTOPSIG(status)));
-                return str;
+        case PTRACE_EVENT_FORK:
+            snprintf(str, sizeof(str), "EVENT (Linux) - fork - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        case PTRACE_EVENT_VFORK:
+            snprintf(str, sizeof(str), "EVENT (Linux) - vfork - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        case PTRACE_EVENT_CLONE:
+            snprintf(str, sizeof(str), "EVENT (Linux) - clone - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        case PTRACE_EVENT_EXEC:
+            snprintf(str, sizeof(str), "EVENT (Linux) - exec - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        case PTRACE_EVENT_VFORK_DONE:
+            snprintf(str, sizeof(str), "EVENT (Linux) - vfork_done - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        case PTRACE_EVENT_EXIT:
+            snprintf(str, sizeof(str), "EVENT (Linux) - exit - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        case PTRACE_EVENT_SECCOMP:
+            snprintf(str, sizeof(str), "EVENT (Linux) - seccomp - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        case PTRACE_EVENT_STOP:
+            snprintf(str, sizeof(str), "EVENT (Linux) - stop - with signal: %d (%s)",
+                WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
+        default:
+            snprintf(str, sizeof(str), "EVENT (Linux) UNKNOWN (%d): with signal: %d (%s)",
+                __LINUX_WPTRACEEVENT(status), WSTOPSIG(status), strsignal(WSTOPSIG(status)));
+            return str;
         }
     }
 #endif /*  defined(PTRACE_EVENT_STOP)  */
@@ -155,32 +155,32 @@ bool subproc_persistentModeStateMachine(run_t* run) {
 
     for (;;) {
         switch (run->runState) {
-            case _HF_RS_WAITING_FOR_INITIAL_READY: {
-                if (!subproc_persistentGetReady(run)) {
-                    return false;
-                }
-                run->runState = _HF_RS_SEND_DATA;
-            }; break;
-            case _HF_RS_SEND_DATA: {
-                if (!subproc_persistentSendFileIndicator(run)) {
-                    LOG_E("Could not send the file size indicator to the persistent process. "
-                          "Killing the process pid=%d",
-                        (int)run->pid);
-                    kill(run->pid, SIGKILL);
-                    return false;
-                }
-                run->runState = _HF_RS_WAITING_FOR_READY;
-            }; break;
-            case _HF_RS_WAITING_FOR_READY: {
-                if (!subproc_persistentGetReady(run)) {
-                    return false;
-                }
-                run->runState = _HF_RS_SEND_DATA;
-                /* The current persistent round is done */
-                return true;
-            }; break;
-            default:
-                LOG_F("Unknown runState: %d", run->runState);
+        case _HF_RS_WAITING_FOR_INITIAL_READY: {
+            if (!subproc_persistentGetReady(run)) {
+                return false;
+            }
+            run->runState = _HF_RS_SEND_DATA;
+        }; break;
+        case _HF_RS_SEND_DATA: {
+            if (!subproc_persistentSendFileIndicator(run)) {
+                LOG_E("Could not send the file size indicator to the persistent process. "
+                      "Killing the process pid=%d",
+                    (int)run->pid);
+                kill(run->pid, SIGKILL);
+                return false;
+            }
+            run->runState = _HF_RS_WAITING_FOR_READY;
+        }; break;
+        case _HF_RS_WAITING_FOR_READY: {
+            if (!subproc_persistentGetReady(run)) {
+                return false;
+            }
+            run->runState = _HF_RS_SEND_DATA;
+            /* The current persistent round is done */
+            return true;
+        }; break;
+        default:
+            LOG_F("Unknown runState: %d", run->runState);
         }
     }
 }