diff --git a/include/terminal.h b/include/terminal.h
index 6280ff3d8..1790b1e91 100644
--- a/include/terminal.h
+++ b/include/terminal.h
@@ -42,11 +42,11 @@ HC_API_CALL void *thread_keypress (void *p);
 void SetConsoleWindowSize (const int x);
 #endif
 
-int tty_break(void);
-int tty_getchar(void);
-int tty_fix(void);
+int tty_break (void);
+int tty_getchar (void);
+int tty_fix (void);
 
-bool is_stdout_terminal(void);
+bool is_stdout_terminal (void);
 
 void compress_terminal_line_length (char *out_buf, const size_t keep_from_beginning, const size_t keep_from_end);
 
diff --git a/src/affinity.c b/src/affinity.c
index 920f24f87..8a99279e4 100644
--- a/src/affinity.c
+++ b/src/affinity.c
@@ -70,7 +70,7 @@ int set_cpu_affinity (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx)
   #elif defined(__NetBSD__)
   cpuset_t * cpuset;
   const int cpu_id_max = 8 * cpuset_size (cpuset);
-  cpuset = cpuset_create();
+  cpuset = cpuset_create ();
   if (cpuset == NULL)
   {
     event_log_error (hashcat_ctx, "cpuset_create() failed with error: %d", errno);
@@ -157,7 +157,7 @@ int set_cpu_affinity (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx)
 
   pthread_t thread = pthread_self ();
 
-  const int rc = pthread_setaffinity_np (thread, cpuset_size(cpuset), cpuset);
+  const int rc = pthread_setaffinity_np (thread, cpuset_size (cpuset), cpuset);
 
   if (rc != 0)
   {
diff --git a/src/backend.c b/src/backend.c
index 53d38ee12..cc5dea3c3 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -353,7 +353,7 @@ static bool setup_opencl_device_types_filter (hashcat_ctx_t *hashcat_ctx, const
   {
     #if defined (__APPLE__)
 
-    if (is_apple_silicon() == true)
+    if (is_apple_silicon () == true)
     {
       // With Apple's M1* use GPU only, because CPU device it is not recognized by OpenCL
 
@@ -1747,7 +1747,7 @@ int run_hip_kernel_bzero (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_
 
     const u64 kernel_threads = device_param->kernel_wgs_bzero;
 
-    u64 num_elements = CEILDIV(num16d, kernel_threads);
+    u64 num_elements = CEILDIV (num16d, kernel_threads);
 
     hipFunction_t function = device_param->hip_function_bzero;
 
@@ -2020,7 +2020,7 @@ int run_opencl_kernel_bzero (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *devi
   {
     const u64 kernel_threads = device_param->kernel_wgs_bzero;
 
-    u64 num_elements = round_up_multiple_64(num16d, kernel_threads);
+    u64 num_elements = round_up_multiple_64 (num16d, kernel_threads);
 
     cl_kernel kernel = device_param->opencl_kernel_bzero;
 
@@ -5791,7 +5791,7 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
       device_param->use_opencl20 = false;
       device_param->use_opencl21 = false;
 
-      device_param->is_apple_silicon = is_apple_silicon();
+      device_param->is_apple_silicon = is_apple_silicon ();
 
       // some attributes have to be hardcoded values because they are used for instance in the build options
 
@@ -9561,7 +9561,7 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
       build_options_len += snprintf (build_options_buf + build_options_len, build_options_sz - build_options_len, "-D M2S(x)=XM2S(x) ");
 
       #if defined (__APPLE__)
-      if (is_apple_silicon() == true)
+      if (is_apple_silicon () == true)
       {
         build_options_len += snprintf (build_options_buf + build_options_len, build_options_sz - build_options_len, "-D IS_APPLE_SILICON ");
       }
diff --git a/src/brain.c b/src/brain.c
index a12a1375b..bd97d9695 100644
--- a/src/brain.c
+++ b/src/brain.c
@@ -3369,7 +3369,7 @@ int brain_server (const char *listen_host, const int listen_port, const char *br
   close (server_fd);
 
   #if defined (_WIN)
-  WSACleanup();
+  WSACleanup ();
   #endif
 
   return 0;
diff --git a/src/ext_iokit.c b/src/ext_iokit.c
index e638ba7c7..adeb9291d 100644
--- a/src/ext_iokit.c
+++ b/src/ext_iokit.c
@@ -27,7 +27,7 @@ UInt32 hm_IOKIT_strtoul (const char *str, int size, int base)
     }
     else
     {
-      total += (unsigned char)(str[i] << (size - 1 - i) * 8);
+      total += (unsigned char) (str[i] << (size - 1 - i) * 8);
     }
   }
   return total;
@@ -37,7 +37,7 @@ void hm_IOKIT_ultostr (char *str, UInt32 val)
 {
   str[0] = '\0';
 
-  sprintf (str, "%c%c%c%c", (unsigned int)(val >> 24), (unsigned int)(val >> 16), (unsigned int)(val >> 8), (unsigned int)(val));
+  sprintf (str, "%c%c%c%c", (unsigned int) (val >> 24), (unsigned int) (val >> 16), (unsigned int) (val >> 8), (unsigned int) (val));
 }
 
 kern_return_t hm_IOKIT_SMCOpen (void *hashcat_ctx, io_connect_t *conn)
@@ -68,7 +68,7 @@ kern_return_t hm_IOKIT_SMCOpen (void *hashcat_ctx, io_connect_t *conn)
     return 1;
   }
 
-  result = IOServiceOpen (device, mach_task_self(), 0, conn);
+  result = IOServiceOpen (device, mach_task_self (), 0, conn);
 
   IOObjectRelease (device);
 
@@ -124,7 +124,7 @@ kern_return_t hm_IOKIT_SMCReadKey (UInt32Char_t key, SMCVal_t *val, io_connect_t
 
   if (hm_IOKIT_SMCCall (KERNEL_INDEX_SMC, &inData, &outData, conn) != kIOReturnSuccess) return 1;
 
-  memcpy(val->bytes, outData.bytes, sizeof(outData.bytes));
+  memcpy (val->bytes, outData.bytes, sizeof (outData.bytes));
 
   return kIOReturnSuccess;
 }
@@ -145,9 +145,9 @@ int hm_IOKIT_SMCGetSensorGraphicHot (void *hashcat_ctx)
 
     if (val.dataSize > 0)
     {
-      if (strcmp(val.dataType, DATATYPE_UINT8) == 0)
+      if (strcmp (val.dataType, DATATYPE_UINT8) == 0)
       {
-        alarm = hm_IOKIT_strtoul ((char *)val.bytes, val.dataSize, 10);
+        alarm = hm_IOKIT_strtoul ((char *) val.bytes, val.dataSize, 10);
       }
     }
 
@@ -171,7 +171,7 @@ int hm_IOKIT_SMCGetTemperature (void *hashcat_ctx, char *key, double *temp)
   {
     if (val.dataSize > 0)
     {
-      if (strcmp(val.dataType, DATATYPE_SP78) == 0)
+      if (strcmp (val.dataType, DATATYPE_SP78) == 0)
       {
         // convert sp78 value to temperature
         int intValue = val.bytes[0] * 256 + (unsigned char)val.bytes[1];
@@ -200,17 +200,17 @@ bool hm_IOKIT_SMCGetFanRPM (char *key, io_connect_t conn, float *ret)
   {
     if (val.dataSize > 0)
     {
-      if (strcmp(val.dataType, DATATYPE_FLT) == 0)
+      if (strcmp (val.dataType, DATATYPE_FLT) == 0)
       {
         *ret = *(float *) val.bytes;
 
         return true;
       }
 
-      if (strcmp(val.dataType, DATATYPE_FPE2) == 0)
+      if (strcmp (val.dataType, DATATYPE_FPE2) == 0)
       {
         // convert fpe2 value to RPM
-        *ret = ntohs (*(UInt16*)val.bytes) / 4.0;
+        *ret = ntohs (*(UInt16*) val.bytes) / 4.0;
 
         return true;
       }
diff --git a/src/ext_metal.m b/src/ext_metal.m
index 7bd4aafa9..7cdbdf0d4 100644
--- a/src/ext_metal.m
+++ b/src/ext_metal.m
@@ -56,7 +56,7 @@ static bool iokit_getGPUCore (void *hashcat_ctx, int *gpu_core)
 
   // "gpu-core-count" is present only on Apple Silicon
 
-  CFNumberRef num = IORegistryEntryCreateCFProperty(service, CFSTR("gpu-core-count"), kCFAllocatorDefault, 0);
+  CFNumberRef num = IORegistryEntryCreateCFProperty (service, CFSTR ("gpu-core-count"), kCFAllocatorDefault, 0);
 
   int gc = 0;
 
@@ -216,7 +216,7 @@ int mtl_init (void *hashcat_ctx)
 
   mtl->devices = nil;
 
-  if (MTLCreateSystemDefaultDevice() == nil)
+  if (MTLCreateSystemDefaultDevice () == nil)
   {
     event_log_error (hashcat_ctx, "Metal is not supported on this computer");
 
@@ -262,7 +262,7 @@ int hc_mtlDeviceGetCount (void *hashcat_ctx, int *count)
 
   if (mtl == nil) return -1;
 
-  CFArrayRef devices = (CFArrayRef) MTLCopyAllDevices();
+  CFArrayRef devices = (CFArrayRef) MTLCopyAllDevices ();
 
   if (devices == nil)
   {
@@ -395,7 +395,7 @@ int hc_mtlDeviceGetAttribute (void *hashcat_ctx, int *pi, metalDeviceAttribute_t
     case MTL_DEVICE_ATTRIBUTE_UNIFIED_MEMORY:
       *pi = 0;
 
-      SEL hasUnifiedMemorySelector = NSSelectorFromString(@"hasUnifiedMemory");
+      SEL hasUnifiedMemorySelector = NSSelectorFromString (@"hasUnifiedMemory");
 
       hc_mtlInvocationHelper (metal_device, hasUnifiedMemorySelector, &valBool);
 
@@ -467,7 +467,7 @@ int hc_mtlDeviceGetAttribute (void *hashcat_ctx, int *pi, metalDeviceAttribute_t
     case MTL_DEVICE_ATTRIBUTE_MAX_TRANSFER_RATE:
       val64 = 0;
 
-      SEL maxTransferRateSelector = NSSelectorFromString(@"maxTransferRate");
+      SEL maxTransferRateSelector = NSSelectorFromString (@"maxTransferRate");
 
       hc_mtlInvocationHelper (metal_device, maxTransferRateSelector, &val64);
 
@@ -497,7 +497,7 @@ int hc_mtlDeviceGetAttribute (void *hashcat_ctx, int *pi, metalDeviceAttribute_t
     case MTL_DEVICE_ATTRIBUTE_PHYSICAL_LOCATION:
       *pi = 0;
 
-      SEL locationSelector = NSSelectorFromString(@"location");
+      SEL locationSelector = NSSelectorFromString (@"location");
       valULong = 0;
 
       hc_mtlInvocationHelper (metal_device, locationSelector, &valULong);
@@ -509,7 +509,7 @@ int hc_mtlDeviceGetAttribute (void *hashcat_ctx, int *pi, metalDeviceAttribute_t
     case MTL_DEVICE_ATTRIBUTE_LOCATION_NUMBER:
       *pi = 0;
 
-      SEL locationNumberSelector = NSSelectorFromString(@"locationNumber");
+      SEL locationNumberSelector = NSSelectorFromString (@"locationNumber");
 
       valULong = 0;
       hc_mtlInvocationHelper (metal_device, locationNumberSelector, &valULong);
@@ -538,7 +538,7 @@ int hc_mtlMemGetInfo (void *hashcat_ctx, size_t *mem_free, size_t *mem_total)
   vm_size_t page_size = 0;
   unsigned int count = HOST_VM_INFO64_COUNT;
 
-  mach_port_t port = mach_host_self();
+  mach_port_t port = mach_host_self ();
 
   if (host_page_size (port, &page_size) != KERN_SUCCESS)
   {
@@ -580,7 +580,7 @@ int hc_mtlDeviceMaxMemAlloc (void *hashcat_ctx, size_t *bytes, mtl_device_id met
 
   uint64_t memsize = 0;
 
-  SEL maxBufferLengthSelector = NSSelectorFromString(@"maxBufferLength");
+  SEL maxBufferLengthSelector = NSSelectorFromString (@"maxBufferLength");
 
   if (hc_mtlInvocationHelper (metal_device, maxBufferLengthSelector, &memsize) == -1) return -1;
 
@@ -1094,7 +1094,7 @@ int hc_mtlMemcpyDtoH (void *hashcat_ctx, mtl_command_queue command_queue, void *
 
 int hc_mtlRuntimeGetVersionString (void *hashcat_ctx, char *runtimeVersion_str, size_t *size)
 {
-  CFURLRef plist_url = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, CFSTR("/System/Library/Frameworks/Metal.framework/Versions/Current/Resources/version.plist"), kCFURLPOSIXPathStyle, false);
+  CFURLRef plist_url = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, CFSTR ("/System/Library/Frameworks/Metal.framework/Versions/Current/Resources/version.plist"), kCFURLPOSIXPathStyle, false);
 
   if (plist_url == NULL)
   {
@@ -1137,7 +1137,7 @@ int hc_mtlRuntimeGetVersionString (void *hashcat_ctx, char *runtimeVersion_str,
     return -1;
   }
 
-  CFStringRef runtime_version_str = CFRetain (CFDictionaryGetValue (plist_prop, CFSTR("CFBundleVersion")));
+  CFStringRef runtime_version_str = CFRetain (CFDictionaryGetValue (plist_prop, CFSTR ("CFBundleVersion")));
 
   if (runtime_version_str != NULL)
   {
@@ -1290,8 +1290,8 @@ int hc_mtlEncodeComputeCommand (void *hashcat_ctx, mtl_command_encoder metal_com
   CFTimeInterval myGPUStartTime = 0;
   CFTimeInterval myGPUEndTime = 0;
 
-  SEL myGPUStartTimeSelector = NSSelectorFromString(@"GPUStartTime");
-  SEL myGPUEndTimeSelector   = NSSelectorFromString(@"GPUEndTime");
+  SEL myGPUStartTimeSelector = NSSelectorFromString (@"GPUStartTime");
+  SEL myGPUEndTimeSelector   = NSSelectorFromString (@"GPUEndTime");
 
   if (hc_mtlInvocationHelper (metal_command_buffer, myGPUStartTimeSelector, &myGPUStartTime) == -1) return -1;
   if (hc_mtlInvocationHelper (metal_command_buffer, myGPUEndTimeSelector, &myGPUEndTime) == -1) return -1;
@@ -1355,7 +1355,7 @@ int hc_mtlCreateLibraryWithSource (void *hashcat_ctx, mtl_device_id metal_device
 
     if (build_options_buf != nil)
     {
-      //printf("using build_opts from arg:\n%s\n", build_options_buf);
+      //printf ("using build_opts from arg:\n%s\n", build_options_buf);
 
       build_options_dict = [NSMutableDictionary dictionary]; //[[NSMutableDictionary alloc] init];
 
diff --git a/src/filehandling.c b/src/filehandling.c
index 345d45141..8a53faba4 100644
--- a/src/filehandling.c
+++ b/src/filehandling.c
@@ -126,7 +126,7 @@ bool hc_fopen (HCFILE *fp, const char *path, const char *mode)
     {
       if (check[0] == 0x1f && check[1] == 0x8b && check[2] == 0x08)                     is_gzip = true;
       if (check[0] == 0x50 && check[1] == 0x4b && check[2] == 0x03 && check[3] == 0x04) is_zip  = true;
-      if (memcmp(check, XZ_SIG, XZ_SIG_SIZE) == 0)                                      is_xz   = true;
+      if (memcmp (check, XZ_SIG, XZ_SIG_SIZE) == 0)                                     is_xz   = true;
 
       // compressed files with BOM will be undetected!
 
diff --git a/src/folder.c b/src/folder.c
index 531b2e4af..cf35b97e5 100644
--- a/src/folder.c
+++ b/src/folder.c
@@ -67,7 +67,7 @@ static int get_exec_path (char *exec_path, const size_t exec_path_sz)
 
   mib[0] = CTL_KERN;
   mib[1] = KERN_PROC_ARGS;
-  mib[2] = getpid();
+  mib[2] = getpid ();
   mib[3] = KERN_PROC_PATHNAME;
 
   size_t size = exec_path_sz;
diff --git a/src/hwmon.c b/src/hwmon.c
index 9879ab3ac..b1cf2d56e 100644
--- a/src/hwmon.c
+++ b/src/hwmon.c
@@ -246,7 +246,7 @@ int hm_get_temperature_with_devices_idx (hashcat_ctx_t *hashcat_ctx, const int b
 
           char *key = HM_IOKIT_SMC_CPU_PROXIMITY;
 
-          if (hm_IOKIT_SMCGetTemperature(hashcat_ctx, key, &temperature) == -1)
+          if (hm_IOKIT_SMCGetTemperature (hashcat_ctx, key, &temperature) == -1)
           {
             hwmon_ctx->hm_device[backend_device_idx].temperature_get_supported = false;
 
diff --git a/src/main.c b/src/main.c
index 8ff5c59e7..dc6ef0f31 100644
--- a/src/main.c
+++ b/src/main.c
@@ -30,7 +30,7 @@ int _dowildcard = -1;
 
 static void main_log_clear_line (MAYBE_UNUSED const size_t prev_len, MAYBE_UNUSED FILE *fp)
 {
-  if (!is_stdout_terminal()) return;
+  if (!is_stdout_terminal ()) return;
 
   #if defined (_WIN)
 
@@ -81,7 +81,8 @@ static void main_log (hashcat_ctx_t *hashcat_ctx, FILE *fp, const int loglevel)
   #endif
 
   // color stuff pre
-  if (is_stdout_terminal()) {
+  if (is_stdout_terminal ())
+  {
   #if defined (_WIN)
     switch (loglevel)
     {
@@ -111,7 +112,8 @@ static void main_log (hashcat_ctx_t *hashcat_ctx, FILE *fp, const int loglevel)
   fwrite (msg_buf, msg_len, 1, fp);
 
   // color stuff post
-  if (is_stdout_terminal()) {
+  if (is_stdout_terminal ())
+  {
   #if defined (_WIN)
     switch (loglevel)
     {
diff --git a/src/modules/module_15300.c b/src/modules/module_15300.c
index 28134ad10..66d8b7496 100644
--- a/src/modules/module_15300.c
+++ b/src/modules/module_15300.c
@@ -315,7 +315,7 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
 
   // convert back SID
 
-  SID_tmp = (u8 *) hcmalloc ((SID_len + 1) * sizeof(u8));
+  SID_tmp = (u8 *) hcmalloc ((SID_len + 1) * sizeof (u8));
 
   for (u32 i = 0; i < (SID_len / 4); i++)
   {
diff --git a/src/modules/module_23800.c b/src/modules/module_23800.c
index 65a8cf314..73e654198 100644
--- a/src/modules/module_23800.c
+++ b/src/modules/module_23800.c
@@ -160,7 +160,7 @@ static int check_huffman (const unsigned char *next)
       {
         zero_count += 2;
 
-        while (zero_count-- > 0 && i < sizeof(bit_length) / sizeof (bit_length[0]))
+        while (zero_count-- > 0 && i < sizeof (bit_length) / sizeof (bit_length[0]))
         {
           bit_length[i++] = 0;
         }
diff --git a/src/modules/module_25400.c b/src/modules/module_25400.c
index 24b607e67..0506fb470 100644
--- a/src/modules/module_25400.c
+++ b/src/modules/module_25400.c
@@ -390,7 +390,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
   pdf->P = P;
 
   memcpy ( pdf->u_pass_buf, u_pass_buf_pos, 32);
-  pdf->u_pass_len = strlen((char *) pdf->u_pass_buf);
+  pdf->u_pass_len = strlen ((char *) pdf->u_pass_buf);
 
   pdf->enc_md = enc_md;
 
@@ -496,7 +496,11 @@ int module_build_plain_postprocess (MAYBE_UNUSED const hashconfig_t *hashconfig,
   pdf_t *pdf = (pdf_t *) hashes->esalts_buf;
 
   // if the password in tmp->out is equal to the padding, then we recovered just the owner-password
-  if(pdf_tmp->out[0]==padding[0] && pdf_tmp->out[1]==padding[1] && pdf_tmp->out[2]==padding[2] && pdf_tmp->out[3]==padding[3])
+
+  if (pdf_tmp->out[0] == padding[0] &&
+      pdf_tmp->out[1] == padding[1] &&
+      pdf_tmp->out[2] == padding[2] &&
+      pdf_tmp->out[3] == padding[3])
   {
     return snprintf ((char *) dst_buf, dst_sz, "%s    (user password not set)", (char *) src_buf);
   }
@@ -511,14 +515,15 @@ int module_build_plain_postprocess (MAYBE_UNUSED const hashconfig_t *hashconfig,
   const u8 *u8OutPadPtr;
   u8OutPadPtr = (u8*) u32OutPadPtr;
 
-  bool remove_padding=false;
-  int i_padding=0;
-  for(int i=0;i<16;i++)
+  bool remove_padding = false;
+  int i_padding = 0;
+
+  for (int i = 0; i < 16; i++)
   {
-    if(u8OutBufPtr[i]==u8OutPadPtr[i_padding] || remove_padding)
+    if (u8OutBufPtr[i] == u8OutPadPtr[i_padding] || remove_padding)
     {
-    u8OutBufPtr[i]=0x0;
-    remove_padding=true;
+      u8OutBufPtr[i] = 0x0;
+      remove_padding = true;
     }
   }
 
@@ -527,9 +532,13 @@ int module_build_plain_postprocess (MAYBE_UNUSED const hashconfig_t *hashconfig,
   //   TODO would be better to actually also verify the u-value whether we've retrieved the correct user-password,
   //     however, we'd need to include a lot of code/complexity here to do so (or call into 10500 kernel).
   //     this seems relevant: run_kernel (hashcat_ctx, device_param, KERN_RUN_3, 0, 1, false, 0)
-  if(pdf_tmp->out[0]==src_buf[0] && pdf_tmp->out[1]==src_buf[1] && pdf_tmp->out[2]==src_buf[2] && pdf_tmp->out[3]==src_buf[3])
+
+  if (pdf_tmp->out[0] == src_buf[0] &&
+      pdf_tmp->out[1] == src_buf[1] &&
+      pdf_tmp->out[2] == src_buf[2] &&
+      pdf_tmp->out[3] == src_buf[3])
   {
-    if(pdf->u_pass_len==0)
+    if (pdf->u_pass_len == 0)
     {
       // we seem to only have recovered the user-password as we don't have one yet
       return snprintf ((char *) dst_buf, dst_sz, "(user password=%s)", (char *) src_buf);
diff --git a/src/modules/module_25900.c b/src/modules/module_25900.c
index d0d957f79..f36a41c4f 100644
--- a/src/modules/module_25900.c
+++ b/src/modules/module_25900.c
@@ -65,7 +65,7 @@ static const char *SIGNATURE_DEVICE_AUTHENTICATION_CODE = "$knx-ip-secure-device
 static const char *SALT_DEVICE_AUTHENTICATION_CODE      = "device-authentication-code.1.secure.ip.knx.org";
 static const int   ROUNDS_DEVICE_AUTHENTICATION_CODE    = 65536;
 
-char *module_jit_build_options(MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param)
+char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param)
 {
   char *jit_build_options = NULL;
 
@@ -78,7 +78,7 @@ char *module_jit_build_options(MAYBE_UNUSED const hashconfig_t *hashconfig, MAYB
   // NVIDIA GPU
   if (device_param->opencl_device_vendor_id == VENDOR_ID_NV)
   {
-    hc_asprintf(&jit_build_options, "-D _unroll");
+    hc_asprintf (&jit_build_options, "-D _unroll");
   }
 
   // HIP
@@ -90,7 +90,7 @@ char *module_jit_build_options(MAYBE_UNUSED const hashconfig_t *hashconfig, MAYB
   // ROCM
   if ((device_param->opencl_device_vendor_id == VENDOR_ID_AMD) && (device_param->has_vperm == true))
   {
-    hc_asprintf(&jit_build_options, "-D _unroll");
+    hc_asprintf (&jit_build_options, "-D _unroll");
   }
 
   return jit_build_options;
@@ -204,7 +204,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
                 public_value_xor[3],
                 public_value_xor[4],
                 public_value_xor[5] };
-  memcpy (blocks->b1, b1, sizeof(b1));
+  memcpy (blocks->b1, b1, sizeof (b1));
 
   memcpy (blocks->b2, &public_value_xor[6], 16);
 
@@ -213,7 +213,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
   memcpy (blocks->b3, &public_value_xor[22], 10);
 
   // The salt used in the derivation of the device authentication code is constant
-  size_t salt_len = strlen(SALT_DEVICE_AUTHENTICATION_CODE); // exclude the null byte
+  size_t salt_len = strlen (SALT_DEVICE_AUTHENTICATION_CODE); // exclude the null byte
   memcpy (salt->salt_buf, SALT_DEVICE_AUTHENTICATION_CODE, salt_len);
   salt->salt_len = salt_len;
   salt->salt_iter = ROUNDS_DEVICE_AUTHENTICATION_CODE - 1;
@@ -238,8 +238,8 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
   memcpy (&public_value_xor[ 6], &(blocks->b2[0]), 16);
   memcpy (&public_value_xor[22], &(blocks->b3[0]), 10);
 
-  hex_encode(secure_session_identifier, 2, secure_session_identifier_hex);
-  hex_encode(public_value_xor, 32, public_value_xor_hex);
+  hex_encode (secure_session_identifier, 2, secure_session_identifier_hex);
+  hex_encode (public_value_xor, 32, public_value_xor_hex);
 
   const int line_len = snprintf (line_buf, line_size, "%s*%s*%s*%08x%08x%08x%08x",
     SIGNATURE_DEVICE_AUTHENTICATION_CODE,
diff --git a/src/modules/module_28600.c b/src/modules/module_28600.c
index 2e8dde6af..48d995f46 100644
--- a/src/modules/module_28600.c
+++ b/src/modules/module_28600.c
@@ -81,20 +81,20 @@ char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAY
   // NVIDIA GPU
   if (device_param->opencl_device_vendor_id == VENDOR_ID_NV)
   {
-    hc_asprintf(&jit_build_options, "-D _unroll");
+    hc_asprintf (&jit_build_options, "-D _unroll");
   }
 
   // HIP
   if (device_param->opencl_device_vendor_id == VENDOR_ID_AMD_USE_HIP)
   {
-    hc_asprintf(&jit_build_options, "-D _unroll");
+    hc_asprintf (&jit_build_options, "-D _unroll");
   }
 
   // ROCM
   if ((device_param->opencl_device_vendor_id == VENDOR_ID_AMD) &&
       (device_param->has_vperm == true))
   {
-    hc_asprintf(&jit_build_options, "-D _unroll");
+    hc_asprintf (&jit_build_options, "-D _unroll");
   }
 
   return jit_build_options;
@@ -191,22 +191,22 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
 
   memcpy (postgres_sha256->salt, tmp_buf, tmp_len);
 
-  postgres_sha256->salt[ 0] = byte_swap_32(postgres_sha256->salt[ 0]);
-  postgres_sha256->salt[ 1] = byte_swap_32(postgres_sha256->salt[ 1]);
-  postgres_sha256->salt[ 2] = byte_swap_32(postgres_sha256->salt[ 2]);
-  postgres_sha256->salt[ 3] = byte_swap_32(postgres_sha256->salt[ 3]);
-  postgres_sha256->salt[ 4] = byte_swap_32(postgres_sha256->salt[ 4]);
-  postgres_sha256->salt[ 5] = byte_swap_32(postgres_sha256->salt[ 5]);
-  postgres_sha256->salt[ 6] = byte_swap_32(postgres_sha256->salt[ 6]);
-  postgres_sha256->salt[ 7] = byte_swap_32(postgres_sha256->salt[ 7]);
-  postgres_sha256->salt[ 8] = byte_swap_32(postgres_sha256->salt[ 8]);
-  postgres_sha256->salt[ 9] = byte_swap_32(postgres_sha256->salt[ 9]);
-  postgres_sha256->salt[10] = byte_swap_32(postgres_sha256->salt[10]);
-  postgres_sha256->salt[11] = byte_swap_32(postgres_sha256->salt[11]);
-  postgres_sha256->salt[12] = byte_swap_32(postgres_sha256->salt[12]);
-  postgres_sha256->salt[13] = byte_swap_32(postgres_sha256->salt[13]);
-  postgres_sha256->salt[14] = byte_swap_32(postgres_sha256->salt[14]);
-  postgres_sha256->salt[15] = byte_swap_32(postgres_sha256->salt[15]);
+  postgres_sha256->salt[ 0] = byte_swap_32 (postgres_sha256->salt[ 0]);
+  postgres_sha256->salt[ 1] = byte_swap_32 (postgres_sha256->salt[ 1]);
+  postgres_sha256->salt[ 2] = byte_swap_32 (postgres_sha256->salt[ 2]);
+  postgres_sha256->salt[ 3] = byte_swap_32 (postgres_sha256->salt[ 3]);
+  postgres_sha256->salt[ 4] = byte_swap_32 (postgres_sha256->salt[ 4]);
+  postgres_sha256->salt[ 5] = byte_swap_32 (postgres_sha256->salt[ 5]);
+  postgres_sha256->salt[ 6] = byte_swap_32 (postgres_sha256->salt[ 6]);
+  postgres_sha256->salt[ 7] = byte_swap_32 (postgres_sha256->salt[ 7]);
+  postgres_sha256->salt[ 8] = byte_swap_32 (postgres_sha256->salt[ 8]);
+  postgres_sha256->salt[ 9] = byte_swap_32 (postgres_sha256->salt[ 9]);
+  postgres_sha256->salt[10] = byte_swap_32 (postgres_sha256->salt[10]);
+  postgres_sha256->salt[11] = byte_swap_32 (postgres_sha256->salt[11]);
+  postgres_sha256->salt[12] = byte_swap_32 (postgres_sha256->salt[12]);
+  postgres_sha256->salt[13] = byte_swap_32 (postgres_sha256->salt[13]);
+  postgres_sha256->salt[14] = byte_swap_32 (postgres_sha256->salt[14]);
+  postgres_sha256->salt[15] = byte_swap_32 (postgres_sha256->salt[15]);
 
   postgres_sha256->salt_len = tmp_len;
   salt->salt_len            = tmp_len;
@@ -245,7 +245,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
   const u8 *hash_pos = token.buf[4];
   const int hash_len = token.len[4];
 
-  memset (tmp_buf, 0, sizeof(tmp_buf));
+  memset (tmp_buf, 0, sizeof (tmp_buf));
 
   tmp_len = base64_decode (base64_to_int, hash_pos, hash_len, tmp_buf);
 
diff --git a/src/terminal.c b/src/terminal.c
index 3416e8fbc..38a141f3e 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -477,7 +477,7 @@ int tty_getchar ()
   if (retval ==  0) return  0;
   if (retval == -1) return -1;
 
-  return getchar();
+  return getchar ();
 }
 
 int tty_fix ()
@@ -526,7 +526,7 @@ int tty_getchar ()
   if (retval ==  0) return  0;
   if (retval == -1) return -1;
 
-  return getchar();
+  return getchar ();
 }
 
 int tty_fix ()
@@ -600,12 +600,12 @@ int tty_fix ()
 }
 #endif
 
-bool is_stdout_terminal(void)
+bool is_stdout_terminal (void)
 {
 #if defined(_WIN)
-  return _isatty(_fileno(stdout));
+  return _isatty(_fileno (stdout));
 #else
-  return isatty(fileno(stdout));
+  return isatty (fileno (stdout));
 #endif
 }
 
@@ -652,22 +652,22 @@ void hash_info_single_json (hashcat_ctx_t *hashcat_ctx, user_options_extra_t *us
     {
       u32 t = hashconfig->salt_type;
       const char *t_desc = (t == SALT_TYPE_EMBEDDED) ? "embedded" : (t == SALT_TYPE_GENERIC) ? "generic" : "virtual";
-      printf("\"salt_type\": \"%s\", ", t_desc);
-      printf("\"salt_len_min\": %u, ", hashconfig->salt_min);
-      printf("\"salt_len_max\": %u, ", hashconfig->salt_max);
+      printf ("\"salt_type\": \"%s\", ", t_desc);
+      printf ("\"salt_len_min\": %u, ", hashconfig->salt_min);
+      printf ("\"salt_len_max\": %u, ", hashconfig->salt_max);
     }
 
     if ((hashconfig->has_pure_kernel) && (hashconfig->has_optimized_kernel))
     {
-      printf("\"kernel_type\": %s, ", "[ \"pure\", \"optimized\" ]");
+      printf ("\"kernel_type\": %s, ", "[ \"pure\", \"optimized\" ]");
     }
     else if (hashconfig->has_pure_kernel)
     {
-      printf("\"kernel_type\": %s, ", "[ \"pure\" ]");
+      printf ("\"kernel_type\": %s, ", "[ \"pure\" ]");
     }
     else if (hashconfig->has_optimized_kernel)
     {
-      printf("\"kernel_type\": %s, ", "[ \"optimized\" ]");
+      printf ("\"kernel_type\": %s, ", "[ \"optimized\" ]");
     }
 
     if ((hashconfig->st_hash != NULL) && (hashconfig->st_pass != NULL))
@@ -676,18 +676,18 @@ void hash_info_single_json (hashcat_ctx_t *hashcat_ctx, user_options_extra_t *us
       {
         if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE_OPTIONAL)
         {
-          printf("\"example_hash_format\": \"%s\", ", "hex-encoded");
+          printf ("\"example_hash_format\": \"%s\", ", "hex-encoded");
         }
         else
         {
-          printf("\"example_hash_format\": \"%s\", ", "hex-encoded (binary file only)");
+          printf ("\"example_hash_format\": \"%s\", ", "hex-encoded (binary file only)");
         }
-        printf("\"example_hash\": \"%s\", ", hashconfig->st_hash);
+        printf ("\"example_hash\": \"%s\", ", hashconfig->st_hash);
       }
       else
       {
-        printf("\"example_hash_format\": \"%s\", ", "plain");
-        printf("\"example_hash\": \"%s\", ", hashconfig->st_hash);
+        printf ("\"example_hash_format\": \"%s\", ", "plain");
+        printf ("\"example_hash\": \"%s\", ", hashconfig->st_hash);
       }
 
       if (need_hexify ((const u8 *) hashconfig->st_pass, strlen (hashconfig->st_pass), user_options_extra->separator, false))
@@ -709,7 +709,7 @@ void hash_info_single_json (hashcat_ctx_t *hashcat_ctx, user_options_extra_t *us
         tmp_buf[tmp_len++] = ']';
         tmp_buf[tmp_len++] = 0;
 
-        printf("\"example_pass\": \"%s\", ", tmp_buf);
+        printf ("\"example_pass\": \"%s\", ", tmp_buf);
 
         hcfree (tmp_buf);
       }
@@ -723,46 +723,46 @@ void hash_info_single_json (hashcat_ctx_t *hashcat_ctx, user_options_extra_t *us
 
         uppercase ((u8 *) tmp_buf, st_pass_len);
 
-        printf("\"example_pass\": \"%s\", ", tmp_buf);
+        printf ("\"example_pass\": \"%s\", ", tmp_buf);
 
         hcfree (tmp_buf);
       }
       else
       {
-        printf("\"example_pass\": \"%s\", ", hashconfig->st_pass);
+        printf ("\"example_pass\": \"%s\", ", hashconfig->st_pass);
       }
     }
     else
     {
-      printf("\"example_hash_format\": \"%s\", ", "N/A");
-      printf("\"example_hash\": \"%s\", ", "N/A");
-      printf("\"example_pass\": \"%s\", ", "N/A");
+      printf ("\"example_hash_format\": \"%s\", ", "N/A");
+      printf ("\"example_hash\": \"%s\", ", "N/A");
+      printf ("\"example_pass\": \"%s\", ", "N/A");
     }
 
     if (hashconfig->benchmark_mask != NULL)
     {
-      printf("\"benchmark_mask\": \"%s\", ", hashconfig->benchmark_mask);
+      printf ("\"benchmark_mask\": \"%s\", ", hashconfig->benchmark_mask);
     }
     else
     {
-      printf("\"benchmark_mask\": \"%s\", ", "N/A");
+      printf ("\"benchmark_mask\": \"%s\", ", "N/A");
     }
 
-    printf("\"autodetect_enabled\": %s, ", (hashconfig->opts_type & OPTS_TYPE_AUTODETECT_DISABLE) ? "false" : "true");
-    printf("\"self_test_enabled\": %s, ", (hashconfig->opts_type & OPTS_TYPE_SELF_TEST_DISABLE) ? "false" : "true");
-    printf("\"potfile_enabled\": %s, ", (hashconfig->opts_type & OPTS_TYPE_POTFILE_NOPASS) ? "false" : "true");
+    printf ("\"autodetect_enabled\": %s, ", (hashconfig->opts_type & OPTS_TYPE_AUTODETECT_DISABLE) ? "false" : "true");
+    printf ("\"self_test_enabled\": %s, ", (hashconfig->opts_type & OPTS_TYPE_SELF_TEST_DISABLE) ? "false" : "true");
+    printf ("\"potfile_enabled\": %s, ", (hashconfig->opts_type & OPTS_TYPE_POTFILE_NOPASS) ? "false" : "true");
 
     if (hashconfig->opts_type & OPTS_TYPE_PT_ALWAYS_ASCII)
     {
-      printf("\"plaintext_encoding\": %s", "[ \"ASCII\" ]");
+      printf ("\"plaintext_encoding\": %s", "[ \"ASCII\" ]");
     }
     else if (hashconfig->opts_type & OPTS_TYPE_PT_ALWAYS_HEXIFY)
     {
-      printf("\"plaintext_encoding\": %s", "[ \"HEX\" ]");
+      printf ("\"plaintext_encoding\": %s", "[ \"HEX\" ]");
     }
     else
     {
-      printf("\"plaintext_encoding\": %s", "[ \"ASCII\", \"HEX\" ]");
+      printf ("\"plaintext_encoding\": %s", "[ \"ASCII\", \"HEX\" ]");
     }
 
     event_log_info (hashcat_ctx, NULL);
@@ -922,30 +922,29 @@ void hash_info (hashcat_ctx_t *hashcat_ctx)
 
   if (user_options->machine_readable == false)
   {
-    event_log_info(hashcat_ctx, "Hash Info:");
-    event_log_info(hashcat_ctx, "==========");
-    event_log_info(hashcat_ctx, NULL);
+    event_log_info (hashcat_ctx, "Hash Info:");
+    event_log_info (hashcat_ctx, "==========");
+    event_log_info (hashcat_ctx, NULL);
   }
 
   if (user_options->hash_mode_chgd == true)
   {
     if (user_options->machine_readable == true)
     {
-      printf("{ ");
-      hash_info_single_json(hashcat_ctx, user_options_extra);
-      printf(" }");
+      printf ("{ ");
+      hash_info_single_json (hashcat_ctx, user_options_extra);
+      printf (" }");
     }
     else
     {
-      hash_info_single(hashcat_ctx, user_options_extra);
+      hash_info_single (hashcat_ctx, user_options_extra);
     }
   }
   else
   {
     char *modulefile = (char *) hcmalloc (HCBUFSIZ_TINY);
 
-    if (user_options->machine_readable == true)
-      printf("{ ");
+    if (user_options->machine_readable == true) printf ("{ ");
 
     for (int i = 0; i < MODULE_HASH_MODES_MAXIMUM; i++)
     {
@@ -959,19 +958,18 @@ void hash_info (hashcat_ctx_t *hashcat_ctx)
       {
         if (i != 0)
         {
-          printf(", ");
+          printf (", ");
         }
 
-        hash_info_single_json(hashcat_ctx, user_options_extra);
+        hash_info_single_json (hashcat_ctx, user_options_extra);
       }
       else
       {
-        hash_info_single(hashcat_ctx, user_options_extra);
+        hash_info_single (hashcat_ctx, user_options_extra);
       }
     }
 
-    if (user_options->machine_readable == true)
-      printf(" }");
+    if (user_options->machine_readable == true) printf (" }");
 
     hcfree (modulefile);
   }
@@ -1723,14 +1721,14 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
   hcfree (hashcat_status);
 }
 
-void json_encode(char *text, char *escaped)
+void json_encode (char *text, char *escaped)
 {
   /*
    * Based on https://www.freeformatter.com/json-escape.html, below these 7 different chars
    * are getting escaped before being printed.
    */
 
-  size_t len = strlen(text);
+  size_t len = strlen (text);
   unsigned long i, j;
 
   for (i = 0, j = 0; i < len; i++, j++)
@@ -1789,17 +1787,28 @@ void status_display_status_json (hashcat_ctx_t *hashcat_ctx)
   printf ("{ \"session\": \"%s\",", hashcat_status->session);
   printf (" \"guess\": {");
   if (hashcat_status->guess_base)
+  {
     printf (" \"guess_base\": \"%s\",", hashcat_status->guess_base);
+  }
   else
+  {
     printf (" \"guess_base\": null,");
+  }
+
   printf (" \"guess_base_count\": %u,", hashcat_status->guess_base_count);
   printf (" \"guess_base_offset\": %u,", hashcat_status->guess_base_offset);
   printf (" \"guess_base_percent\": %.02f,", hashcat_status->guess_base_percent);
   printf (" \"guess_mask_length\": %u,", hashcat_status->guess_mask_length);
+
   if (hashcat_status->guess_mod)
+  {
     printf (" \"guess_mod\": \"%s\",", hashcat_status->guess_mod);
+  }
   else
+  {
     printf (" \"guess_mod\": null,");
+  }
+
   printf (" \"guess_mod_count\": %u,", hashcat_status->guess_mod_count);
   printf (" \"guess_mod_offset\": %u,", hashcat_status->guess_mod_offset);
   printf (" \"guess_mod_percent\": %.02f,", hashcat_status->guess_mod_percent);
@@ -1812,7 +1821,7 @@ void status_display_status_json (hashcat_ctx_t *hashcat_ctx)
    * some salts can contain chars which need to be escaped to not break the JSON encoding.
    */
   char *target_json_encoded = (char *) hcmalloc (strlen (hashcat_status->hash_target) * 2);
-  json_encode(hashcat_status->hash_target, target_json_encoded);
+  json_encode (hashcat_status->hash_target, target_json_encoded);
   printf (" \"target\": \"%s\",", target_json_encoded);
   hcfree (target_json_encoded);
 
@@ -1839,14 +1848,14 @@ void status_display_status_json (hashcat_ctx_t *hashcat_ctx)
 
     printf (" { \"device_id\": %u,", device_id + 1);
 
-    char *device_name_json_encoded = (char *)hcmalloc(strlen(device_info->device_name) * 2);
-    json_encode(device_info->device_name, device_name_json_encoded);
-    printf(" \"device_name\": \"%s\",", device_name_json_encoded);
-    hcfree(device_name_json_encoded);
+    char *device_name_json_encoded = (char *) hcmalloc (strlen (device_info->device_name) * 2);
+    json_encode (device_info->device_name, device_name_json_encoded);
+    printf (" \"device_name\": \"%s\",", device_name_json_encoded);
+    hcfree (device_name_json_encoded);
 
     const char *device_type_desc = ((device_info->device_type & CL_DEVICE_TYPE_CPU) ? "CPU" :
                                    ((device_info->device_type & CL_DEVICE_TYPE_GPU) ? "GPU" : "Accelerator"));
-    printf(" \"device_type\": \"%s\",", device_type_desc);
+    printf (" \"device_type\": \"%s\",", device_type_desc);
 
     printf (" \"speed\": %" PRIu64 ",", (u64) (device_info->hashes_msec_dev * 1000));
 
diff --git a/src/usage.c b/src/usage.c
index 15e071f8e..7f1c0b82b 100644
--- a/src/usage.c
+++ b/src/usage.c
@@ -291,7 +291,7 @@ void usage_mini_print (const char *progname)
   printf ("\n");
   printf ("Press any key to exit\n");
 
-  getch();
+  getch ();
   #endif
 }
 
diff --git a/src/user_options.c b/src/user_options.c
index a7e5e3512..97c035d12 100644
--- a/src/user_options.c
+++ b/src/user_options.c
@@ -613,8 +613,9 @@ int user_options_sanity (hashcat_ctx_t *hashcat_ctx)
     {
       if ((user_options->separator[0] == '0') && (user_options->separator[1] == 'x'))
       {
-        if (is_valid_hex_string((u8 * )(&(user_options->separator[2])),2)){
-          u8 sep = hex_to_u8((u8 * )(&(user_options->separator[2])));
+        if (is_valid_hex_string ((u8 * ) (&(user_options->separator[2])), 2))
+        {
+          u8 sep = hex_to_u8 ((u8 * ) (&(user_options->separator[2])));
           user_options->separator[0] = sep;
           user_options->separator[1] = 0;
         }
@@ -627,7 +628,9 @@ int user_options_sanity (hashcat_ctx_t *hashcat_ctx)
         error = true;
       }
     }
-    if (error){
+
+    if (error)
+    {
       event_log_error (hashcat_ctx, "Separator length has to be exactly 1 byte (single char or hex format e.g. 0x09 for TAB)");
 
       return -1;