Merge pull request #28 from usr42/refactorings

Refactorings
diff --git a/fakegen.rb b/fakegen.rb
index 7f27c69..e21387f 100644
--- a/fakegen.rb
+++ b/fakegen.rb
@@ -11,16 +11,20 @@
 def include_dependencies
   putd "#include <stdarg.h>"
   putd "#include <string.h> /* For memset and memcpy */"
-  putd ""
+  puts
 end
 
 def output_constants
   putd "#define FFF_MAX_ARGS (#{$MAX_ARGS}u)"
   putd "#ifndef FFF_ARG_HISTORY_LEN"
-  putd "    #define FFF_ARG_HISTORY_LEN (#{$DEFAULT_ARG_HISTORY}u)"
+  indent {
+    putd "#define FFF_ARG_HISTORY_LEN (#{$DEFAULT_ARG_HISTORY}u)"
+  }
   putd "#endif"
   putd "#ifndef FFF_CALL_HISTORY_LEN"
-  putd "  #define FFF_CALL_HISTORY_LEN (#{$MAX_CALL_HISTORY}u)"
+  indent {
+    putd "#define FFF_CALL_HISTORY_LEN (#{$MAX_CALL_HISTORY}u)"
+  }
   putd "#endif"
 end
 
@@ -51,137 +55,181 @@
   define_reset_fake_helper
 
   putd "/* -- END INTERNAL HELPER MACROS -- */"
-  putd ""
+  puts
 end
 
 def define_return_sequence_helper
-  putd "#define SET_RETURN_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \\"
-  putd "                        FUNCNAME##_fake.return_val_seq = ARRAY_POINTER; \\"
-  putd "                        FUNCNAME##_fake.return_val_seq_len = ARRAY_LEN;"
+  putd_backslash "#define SET_RETURN_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN)"
+  indent {
+    putd_backslash "FUNCNAME##_fake.return_val_seq = ARRAY_POINTER;"
+    putd "FUNCNAME##_fake.return_val_seq_len = ARRAY_LEN;"
+  }
 end
 
 def define_custom_fake_sequence_helper
-  putd "#define SET_CUSTOM_FAKE_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \\"
-  putd "                            FUNCNAME##_fake.custom_fake_seq = ARRAY_POINTER; \\"
-  putd "                            FUNCNAME##_fake.custom_fake_seq_len = ARRAY_LEN;"
+  putd_backslash "#define SET_CUSTOM_FAKE_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN)"
+  indent {
+    putd_backslash "FUNCNAME##_fake.custom_fake_seq = ARRAY_POINTER;"
+    putd "FUNCNAME##_fake.custom_fake_seq_len = ARRAY_LEN;"
+  }
 end
 
 def define_reset_fake_macro
-  putd ""
+  puts
   putd "/* Defining a function to reset a fake function */"
-  putd "#define RESET_FAKE(FUNCNAME) { \\"
-  putd "    FUNCNAME##_reset(); \\"
-  putd "} \\"
-  putd ""
+  putd_backslash "#define RESET_FAKE(FUNCNAME) {"
+  indent {
+    putd_backslash "FUNCNAME##_reset();"
+  }
+  putd_backslash "}"
+  puts
 end
 
 def define_declare_arg_helper
-  putd ""
-  putd "#define DECLARE_ARG(type, n, FUNCNAME) \\"
-  putd "    type arg##n##_val; \\"
-  putd "    type arg##n##_history[FFF_ARG_HISTORY_LEN];"
+  puts
+  putd_backslash "#define DECLARE_ARG(type, n, FUNCNAME)"
+  indent {
+    putd_backslash "type arg##n##_val;"
+    putd "type arg##n##_history[FFF_ARG_HISTORY_LEN];"
+  }
 end
 
 def define_declare_all_func_common_helper
-  putd ""
-  putd "#define DECLARE_ALL_FUNC_COMMON \\"
-  putd "    unsigned int call_count; \\"
-  putd "    unsigned int arg_history_len;\\"
-  putd "    unsigned int arg_histories_dropped; \\"
+  puts
+  putd_backslash "#define DECLARE_ALL_FUNC_COMMON"
+  indent {
+    putd_backslash "unsigned int call_count;"
+    putd_backslash "unsigned int arg_history_len;"
+    putd_backslash "unsigned int arg_histories_dropped;"
+  }
 end
 
 def define_declare_return_value_history
   putd ""
-  putd "#define DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \\"
-  putd "    RETURN_TYPE return_val_history[FFF_ARG_HISTORY_LEN];"
+  putd_backslash "#define DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE)"
+  indent {
+    putd "RETURN_TYPE return_val_history[FFF_ARG_HISTORY_LEN];"
+  }
 end
 
 def define_save_arg_helper
-  putd ""
-  putd "#define SAVE_ARG(FUNCNAME, n) \\"
-  putd "    memcpy((void*)&FUNCNAME##_fake.arg##n##_val, (void*)&arg##n, sizeof(arg##n));"
+  puts
+  putd_backslash "#define SAVE_ARG(FUNCNAME, n)"
+  indent {
+    putd "memcpy((void*)&FUNCNAME##_fake.arg##n##_val, (void*)&arg##n, sizeof(arg##n));"
+  }
 end
 
 def define_save_ret_history_helper
   putd ""
-  putd "#define SAVE_RET_HISTORY(FUNCNAME, RETVAL) \\"
-  putd "    if ((FUNCNAME##_fake.call_count - 1) < FFF_ARG_HISTORY_LEN) \\"
-  putd "        memcpy((void *)&FUNCNAME##_fake.return_val_history[FUNCNAME##_fake.call_count - 1], (const void *) &RETVAL, sizeof(RETVAL)); \\"
+  putd_backslash "#define SAVE_RET_HISTORY(FUNCNAME, RETVAL)"
+  indent {
+    putd_backslash "if ((FUNCNAME##_fake.call_count - 1) < FFF_ARG_HISTORY_LEN)"
+    indent {
+      putd_backslash "memcpy((void *)&FUNCNAME##_fake.return_val_history[FUNCNAME##_fake.call_count - 1], (const void *) &RETVAL, sizeof(RETVAL));"
+    }
+  }
 end
 
 def define_room_for_more_history
-  putd ""
-  putd "#define ROOM_FOR_MORE_HISTORY(FUNCNAME) \\"
-  putd "  FUNCNAME##_fake.call_count < FFF_ARG_HISTORY_LEN"
+  puts
+  putd_backslash "#define ROOM_FOR_MORE_HISTORY(FUNCNAME)"
+  indent {
+    putd "FUNCNAME##_fake.call_count < FFF_ARG_HISTORY_LEN"
+  }
 end
 
 def define_save_arg_history_helper
-  putd ""
-  putd "#define SAVE_ARG_HISTORY(FUNCNAME, ARGN) \\"
-  putd "    memcpy((void*)&FUNCNAME##_fake.arg##ARGN##_history[FUNCNAME##_fake.call_count], (void*)&arg##ARGN, sizeof(arg##ARGN));"
+  puts
+  putd_backslash "#define SAVE_ARG_HISTORY(FUNCNAME, ARGN)"
+  indent {
+    putd "memcpy((void*)&FUNCNAME##_fake.arg##ARGN##_history[FUNCNAME##_fake.call_count], (void*)&arg##ARGN, sizeof(arg##ARGN));"
+  }
 end
 
 def define_history_dropped_helper
-  putd ""
-  putd "#define HISTORY_DROPPED(FUNCNAME) \\"
-  putd "    FUNCNAME##_fake.arg_histories_dropped++"
+  puts
+  putd_backslash "#define HISTORY_DROPPED(FUNCNAME)"
+  indent {
+    putd "FUNCNAME##_fake.arg_histories_dropped++"
+  }
 end
 
 def define_value_function_variables_helper
-  putd ""
-  putd "#define DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \\"
-  putd "    RETURN_TYPE return_val; \\"
-  putd "    int return_val_seq_len; \\"
-  putd "    int return_val_seq_idx; \\"
-  putd "    RETURN_TYPE * return_val_seq; \\"
+  puts
+  putd_backslash "#define DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE)"
+  indent {
+    putd_backslash "RETURN_TYPE return_val;" 
+    putd_backslash "int return_val_seq_len;" 
+    putd_backslash "int return_val_seq_idx;" 
+    putd_backslash "RETURN_TYPE * return_val_seq;"
+  }
 end
 
 def define_custom_fake_seq_variables_helper
-  putd ""
-  putd "#define DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \\"
-  putd "    int custom_fake_seq_len; \\"
-  putd "    int custom_fake_seq_idx; \\"
+  puts
+  putd_backslash "#define DECLARE_CUSTOM_FAKE_SEQ_VARIABLES"
+  indent {
+    putd_backslash "int custom_fake_seq_len;"
+    putd_backslash "int custom_fake_seq_idx;"
+  }
 end
 
 def define_increment_call_count_helper
-  putd ""
-  putd "#define INCREMENT_CALL_COUNT(FUNCNAME) \\"
-  putd "    FUNCNAME##_fake.call_count++"
+  puts
+  putd_backslash "#define INCREMENT_CALL_COUNT(FUNCNAME)"
+  indent {
+    putd "FUNCNAME##_fake.call_count++"
+  }
 end
 
 def define_return_fake_result_helper
-  putd ""
-  putd "#define RETURN_FAKE_RESULT(FUNCNAME) \\"
-  putd "    if (FUNCNAME##_fake.return_val_seq_len){ /* then its a sequence */ \\"
-  putd "        if(FUNCNAME##_fake.return_val_seq_idx < FUNCNAME##_fake.return_val_seq_len) { \\"
-  putd "            SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx]) \\"
-  putd "            return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx++]; \\"
-  putd "        } \\"
-  putd "        SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1]) \\"
-  putd "        return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1]; /* return last element */ \\"
-  putd "    } \\"
-  putd "    SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val) \\"
-  putd "    return FUNCNAME##_fake.return_val; \\"
+  puts
+  putd_backslash "#define RETURN_FAKE_RESULT(FUNCNAME)"
+  indent {
+    putd_backslash "if (FUNCNAME##_fake.return_val_seq_len){ /* then its a sequence */"
+    indent {
+      putd_backslash "if(FUNCNAME##_fake.return_val_seq_idx < FUNCNAME##_fake.return_val_seq_len) {"
+      indent {
+        putd_backslash "SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx])"
+        putd_backslash "return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx++];"
+      }
+      putd_backslash "}"
+      putd_backslash "SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1])"
+      putd_backslash "return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1]; /* return last element */"
+    }
+    putd_backslash "}"
+    putd_backslash "SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val)"
+    putd_backslash "return FUNCNAME##_fake.return_val;"
+  }
 end
 
 def define_extern_c_helper
-  putd ""
+  puts
   putd "#ifdef __cplusplus"
-  putd "    #define FFF_EXTERN_C extern \"C\"{"
-  putd "    #define FFF_END_EXTERN_C } "
+  indent {
+    putd "#define FFF_EXTERN_C extern \"C\"{" 
+    putd "#define FFF_END_EXTERN_C } " 
+  }
   putd "#else  /* ansi c */"
-  putd "    #define FFF_EXTERN_C "
-  putd "    #define FFF_END_EXTERN_C "
+  indent {
+    putd "#define FFF_EXTERN_C "
+    putd "#define FFF_END_EXTERN_C "
+  }
   putd "#endif  /* cpp/ansi c */"
 end
 
 def define_reset_fake_helper
-  putd ""
-  putd "#define DEFINE_RESET_FUNCTION(FUNCNAME) \\"
-  putd "    void FUNCNAME##_reset(void){ \\"
-  putd "        memset(&FUNCNAME##_fake, 0, sizeof(FUNCNAME##_fake)); \\"
-  putd "        FUNCNAME##_fake.arg_history_len = FFF_ARG_HISTORY_LEN;\\"
-  putd "    }"
+  puts
+  putd_backslash "#define DEFINE_RESET_FUNCTION(FUNCNAME)"
+  indent {
+    putd_backslash "void FUNCNAME##_reset(void){"
+    indent {
+      putd_backslash "memset(&FUNCNAME##_fake, 0, sizeof(FUNCNAME##_fake));"
+      putd_backslash "FUNCNAME##_fake.arg_history_len = FFF_ARG_HISTORY_LEN;"
+    }
+    putd "}"
+  }
 end
 # ------  End Helper macros ------ #
 
@@ -192,6 +240,11 @@
   puts str
 end
 
+#multiline putd which adds a \ at the end of the generated macro
+def putd_backslash str
+  putd(str + " \\")
+end
+
 def pushd
   $current_depth = $current_depth + 4
 end
@@ -200,6 +253,12 @@
   $current_depth = $current_depth - 4
 end
 
+def indent
+  pushd 
+    yield
+  popd
+end
+
 def output_macro(arg_count, has_varargs, is_value_function)
 
   vararg_name = has_varargs ? "_VARARG" : ""
@@ -209,36 +268,36 @@
   saved_arg_count = arg_count - (has_varargs ? 1 : 0)
   return_type = is_value_function ? "RETURN_TYPE" : ""
 
-  putd ""
+  puts
   output_macro_header(declare_macro_name, saved_arg_count, has_varargs, return_type)
-  pushd
+  indent {
     extern_c {  # define argument capture variables
       output_variables(saved_arg_count, has_varargs, is_value_function)
     }
-  popd
-
-  putd ""
+  }
+  
+  puts
   output_macro_header(define_macro_name, saved_arg_count, has_varargs, return_type)
-  pushd
+  indent {
     extern_c {
-      putd "FUNCNAME##_Fake FUNCNAME##_fake;\\"
-      putd function_signature(saved_arg_count, has_varargs, is_value_function) + "{ \\"
-      pushd
+      putd_backslash "FUNCNAME##_Fake FUNCNAME##_fake;"
+      putd_backslash function_signature(saved_arg_count, has_varargs, is_value_function) + "{"
+      indent {
         output_function_body(saved_arg_count, has_varargs, is_value_function)
-      popd
-      putd "} \\"
-      putd "DEFINE_RESET_FUNCTION(FUNCNAME) \\"
+      }
+      putd_backslash "}"
+      putd_backslash "DEFINE_RESET_FUNCTION(FUNCNAME)"
     }
-  popd
-
-  putd ""
-
+  }
+  
+  puts
+  
   output_macro_header(fake_macro_name, saved_arg_count, has_varargs, return_type)
-  pushd
+  indent {
     putd macro_signature_for(declare_macro_name, saved_arg_count, has_varargs, return_type)
     putd macro_signature_for(define_macro_name, saved_arg_count, has_varargs, return_type)
-    putd ""
-  popd
+    puts
+  }
 end
 
 def output_macro_header(macro_name, arg_count, has_varargs, return_type)
@@ -250,7 +309,7 @@
   putd "#define " + macro_signature_for(macro_name, arg_count, has_varargs, return_type)
 end
 
-# #macro_name(RETURN_TYPE, FUNCNAME, ARG0,...)
+# #macro_name(RETURN_TYPE, FUNCNAME, ARG0,...) \
 def macro_signature_for(macro_name, arg_count, has_varargs, return_type)
   parameter_list = "#{macro_name}("
   if return_type != ""
@@ -268,25 +327,21 @@
   parameter_list
 end
 
-def output_argument_capture_variables(argN)
-  putd "    DECLARE_ARG(ARG#{argN}_TYPE, #{argN}, FUNCNAME) \\"
-end
-
 def output_variables(arg_count, has_varargs, is_value_function)
   in_struct{
-    arg_count.times { |argN|
-      putd "DECLARE_ARG(ARG#{argN}_TYPE, #{argN}, FUNCNAME) \\"
+    arg_count.times { |argN| 
+      putd_backslash "DECLARE_ARG(ARG#{argN}_TYPE, #{argN}, FUNCNAME)"
     }
-    putd "DECLARE_ALL_FUNC_COMMON \\"
-    putd "DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \\" unless not is_value_function
-    putd "DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \\" unless not is_value_function
-    putd "DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \\"
+    putd_backslash "DECLARE_ALL_FUNC_COMMON"
+    putd_backslash "DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE)" unless not is_value_function
+    putd_backslash "DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE)" unless not is_value_function
+    putd_backslash "DECLARE_CUSTOM_FAKE_SEQ_VARIABLES"
     output_custom_function_signature(arg_count, has_varargs, is_value_function)
     output_custom_function_array(arg_count, has_varargs, is_value_function)
   }
-  putd "extern FUNCNAME##_Fake FUNCNAME##_fake;\\"
-  putd "void FUNCNAME##_reset(void); \\"
-  putd function_signature(arg_count, has_varargs, is_value_function) + "; \\"
+  putd_backslash "extern FUNCNAME##_Fake FUNCNAME##_fake;"
+  putd_backslash "void FUNCNAME##_reset(void);"
+  putd_backslash function_signature(arg_count, has_varargs, is_value_function) + ";"
 end
 
 #example: ARG0_TYPE arg0, ARG1_TYPE arg1
@@ -309,15 +364,15 @@
 def output_custom_function_signature(arg_count, has_varargs, is_value_function)
   return_type = is_value_function ? "RETURN_TYPE" : "void"
   ap_list = has_varargs ? ", va_list ap" : ""
-  signature = "(*custom_fake)(#{arg_val_list(arg_count)}#{ap_list}); \\"
-  putd return_type + signature
+  signature = "(*custom_fake)(#{arg_val_list(arg_count)}#{ap_list});"
+  putd_backslash return_type + signature
 end
 
 def output_custom_function_array(arg_count, has_varargs, is_value_function)
   return_type = is_value_function ? "RETURN_TYPE" : "void"
   ap_list = has_varargs ? ", va_list ap" : ""
-  custom_array = "(**custom_fake_seq)(#{arg_val_list(arg_count)}#{ap_list}); \\"
-  putd return_type + custom_array
+  custom_array = "(**custom_fake_seq)(#{arg_val_list(arg_count)}#{ap_list});"
+  putd_backslash return_type + custom_array
 end
 
 # example: RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1)
@@ -328,107 +383,124 @@
 end
 
 def output_function_body(arg_count, has_varargs, is_value_function)
-  arg_count.times { |i| putd "SAVE_ARG(FUNCNAME, #{i}); \\" }
-  putd "if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\\"
-  arg_count.times { |i| putd "    SAVE_ARG_HISTORY(FUNCNAME, #{i}); \\" }
-  putd "}\\"
-  putd "else{\\"
-  putd "    HISTORY_DROPPED(FUNCNAME);\\"
-  putd "}\\"
-  putd "INCREMENT_CALL_COUNT(FUNCNAME); \\"
-  putd "REGISTER_CALL(FUNCNAME); \\"
+  arg_count.times { |i| putd_backslash "SAVE_ARG(FUNCNAME, #{i});" }
+  putd_backslash "if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){"
+  indent {
+    arg_count.times { |i| putd_backslash "SAVE_ARG_HISTORY(FUNCNAME, #{i});" }
+  }
+  putd_backslash "}"
+  putd_backslash "else{"
+  indent {
+    putd_backslash "HISTORY_DROPPED(FUNCNAME);"
+  }
+  putd_backslash "}"
+  putd_backslash "INCREMENT_CALL_COUNT(FUNCNAME);"
+  putd_backslash "REGISTER_CALL(FUNCNAME);"
 
   if has_varargs
-    putd "if(FUNCNAME##_fake.custom_fake){\\"
-    putd "    RETURN_TYPE ret;\\" if is_value_function
-    putd "    va_list ap;\\"
-    putd "    va_start(ap, arg#{arg_count-1});\\"
+    putd_backslash "if(FUNCNAME##_fake.custom_fake){"
+    indent {
+      putd_backslash "RETURN_TYPE ret;" if is_value_function
+      putd_backslash "va_list ap;"
+      putd_backslash "va_start(ap, arg#{arg_count-1});"
+    }
     custom_fake_call = "FUNCNAME##_fake.custom_fake(#{arg_list(arg_count)}, ap);"
-    if is_value_function
-      putd "    ret = #{custom_fake_call}\\"
-    else
-      putd "  #{custom_fake_call}\\"
-    end
-    putd "    va_end(ap);\\"
-    putd "    SAVE_RET_HISTORY(FUNCNAME, ret); \\" unless not is_value_function
-    putd "    return ret;\\" if is_value_function
-    putd "}\\"
+    indent {
+      if is_value_function
+        putd_backslash "ret = #{custom_fake_call}"
+      else
+        putd_backslash "#{custom_fake_call}"
+      end
+      putd_backslash "va_end(ap);"
+      putd_backslash "SAVE_RET_HISTORY(FUNCNAME, ret);" unless not is_value_function
+      putd_backslash "return ret;" if is_value_function
+    }
+    putd_backslash "}"
   else
     return_type = is_value_function ? "return " : ""
-    putd "if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \\"
-    putd "    if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \\"
-    putd "        RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](#{arg_list(arg_count)}); \\" unless not is_value_function
-    putd "        SAVE_RET_HISTORY(FUNCNAME, ret); \\" unless not is_value_function
-    putd "        return ret; \\" unless not is_value_function
-    putd "        #{return_type}FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](#{arg_list(arg_count)}); \\" unless is_value_function
-    putd "    } \\"
-    putd "    else{ \\"
-    putd "        RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](#{arg_list(arg_count)}); \\" unless not is_value_function
-    putd "        SAVE_RET_HISTORY(FUNCNAME, ret); \\" unless not is_value_function
-    putd "        return ret; \\" unless not is_value_function
-    putd "        #{return_type}FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](#{arg_list(arg_count)}); \\"
-    putd "    } \\"
-    putd "} \\"
-    putd "if (FUNCNAME##_fake.custom_fake) #{return_type}FUNCNAME##_fake.custom_fake(#{arg_list(arg_count)}); \\"
+    putd_backslash "if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */"
+    indent {
+      putd_backslash "if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){"
+      indent {
+        putd_backslash "RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](#{arg_list(arg_count)});" unless not is_value_function
+        putd_backslash "SAVE_RET_HISTORY(FUNCNAME, ret);" unless not is_value_function
+        putd_backslash "return ret;" unless not is_value_function
+        putd_backslash "#{return_type}FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](#{arg_list(arg_count)});" unless is_value_function
+      }
+      putd_backslash "}"
+      putd_backslash "else{"
+      indent {
+        putd_backslash "RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](#{arg_list(arg_count)});" unless not is_value_function
+        putd_backslash "SAVE_RET_HISTORY(FUNCNAME, ret);" unless not is_value_function
+        putd_backslash "return ret;" unless not is_value_function
+        putd_backslash "#{return_type}FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](#{arg_list(arg_count)});"
+      }
+      putd_backslash "}"
+    }
+    putd_backslash "}"
+    putd_backslash "if (FUNCNAME##_fake.custom_fake) #{return_type}FUNCNAME##_fake.custom_fake(#{arg_list(arg_count)});"
   end
 
-  putd "RETURN_FAKE_RESULT(FUNCNAME)  \\" if is_value_function
-end
-
-def output_reset_function(arg_count, is_value_function)
-  putd "void FUNCNAME##_reset(void){ \\"
-  putd "    memset(&FUNCNAME##_fake, 0, sizeof(FUNCNAME##_fake)); \\"
-  putd "    FUNCNAME##_fake.arg_history_len = FFF_ARG_HISTORY_LEN;\\"
-  putd "} \\"
+  putd_backslash "RETURN_FAKE_RESULT(FUNCNAME)" if is_value_function
 end
 
 def define_fff_globals
   putd "typedef void (*fff_function_t)(void);"
   putd "typedef struct { "
-  putd "    fff_function_t call_history[FFF_CALL_HISTORY_LEN];"
-  putd "    unsigned int call_history_idx;"
+  indent {
+    putd "fff_function_t call_history[FFF_CALL_HISTORY_LEN];"
+    putd "unsigned int call_history_idx;"
+  }
   putd "} fff_globals_t;"
-  putd ""
-  putd "FFF_EXTERN_C \\"
+  puts
+  putd_backslash "FFF_EXTERN_C"
   putd "extern fff_globals_t fff;"
-  putd "FFF_END_EXTERN_C \\"
-  putd ""
-  putd "#define DEFINE_FFF_GLOBALS \\"
-  putd "    FFF_EXTERN_C \\"
-  putd "        fff_globals_t fff; \\"
-  putd "    FFF_END_EXTERN_C"
-  putd ""
+  putd_backslash "FFF_END_EXTERN_C"
+  puts
+  putd_backslash "#define DEFINE_FFF_GLOBALS"
+  indent {
+    putd_backslash "FFF_EXTERN_C"
+    indent {
+      putd_backslash "fff_globals_t fff;"
+    }
+    putd "FFF_END_EXTERN_C"
+  }
+  puts
   putd "#define FFF_RESET_HISTORY() fff.call_history_idx = 0;"
-  putd ""
-  putd "#define REGISTER_CALL(function) \\"
-  putd "   if(fff.call_history_idx < FFF_CALL_HISTORY_LEN) \\"
-  putd "       fff.call_history[fff.call_history_idx++] = (fff_function_t)function;"
+  puts
+  putd_backslash "#define REGISTER_CALL(function)"
+  indent {
+    putd_backslash "if(fff.call_history_idx < FFF_CALL_HISTORY_LEN)"
+    indent {
+		putd "fff.call_history[fff.call_history_idx++] = (fff_function_t)function;"
+    }
+  }
 end
 
 def extern_c
-  putd "FFF_EXTERN_C \\"
-  pushd
+  putd_backslash "FFF_EXTERN_C"
+  indent { 
     yield
-  popd
-  putd "FFF_END_EXTERN_C \\"
+  }
+  putd_backslash "FFF_END_EXTERN_C"
 end
 
 def in_struct
-  putd "typedef struct FUNCNAME##_Fake { \\"
-  pushd
-  yield
-  popd
-  putd "} FUNCNAME##_Fake;\\"
+  putd_backslash "typedef struct FUNCNAME##_Fake {"
+  indent {
+    yield
+  }
+  putd_backslash "} FUNCNAME##_Fake;"
 end
 
 def include_guard
   putd "#ifndef FAKE_FUNCTIONS"
   putd "#define FAKE_FUNCTIONS"
-  putd ""
+  puts
 
   yield
 
-  putd ""
+  puts
   putd "#endif /* FAKE_FUNCTIONS */"
 end
 
diff --git a/fff.h b/fff.h
index 148cb23..230144e 100644
--- a/fff.h
+++ b/fff.h
@@ -34,15 +34,15 @@
     #define FFF_ARG_HISTORY_LEN (50u)
 #endif
 #ifndef FFF_CALL_HISTORY_LEN
-  #define FFF_CALL_HISTORY_LEN (50u)
+    #define FFF_CALL_HISTORY_LEN (50u)
 #endif
 /* -- INTERNAL HELPER MACROS -- */
 #define SET_RETURN_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \
-                        FUNCNAME##_fake.return_val_seq = ARRAY_POINTER; \
-                        FUNCNAME##_fake.return_val_seq_len = ARRAY_LEN;
+    FUNCNAME##_fake.return_val_seq = ARRAY_POINTER; \
+    FUNCNAME##_fake.return_val_seq_len = ARRAY_LEN;
 #define SET_CUSTOM_FAKE_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \
-                            FUNCNAME##_fake.custom_fake_seq = ARRAY_POINTER; \
-                            FUNCNAME##_fake.custom_fake_seq_len = ARRAY_LEN;
+    FUNCNAME##_fake.custom_fake_seq = ARRAY_POINTER; \
+    FUNCNAME##_fake.custom_fake_seq_len = ARRAY_LEN;
 
 /* Defining a function to reset a fake function */
 #define RESET_FAKE(FUNCNAME) { \
@@ -56,7 +56,7 @@
 
 #define DECLARE_ALL_FUNC_COMMON \
     unsigned int call_count; \
-    unsigned int arg_history_len;\
+    unsigned int arg_history_len; \
     unsigned int arg_histories_dropped; \
 
 #define DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
@@ -66,7 +66,7 @@
     memcpy((void*)&FUNCNAME##_fake.arg##n##_val, (void*)&arg##n, sizeof(arg##n));
 
 #define ROOM_FOR_MORE_HISTORY(FUNCNAME) \
-  FUNCNAME##_fake.call_count < FFF_ARG_HISTORY_LEN
+    FUNCNAME##_fake.call_count < FFF_ARG_HISTORY_LEN
 
 #define SAVE_RET_HISTORY(FUNCNAME, RETVAL) \
     if ((FUNCNAME##_fake.call_count - 1) < FFF_ARG_HISTORY_LEN) \
@@ -114,7 +114,7 @@
 #define DEFINE_RESET_FUNCTION(FUNCNAME) \
     void FUNCNAME##_reset(void){ \
         memset(&FUNCNAME##_fake, 0, sizeof(FUNCNAME##_fake)); \
-        FUNCNAME##_fake.arg_history_len = FFF_ARG_HISTORY_LEN;\
+        FUNCNAME##_fake.arg_history_len = FFF_ARG_HISTORY_LEN; \
     }
 /* -- END INTERNAL HELPER MACROS -- */
 
@@ -136,8 +136,8 @@
 #define FFF_RESET_HISTORY() fff.call_history_idx = 0;
 
 #define REGISTER_CALL(function) \
-   if(fff.call_history_idx < FFF_CALL_HISTORY_LEN) \
-       fff.call_history[fff.call_history_idx++] = (fff_function_t)function;
+    if(fff.call_history_idx < FFF_CALL_HISTORY_LEN) \
+        fff.call_history[fff.call_history_idx++] = (fff_function_t)function;
 
 #define DECLARE_FAKE_VOID_FUNC0(FUNCNAME) \
     FFF_EXTERN_C \
@@ -146,21 +146,21 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(void); \
             void(**custom_fake_seq)(void); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(void); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC0(FUNCNAME) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(void){ \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -189,23 +189,23 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0); \
             void(**custom_fake_seq)(ARG0_TYPE arg0); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0){ \
             SAVE_ARG(FUNCNAME, 0); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -235,25 +235,25 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -284,27 +284,27 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -336,29 +336,29 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -391,31 +391,31 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -449,15 +449,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -465,17 +465,17 @@
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -510,15 +510,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -527,7 +527,7 @@
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -535,10 +535,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -574,15 +574,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -592,7 +592,7 @@
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -601,10 +601,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -641,15 +641,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -660,7 +660,7 @@
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -670,10 +670,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -711,15 +711,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -731,7 +731,7 @@
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -742,10 +742,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -784,15 +784,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -805,7 +805,7 @@
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -817,10 +817,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -860,15 +860,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -882,7 +882,7 @@
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -895,10 +895,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -939,15 +939,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -962,7 +962,7 @@
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -976,10 +976,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1021,15 +1021,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -1045,7 +1045,7 @@
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -1060,10 +1060,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1106,15 +1106,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -1131,7 +1131,7 @@
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -1147,10 +1147,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1194,15 +1194,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -1220,7 +1220,7 @@
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -1237,10 +1237,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1285,15 +1285,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -1312,7 +1312,7 @@
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -1330,10 +1330,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1379,15 +1379,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -1407,7 +1407,7 @@
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -1426,10 +1426,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1476,15 +1476,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -1505,7 +1505,7 @@
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
             SAVE_ARG(FUNCNAME, 18); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -1525,10 +1525,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
                 SAVE_ARG_HISTORY(FUNCNAME, 18); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1576,15 +1576,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -1606,7 +1606,7 @@
             SAVE_ARG(FUNCNAME, 17); \
             SAVE_ARG(FUNCNAME, 18); \
             SAVE_ARG(FUNCNAME, 19); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -1627,10 +1627,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
                 SAVE_ARG_HISTORY(FUNCNAME, 18); \
                 SAVE_ARG_HISTORY(FUNCNAME, 19); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1660,21 +1660,21 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(void); \
             RETURN_TYPE(**custom_fake_seq)(void); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(void); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(void){ \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1691,7 +1691,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -1711,23 +1711,23 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0){ \
             SAVE_ARG(FUNCNAME, 0); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1744,7 +1744,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -1765,25 +1765,25 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1800,7 +1800,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -1822,27 +1822,27 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1859,7 +1859,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -1882,29 +1882,29 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1921,7 +1921,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -1945,31 +1945,31 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -1986,7 +1986,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2011,15 +2011,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2027,17 +2027,17 @@
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2054,7 +2054,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2080,15 +2080,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2097,7 +2097,7 @@
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2105,10 +2105,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2125,7 +2125,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2152,15 +2152,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2170,7 +2170,7 @@
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2179,10 +2179,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2199,7 +2199,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2227,15 +2227,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2246,7 +2246,7 @@
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2256,10 +2256,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2276,7 +2276,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2305,15 +2305,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2325,7 +2325,7 @@
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2336,10 +2336,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2356,7 +2356,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2386,15 +2386,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2407,7 +2407,7 @@
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2419,10 +2419,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2439,7 +2439,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2470,15 +2470,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2492,7 +2492,7 @@
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2505,10 +2505,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2525,7 +2525,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2557,15 +2557,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2580,7 +2580,7 @@
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2594,10 +2594,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2614,7 +2614,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2647,15 +2647,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2671,7 +2671,7 @@
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2686,10 +2686,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2706,7 +2706,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2740,15 +2740,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2765,7 +2765,7 @@
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2781,10 +2781,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2801,7 +2801,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2836,15 +2836,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2862,7 +2862,7 @@
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2879,10 +2879,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -2899,7 +2899,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -2935,15 +2935,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -2962,7 +2962,7 @@
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -2980,10 +2980,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -3000,7 +3000,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3037,15 +3037,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3065,7 +3065,7 @@
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3084,10 +3084,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -3104,7 +3104,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3142,15 +3142,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3171,7 +3171,7 @@
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
             SAVE_ARG(FUNCNAME, 18); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3191,10 +3191,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
                 SAVE_ARG_HISTORY(FUNCNAME, 18); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -3211,7 +3211,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3250,15 +3250,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3280,7 +3280,7 @@
             SAVE_ARG(FUNCNAME, 17); \
             SAVE_ARG(FUNCNAME, 18); \
             SAVE_ARG(FUNCNAME, 19); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3301,10 +3301,10 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
                 SAVE_ARG_HISTORY(FUNCNAME, 18); \
                 SAVE_ARG_HISTORY(FUNCNAME, 19); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
             if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
@@ -3321,7 +3321,7 @@
                 } \
             } \
             if (FUNCNAME##_fake.custom_fake) return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3339,31 +3339,31 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg0);\
-              FUNCNAME##_fake.custom_fake(arg0, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg0); \
+                FUNCNAME##_fake.custom_fake(arg0, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3382,33 +3382,33 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg1);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg1); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3428,35 +3428,35 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg2);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg2); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3477,37 +3477,37 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg3);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg3); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3529,39 +3529,39 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg4);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg4); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3584,15 +3584,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3600,25 +3600,25 @@
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg5);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg5); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3642,15 +3642,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3659,7 +3659,7 @@
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3667,18 +3667,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg6);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg6); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3703,15 +3703,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3721,7 +3721,7 @@
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3730,18 +3730,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg7);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg7); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3767,15 +3767,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3786,7 +3786,7 @@
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3796,18 +3796,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg8);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg8); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3834,15 +3834,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3854,7 +3854,7 @@
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3865,18 +3865,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg9);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg9); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3904,15 +3904,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3925,7 +3925,7 @@
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -3937,18 +3937,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg10);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg10); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -3977,15 +3977,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -3999,7 +3999,7 @@
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4012,18 +4012,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg11);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg11); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4053,15 +4053,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4076,7 +4076,7 @@
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4090,18 +4090,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg12);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg12); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4132,15 +4132,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4156,7 +4156,7 @@
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4171,18 +4171,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg13);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg13); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4214,15 +4214,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4239,7 +4239,7 @@
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4255,18 +4255,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg14);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg14); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4299,15 +4299,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4325,7 +4325,7 @@
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4342,18 +4342,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg15);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg15); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4387,15 +4387,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4414,7 +4414,7 @@
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4432,18 +4432,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg16);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg16); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4478,15 +4478,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4506,7 +4506,7 @@
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4525,18 +4525,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg17);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg17); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4572,15 +4572,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             void(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \
             void(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4601,7 +4601,7 @@
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
             SAVE_ARG(FUNCNAME, 18); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -4621,18 +4621,18 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
                 SAVE_ARG_HISTORY(FUNCNAME, 18); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                va_list ap;\
-                va_start(ap, arg18);\
-              FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap);\
-                va_end(ap);\
-            }\
+            if(FUNCNAME##_fake.custom_fake){ \
+                va_list ap; \
+                va_start(ap, arg18); \
+                FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+                va_end(ap); \
+            } \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4652,35 +4652,35 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg0);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg0); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4701,37 +4701,37 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg1);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg1); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4753,39 +4753,39 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg2);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg2); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4808,41 +4808,41 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg3);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg3); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4866,43 +4866,43 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
             SAVE_ARG(FUNCNAME, 2); \
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg4);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg4); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4927,15 +4927,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -4943,29 +4943,29 @@
             SAVE_ARG(FUNCNAME, 3); \
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
                 SAVE_ARG_HISTORY(FUNCNAME, 3); \
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg5);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg5); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -4991,15 +4991,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5008,7 +5008,7 @@
             SAVE_ARG(FUNCNAME, 4); \
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5016,22 +5016,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 4); \
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg6);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg6); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5058,15 +5058,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5076,7 +5076,7 @@
             SAVE_ARG(FUNCNAME, 5); \
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5085,22 +5085,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 5); \
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg7);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg7); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5128,15 +5128,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5147,7 +5147,7 @@
             SAVE_ARG(FUNCNAME, 6); \
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5157,22 +5157,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 6); \
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg8);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg8); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5201,15 +5201,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5221,7 +5221,7 @@
             SAVE_ARG(FUNCNAME, 7); \
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5232,22 +5232,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 7); \
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg9);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg9); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5277,15 +5277,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5298,7 +5298,7 @@
             SAVE_ARG(FUNCNAME, 8); \
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5310,22 +5310,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 8); \
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg10);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg10); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5356,15 +5356,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5378,7 +5378,7 @@
             SAVE_ARG(FUNCNAME, 9); \
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5391,22 +5391,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 9); \
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg11);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg11); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5438,15 +5438,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5461,7 +5461,7 @@
             SAVE_ARG(FUNCNAME, 10); \
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5475,22 +5475,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 10); \
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg12);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg12); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5523,15 +5523,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5547,7 +5547,7 @@
             SAVE_ARG(FUNCNAME, 11); \
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5562,22 +5562,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 11); \
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg13);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg13); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5611,15 +5611,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5636,7 +5636,7 @@
             SAVE_ARG(FUNCNAME, 12); \
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5652,22 +5652,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 12); \
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg14);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg14); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5702,15 +5702,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5728,7 +5728,7 @@
             SAVE_ARG(FUNCNAME, 13); \
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5745,22 +5745,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 13); \
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg15);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg15); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5796,15 +5796,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5823,7 +5823,7 @@
             SAVE_ARG(FUNCNAME, 14); \
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5841,22 +5841,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 14); \
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg16);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg16); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5893,15 +5893,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -5921,7 +5921,7 @@
             SAVE_ARG(FUNCNAME, 15); \
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -5940,22 +5940,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 15); \
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg17);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg17); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \
@@ -5993,15 +5993,15 @@
             DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
             RETURN_TYPE(*custom_fake)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \
             RETURN_TYPE(**custom_fake_seq)(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, va_list ap); \
-        } FUNCNAME##_Fake;\
-        extern FUNCNAME##_Fake FUNCNAME##_fake;\
+        } FUNCNAME##_Fake; \
+        extern FUNCNAME##_Fake FUNCNAME##_fake; \
         void FUNCNAME##_reset(void); \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...); \
     FFF_END_EXTERN_C \
 
 #define DEFINE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
     FFF_EXTERN_C \
-        FUNCNAME##_Fake FUNCNAME##_fake;\
+        FUNCNAME##_Fake FUNCNAME##_fake; \
         RETURN_TYPE FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...){ \
             SAVE_ARG(FUNCNAME, 0); \
             SAVE_ARG(FUNCNAME, 1); \
@@ -6022,7 +6022,7 @@
             SAVE_ARG(FUNCNAME, 16); \
             SAVE_ARG(FUNCNAME, 17); \
             SAVE_ARG(FUNCNAME, 18); \
-            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){\
+            if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
                 SAVE_ARG_HISTORY(FUNCNAME, 0); \
                 SAVE_ARG_HISTORY(FUNCNAME, 1); \
                 SAVE_ARG_HISTORY(FUNCNAME, 2); \
@@ -6042,22 +6042,22 @@
                 SAVE_ARG_HISTORY(FUNCNAME, 16); \
                 SAVE_ARG_HISTORY(FUNCNAME, 17); \
                 SAVE_ARG_HISTORY(FUNCNAME, 18); \
-            }\
-            else{\
-                HISTORY_DROPPED(FUNCNAME);\
-            }\
+            } \
+            else{ \
+                HISTORY_DROPPED(FUNCNAME); \
+            } \
             INCREMENT_CALL_COUNT(FUNCNAME); \
             REGISTER_CALL(FUNCNAME); \
-            if(FUNCNAME##_fake.custom_fake){\
-                RETURN_TYPE ret;\
-                va_list ap;\
-                va_start(ap, arg18);\
-                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap);\
-                va_end(ap);\
+            if(FUNCNAME##_fake.custom_fake){ \
+                RETURN_TYPE ret; \
+                va_list ap; \
+                va_start(ap, arg18); \
+                ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+                va_end(ap); \
                 SAVE_RET_HISTORY(FUNCNAME, ret); \
-                return ret;\
-            }\
-            RETURN_FAKE_RESULT(FUNCNAME)  \
+                return ret; \
+            } \
+            RETURN_FAKE_RESULT(FUNCNAME) \
         } \
         DEFINE_RESET_FUNCTION(FUNCNAME) \
     FFF_END_EXTERN_C \