LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runsToJSONVerbose
static cJSON *runsToJSONVerbose(const RUN* runs) {
  cJSON *runsJSON = cJSON_CreateArray();
  assert(runsJSON);

  for (const RUN *r = runs; r; r = r->next) {
    cJSON *run = cJSON_CreateObject();
    assert(run);

    cJSON_AddBoolToObject(run, "success", r->success);
    cJSON_AddNumberToObject(run, "time", timevalToUsec(&(r->interval)));
    cJSON_AddNumberToObject(run, "input", r->inputBytes);
    cJSON_AddNumberToObject(run, "output", r->outputBytes);

    cJSON_AddItemToArray(runsJSON, run);
  }

  return runsJSON;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
callq 0x8240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x563e
jmp 0x565d
leaq 0x714c(%rip), %rdi      # 0xc791
leaq 0x6fdc(%rip), %rsi      # 0xc628
movl $0x1cc, %edx            # imm = 0x1CC
leaq 0x7142(%rip), %rcx      # 0xc79a
callq 0x21a0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x578e
callq 0x81a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5682
jmp 0x56a1
leaq 0x6fbe(%rip), %rdi      # 0xc647
leaq 0x6f98(%rip), %rsi      # 0xc628
movl $0x1d0, %edx            # imm = 0x1D0
leaq 0x70fe(%rip), %rcx      # 0xc79a
callq 0x21a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x710d(%rip), %rsi      # 0xc7c0
callq 0x7d90
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x44b0
movq -0x48(%rbp), %rdi
movq %rax, %xmm0
movaps 0x6f27(%rip), %xmm1     # 0xc600
movaps %xmm1, -0x40(%rbp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6f27(%rip), %xmm1     # 0xc610
movaps %xmm1, -0x30(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
leaq 0x70c5(%rip), %rsi      # 0xc7c8
callq 0x7e50
movaps -0x40(%rbp), %xmm2
movaps -0x30(%rbp), %xmm1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
leaq 0x7096(%rip), %rsi      # 0xc7cd
callq 0x7e50
movaps -0x40(%rbp), %xmm2
movaps -0x30(%rbp), %xmm1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
leaq 0x7068(%rip), %rsi      # 0xc7d3
callq 0x7e50
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7810
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5665
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultThreads
static unsigned int resultThreads(const RESULT* result) {
  unsigned int count = 0;
  for (const RESULT *re = result; re; re = re->next) {
    count ++;
  }
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x58f5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x58d7
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultTotalLoops
static unsigned long resultTotalLoops(const RESULT* result) {
  unsigned long total = 0;
  for (const RESULT *re = result; re; re = re->next) {
    total += getLoops(re->loops);
  }
  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5945
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x60d0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x591c
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultStdevLoop
static double resultStdevLoop(const RESULT* results) {
  unsigned long sumPow = 0;
  unsigned long avg = resultAvgLoop(results);
  unsigned int count = 0;

  for (const RESULT *re = results; re; re = re->next) {
    unsigned long loops = getLoops(re->loops);
    sumPow += (loops - avg) * (loops - avg);
    count ++;
  }

  return sqrt((double)sumPow/(double)count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5950
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5a0a
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x60d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq -0x18(%rbp), %rcx
imulq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x59c0
movaps 0x6bef(%rip), %xmm1     # 0xc600
movq -0x10(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6bee(%rip), %xmm1     # 0xc610
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movl -0x1c(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
callq 0x21e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultSampleInputByRun
static size_t resultSampleInputByRun(const RESULT *r, const unsigned int run) {
  size_t *samples = runInputSample(r->loops->runs);
  assert (samples);

  unsigned int ret = samples[run];

  free(samples);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x62d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5aeb
jmp 0x5b0a
leaq 0x6d7b(%rip), %rdi      # 0xc86d
leaq 0x6b2f(%rip), %rsi      # 0xc628
movl $0x142, %edx            # imm = 0x142
leaq 0x6e51(%rip), %rcx      # 0xc956
callq 0x21a0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2458
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultSampleOutputByRun
static size_t resultSampleOutputByRun(const RESULT *r, const unsigned int run) {
  size_t *samples = runOutputSample(r->loops->runs);
  assert (samples);

  unsigned int ret = samples[run];

  free(samples);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x5fc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5b5b
jmp 0x5b7a
leaq 0x6d0b(%rip), %rdi      # 0xc86d
leaq 0x6abf(%rip), %rsi      # 0xc628
movl $0x14d, %edx            # imm = 0x14D
leaq 0x6e23(%rip), %rcx      # 0xc998
callq 0x21a0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2458
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultTotalInputByRun
static size_t resultTotalInputByRun(const RESULT *results, const unsigned int run) {
  size_t total = 0;
  
  for (const RESULT* r = results; r; r = r->next) {
     total += loopTotalInput(r->loops, run);
  }

  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5beb
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x6350
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5bbf
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultTotalOutputByRun
static size_t resultTotalOutputByRun(const RESULT *results, const unsigned int run) {
  size_t total = 0;

  for (const RESULT* r = results; r; r = r->next) {
     total += loopTotalOutput(r->loops, run);
  }

  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5c4b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x6430
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5c1f
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultAvgIntervalByRun
static double resultAvgIntervalByRun(const RESULT* results, const unsigned int run) {
  struct timeval t;
  unsigned long total = 0;
  unsigned long loops = 0;
  unsigned int id = 0;

  for (const RESULT* r = results; r; r = r->next) {
    total += loopTotalTime(r->loops, run, &t);
    loops += resultThreadLoops(results, id);
  }

  return (double)total / (double)loops;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x5cd2
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x61a0
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x6510
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x5c8e
movq -0x28(%rbp), %xmm0
movaps 0x6922(%rip), %xmm3     # 0xc600
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x6926(%rip), %xmm2     # 0xc610
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x30(%rbp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultStdevIntervalByRun
static double resultStdevIntervalByRun(const RESULT* results, unsigned int run) {
  unsigned long avg = resultAvgIntervalByRun(results, run);
  unsigned long sumPow = 0;
  unsigned long loops = 0;
  unsigned int id = 0;

  for (const RESULT* r = results; r; r = r->next) {
    sumPow += loopSumPow(r->loops, run, avg);
    loops += resultThreadLoops(results, id);
    id++;
  }

  return sqrt((double)sumPow/(double)loops);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5c60
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x68ce(%rip), %xmm1     # 0xc620
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5dd1
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x6590
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x6510
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x5d84
movq -0x20(%rbp), %xmm0
movaps 0x6823(%rip), %xmm3     # 0xc600
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x6827(%rip), %xmm2     # 0xc610
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x28(%rbp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x21e0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: isLoopResultFixed
static int isLoopResultFixed(const LOOP* loops) {
  int ret = 1;
  size_t *samples = runOutputSample(loops->runs);
  assert(samples);

  for (const LOOP *l = loops->next; l; l = l->next) {
    if (!runCheckOutputSample(l->runs, samples)) { 
      ret = 0;
      break;
    }
  }

  free(samples);  
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5fc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5f4c
jmp 0x5f6b
leaq 0x691a(%rip), %rdi      # 0xc86d
leaq 0x66ce(%rip), %rsi      # 0xc628
movl $0x159, %edx            # imm = 0x159
leaq 0x690f(%rip), %rcx      # 0xc875
callq 0x21a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5fac
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6040
cmpl $0x0, %eax
jne 0x5f9c
movl $0x0, -0xc(%rbp)
jmp 0x5fac
jmp 0x5f9e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5f77
movq -0x18(%rbp), %rdi
callq 0x2458
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runOutputSample
static size_t *runOutputSample(const RUN* runs) {
  size_t *samples = NULL;
  unsigned int count = 0;

  for (const RUN* r = runs; r; r = r->next) {
    samples = (size_t*)realloc(samples, sizeof(size_t) * (count + 1));
    samples[count] = r->outputBytes;
    count ++;
  }

  return samples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x602f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x2468
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5fe3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runCheckOutputSample
static int runCheckOutputSample(RUN *runs, size_t *samples) {
  assert(samples);

  for (RUN* r = runs; r; r = r->next) {
    if (r->outputBytes != *(samples++)) return 0;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6059
jmp 0x6078
leaq 0x680d(%rip), %rdi      # 0xc86d
leaq 0x65c1(%rip), %rsi      # 0xc628
movl $0x11d, %edx            # imm = 0x11D
leaq 0x6826(%rip), %rcx      # 0xc899
callq 0x21a0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60bc
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x18(%rbp)
cmpq (%rcx), %rax
je 0x60ac
movl $0x0, -0x4(%rbp)
jmp 0x60c3
jmp 0x60ae
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6080
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: getLoops
static unsigned long getLoops(const LOOP* loop) {
  unsigned long count = 0;
  for (const LOOP *l = loop; l; l = l->next) {
    count ++;
  }
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6109
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x60e8
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultRealTimeByRun
static unsigned long resultRealTimeByRun(const RESULT* results, const unsigned int run,
                                  struct timeval *totalTime) {
  struct timeval t;
  unsigned long maxTime = 0; 

  for (const RESULT* r = results; r; r = r->next) {
    unsigned long time = loopTotalTime(r->loops, run, &t);
    if (time > maxTime) {
      maxTime = time;
      if (totalTime) {
        totalTime->tv_sec = t.tv_sec;
        totalTime->tv_usec = t.tv_usec;
      }
    }
  }
  return maxTime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x6193
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x61a0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x6183
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6181
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x6183
jmp 0x6185
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x6133
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: loopTotalTime
static unsigned long loopTotalTime(const LOOP* loops, const unsigned int run, 
                          struct timeval *totalTime) {
  assert(totalTime);
  totalTime->tv_sec = 0;
  totalTime->tv_usec = 0;

  for (const LOOP* l = loops; l; l = l->next) {
    runTotalTime(l->runs, run, totalTime);
  }

  return timevalToUsec(totalTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x61bc
jmp 0x61db
leaq 0x6700(%rip), %rdi      # 0xc8c3
leaq 0x645e(%rip), %rsi      # 0xc628
movl $0xbc, %edx
leaq 0x66f7(%rip), %rcx      # 0xc8cd
callq 0x21a0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6222
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x6240
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x61fa
movq -0x18(%rbp), %rdi
callq 0x44b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runTotalTime
static void runTotalTime(RUN* runs, unsigned int run, struct timeval *time) {
  assert(time);
  unsigned int id = 0;
  for (RUN *r = runs; r; r = r->next) {
    if (run == ~0 || run == id) timevalAddAdd(time, &(r->interval));
    id ++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x625c
jmp 0x627b
leaq 0x6565(%rip), %rdi      # 0xc7c8
leaq 0x63be(%rip), %rsi      # 0xc628
movl $0xb2, %edx
leaq 0x66a7(%rip), %rcx      # 0xc91d
callq 0x21a0
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x62c3
cmpl $-0x1, -0xc(%rbp)
je 0x629f
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x62ac
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4550
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x628a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runInputSample
static size_t *runInputSample(RUN* runs) {
  size_t *samples = NULL;
  unsigned int count = 0;

  for (RUN* r = runs; r; r = r->next) {
    samples = (size_t*)realloc(samples, sizeof(size_t) * (count + 1));
    samples[count] = r->inputBytes;
    count ++;
  }

  return samples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x633f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x2468
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x62f3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: loopTotalInput
static size_t loopTotalInput(const LOOP *loops, const unsigned int run) {
  size_t total = 0;

  for (const LOOP *l = loops; l; l = l->next) {
    total += runTotalInput(l->runs, run);
  }

  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x639b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x63b0
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x636f
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runTotalInput
static size_t runTotalInput(const RUN* runs, const unsigned int run) {
  int id = 0;

  for (const RUN* r = runs; r; r = r->next) {
    if (id == run) return r->inputBytes;
    id ++;
  }
  assert(0);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6402
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x63eb
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x63ce
leaq 0x5fca(%rip), %rdi      # 0xc3d3
leaq 0x6218(%rip), %rsi      # 0xc628
movl $0x71, %edx
leaq 0x65bf(%rip), %rcx      # 0xc9db
callq 0x21a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: loopTotalOutput
static size_t loopTotalOutput(const LOOP *loops, const unsigned int run) {
  size_t total = 0;

  for (const LOOP *l = loops; l; l = l->next) {
    total += runTotalOutput(l->runs, run);
  }

  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x647b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x6490
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x644f
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runTotalOutput
static size_t runTotalOutput(const RUN* runs, const unsigned int run) {
  int id = 0;

  for (const RUN* r = runs; r; r = r->next) {
    if (id == run) return r->outputBytes;
    id ++;
  }
  assert(0);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x64e2
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x64cb
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x64ae
leaq 0x5eea(%rip), %rdi      # 0xc3d3
leaq 0x6138(%rip), %rsi      # 0xc628
movl $0x91, %edx
leaq 0x6515(%rip), %rcx      # 0xca11
callq 0x21a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultThreadLoops
static unsigned long resultThreadLoops(const RESULT* result, const unsigned int thread) {
  unsigned int currentThread = 0;

  for (const RESULT *re = result; re; re = re->next) {
    if (currentThread == thread) {
      return getLoops(re->loops);
    }

    currentThread ++;
  }
  assert(0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6566
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x654f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x60d0
addq $0x20, %rsp
popq %rbp
retq
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x652e
leaq 0x5e66(%rip), %rdi      # 0xc3d3
leaq 0x60b4(%rip), %rsi      # 0xc628
movl $0x65, %edx
leaq 0x64c8(%rip), %rcx      # 0xca48
callq 0x21a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: loopSumPow
static unsigned long loopSumPow(LOOP* loops, unsigned int run, unsigned long avg) {
  unsigned long usec = 0;
  unsigned long sumPow = 0;

  struct timeval t;

  for (LOOP* l = loops; l; l = l->next) {
    t.tv_sec = 0;
    t.tv_usec = 0;
    
    runTotalTime(l->runs, run, &t);
    usec = timevalToUsec(&t);

    sumPow += (usec - avg) * (usec - avg);
  }

  return sumPow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x661c
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x6240
leaq -0x38(%rbp), %rdi
callq 0x44b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
imulq %rcx, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x65bb
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_InitHooks
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
{
    if (hooks == NULL)
    {
        /* Reset hooks */
        global_hooks.allocate = malloc;
        global_hooks.deallocate = free;
        global_hooks.reallocate = realloc;
        return;
    }

    global_hooks.allocate = malloc;
    if (hooks->malloc_fn != NULL)
    {
        global_hooks.allocate = hooks->malloc_fn;
    }

    global_hooks.deallocate = free;
    if (hooks->free_fn != NULL)
    {
        global_hooks.deallocate = hooks->free_fn;
    }

    /* use realloc only if both free and malloc are used */
    global_hooks.reallocate = NULL;
    if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
    {
        global_hooks.reallocate = realloc;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x674e
movq 0x989a(%rip), %rax      # 0xffc0
movq %rax, 0x9b13(%rip)      # 0x10240
movq 0x9884(%rip), %rax      # 0xffb8
movq %rax, 0x9b0d(%rip)      # 0x10248
movq 0x9896(%rip), %rax      # 0xffd8
movq %rax, 0x9b07(%rip)      # 0x10250
jmp 0x67d5
movq 0x986b(%rip), %rax      # 0xffc0
movq %rax, 0x9ae4(%rip)      # 0x10240
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6774
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x9acc(%rip)      # 0x10240
movq 0x983d(%rip), %rax      # 0xffb8
movq %rax, 0x9ac6(%rip)      # 0x10248
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x679c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x9aac(%rip)      # 0x10248
movq $0x0, 0x9aa9(%rip) # 0x10250
movq 0x9812(%rip), %rax      # 0xffc0
cmpq %rax, 0x9a8b(%rip)      # 0x10240
jne 0x67d5
movq 0x97fa(%rip), %rax      # 0xffb8
cmpq %rax, 0x9a83(%rip)      # 0x10248
jne 0x67d5
movq 0x980a(%rip), %rax      # 0xffd8
movq %rax, 0x9a7b(%rip)      # 0x10250
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_Delete
CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
{
    cJSON *next = NULL;
    while (item != NULL)
    {
        next = item->next;
        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
        {
            cJSON_Delete(item->child);
        }
        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
        {
            global_hooks.deallocate(item->valuestring);
        }
        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
        {
            global_hooks.deallocate(item->string);
        }
        global_hooks.deallocate(item);
        item = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x68a7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x6833
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6833
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x67e0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x6860
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6860
movq 0x99f2(%rip), %rax      # 0x10248
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x688d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x688d
movq 0x99c5(%rip), %rax      # 0x10248
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq 0x99b4(%rip), %rax      # 0x10248
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x67f4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_SetNumberHelper
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
{
    if (number >= INT_MAX)
    {
        object->valueint = INT_MAX;
    }
    else if (number <= (double)INT_MIN)
    {
        object->valueint = INT_MIN;
    }
    else
    {
        object->valueint = (int)number;
    }

    return object->valuedouble = number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x61c6(%rip), %xmm1     # 0xca90
ucomisd %xmm1, %xmm0
jb 0x68dd
movq -0x8(%rbp), %rax
movl $0x7fffffff, 0x28(%rax) # imm = 0x7FFFFFFF
jmp 0x6907
movsd 0x61b3(%rip), %xmm0     # 0xca98
ucomisd -0x10(%rbp), %xmm0
jb 0x68f9
movq -0x8(%rbp), %rax
movl $0x80000000, 0x28(%rax) # imm = 0x80000000
jmp 0x6905
cvttsd2si -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x6907
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_New_Item
static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
{
    cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
    if (node)
    {
        memset(node, '\0', sizeof(cJSON));
    }

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x40, %edi
callq *(%rax)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6b12
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2130
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: buffer_skip_whitespace
static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
    if ((buffer == NULL) || (buffer->content == NULL))
    {
        return NULL;
    }

    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
    {
       buffer->offset++;
    }

    if (buffer->offset == buffer->length)
    {
        buffer->offset--;
    }

    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6e19
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6e26
movq $0x0, -0x8(%rbp)
jmp 0x6eb0
jmp 0x6e28
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x6e6b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x0, %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0x6e6b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setle %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6e74
jmp 0x6e86
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x6e28
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x6ea8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: skip_utf8_bom
static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
{
    if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
    {
        return NULL;
    }

    if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
    {
        buffer->offset += 3;
    }

    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6ee8
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6ee8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6ef2
movq $0x0, -0x8(%rbp)
jmp 0x6f4c
cmpq $0x0, -0x10(%rbp)
je 0x6f44
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x6f44
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rdi
leaq 0x5cdc(%rip), %rsi      # 0xcc01
movl $0x3, %edx
callq 0x2100
cmpl $0x0, %eax
jne 0x6f44
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x3, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_PrintBuffered
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
{
    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };

    if (prebuffer < 0)
    {
        return NULL;
    }

    p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
    if (!p.buffer)
    {
        return NULL;
    }

    p.length = (size_t)prebuffer;
    p.offset = 0;
    p.noalloc = false;
    p.format = fmt;
    p.hooks = global_hooks;

    if (!print_value(item, &p))
    {
        global_hooks.deallocate(p.buffer);
        return NULL;
    }

    return (char*)p.buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2130
cmpl $0x0, -0x14(%rbp)
jge 0x71c5
movq $0x0, -0x8(%rbp)
jmp 0x7256
movq 0x9074(%rip), %rax      # 0x10240
movslq -0x14(%rbp), %rdi
callq *%rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x71e7
movq $0x0, -0x8(%rbp)
jmp 0x7256
movslq -0x14(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movq 0x9035(%rip), %rax      # 0x10240
movq %rax, -0x30(%rbp)
movq 0x9032(%rip), %rax      # 0x10248
movq %rax, -0x28(%rbp)
movq 0x902f(%rip), %rax      # 0x10250
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7260
cmpl $0x0, %eax
jne 0x724e
movq 0x900a(%rip), %rax      # 0x10248
movq -0x58(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x7256
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_PrintPreallocated
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt)
{
    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };

    if ((len < 0) || (buf == NULL))
    {
        return false;
    }

    p.buffer = (unsigned char*)buf;
    p.length = (size_t)len;
    p.offset = 0;
    p.noalloc = true;
    p.format = fmt;
    p.hooks = global_hooks;

    return print_value(item, &p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2130
cmpl $0x0, -0x1c(%rbp)
jl 0x74d3
cmpq $0x0, -0x18(%rbp)
jne 0x74dc
movl $0x0, -0x4(%rbp)
jmp 0x7532
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movl $0x1, -0x40(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq 0x8d38(%rip), %rax      # 0x10240
movq %rax, -0x38(%rbp)
movq 0x8d35(%rip), %rax      # 0x10248
movq %rax, -0x30(%rbp)
movq 0x8d32(%rip), %rax      # 0x10250
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7260
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_GetArraySize
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
{
    cJSON *child = NULL;
    size_t size = 0;

    if (array == NULL)
    {
        return 0;
    }

    child = array->child;

    while(child != NULL)
    {
        size++;
        child = child->next;
    }

    /* FIXME: Can overflow here. Cannot be fixed without breaking the API */

    return (int)size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7568
movl $0x0, -0x4(%rbp)
jmp 0x759b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7594
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7574
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: get_array_item
static cJSON* get_array_item(const cJSON *array, size_t index)
{
    cJSON *current_child = NULL;

    if (array == NULL)
    {
        return NULL;
    }

    current_child = array->child;
    while ((current_child != NULL) && (index > 0))
    {
        index--;
        current_child = current_child->next;
    }

    return current_child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7605
movq $0x0, -0x8(%rbp)
jmp 0x7652
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x7628
cmpq $0x0, -0x18(%rbp)
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7631
jmp 0x764a
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7611
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: get_object_item
static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
{
    cJSON *current_element = NULL;

    if ((object == NULL) || (name == NULL))
    {
        return NULL;
    }

    current_element = object->child;
    if (case_sensitive)
    {
        while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0))
        {
            current_element = current_element->next;
        }
    }
    else
    {
        while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
        {
            current_element = current_element->next;
        }
    }

    if ((current_element == NULL) || (current_element->string == NULL)) {
        return NULL;
    }

    return current_element;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x76b9
cmpq $0x0, -0x18(%rbp)
jne 0x76c6
movq $0x0, -0x8(%rbp)
jmp 0x778c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7728
jmp 0x76da
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x7710
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, -0x29(%rbp)
je 0x7710
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x2320
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7719
jmp 0x7726
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x76da
jmp 0x7768
jmp 0x772a
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x2a(%rbp)
je 0x7750
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xb380
cmpl $0x0, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x7759
jmp 0x7766
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x772a
jmp 0x7768
cmpq $0x0, -0x28(%rbp)
je 0x777a
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x7784
movq $0x0, -0x8(%rbp)
jmp 0x778c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: add_item_to_array
static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
{
    cJSON *child = NULL;

    if ((item == NULL) || (array == NULL))
    {
        return false;
    }

    child = array->child;

    if (child == NULL)
    {
        /* list is empty, start new one */
        array->child = item;
    }
    else
    {
        /* append to the end */
        while (child->next)
        {
            child = child->next;
        }
        suffix_object(child, item);
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7866
cmpq $0x0, -0x10(%rbp)
jne 0x786f
movl $0x0, -0x4(%rbp)
jmp 0x78bd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7890
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x78b6
jmp 0x7892
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x78a9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7892
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8a20
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: add_item_to_object
static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)
{
    char *new_key = NULL;
    int new_type = cJSON_Invalid;

    if ((object == NULL) || (string == NULL) || (item == NULL))
    {
        return false;
    }

    if (constant_key)
    {
        new_key = (char*)cast_away_const(string);
        new_type = item->type | cJSON_StringIsConst;
    }
    else
    {
        new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
        if (new_key == NULL)
        {
            return false;
        }

        new_type = item->type & ~cJSON_StringIsConst;
    }

    if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
    {
        hooks->deallocate(item->string);
    }

    item->string = new_key;
    item->type = new_type;

    return add_item_to_array(object, item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7950
cmpq $0x0, -0x18(%rbp)
je 0x7950
cmpq $0x0, -0x20(%rbp)
jne 0x795c
movl $0x0, -0x4(%rbp)
jmp 0x7a04
cmpl $0x0, -0x2c(%rbp)
je 0x7980
movq -0x18(%rbp), %rdi
callq 0x8870
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, -0x3c(%rbp)
jmp 0x79b0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8790
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x79a1
movl $0x0, -0x4(%rbp)
jmp 0x7a04
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xfffffdff, %eax       # imm = 0xFFFFFDFF
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x79de
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x79de
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7840
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: create_reference
static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
{
    cJSON *reference = NULL;
    if (item == NULL)
    {
        return NULL;
    }

    reference = cJSON_New_Item(hooks);
    if (reference == NULL)
    {
        return NULL;
    }

    memcpy(reference, item, sizeof(cJSON));
    reference->string = NULL;
    reference->type |= cJSON_IsReference;
    reference->next = reference->prev = NULL;
    return reference;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7ac9
movq $0x0, -0x8(%rbp)
jmp 0x7b34
movq -0x18(%rbp), %rdi
callq 0x6ae0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7ae7
movq $0x0, -0x8(%rbp)
jmp 0x7b34
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x21f0
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop