LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/grammar.c
// Function: test_language
void test_language(void) {
  
  mpc_parser_t *Expr, *Prod, *Value, *Maths;
  
  Expr  = mpc_new("expression");
  Prod  = mpc_new("product");
  Value = mpc_new("value");
  Maths = mpc_new("maths");
  
  mpca_lang(MPCA_LANG_DEFAULT,
    " expression : <product> (('+' | '-') <product>)*; "
    " product : <value>   (('*' | '/')   <value>)*;    "
    " value : /[0-9]+/ | '(' <expression> ')';         "
    " maths : /^/ <expression> /$/;                    ",
    Expr, Prod, Value, Maths);
  
  mpc_cleanup(4, Expr, Prod, Value, Maths);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xcc9b(%rip), %rdi      # 0xfbce
callq 0x71ca
movq %rax, %rbx
leaq 0xcc97(%rip), %rdi      # 0xfbd9
callq 0x71ca
movq %rax, %r14
leaq 0xcc90(%rip), %rdi      # 0xfbe1
callq 0x71ca
movq %rax, %r15
leaq 0xc39a(%rip), %rdi      # 0xf2fa
callq 0x71ca
movq %rax, %r12
leaq 0xd038(%rip), %rsi      # 0xffa7
xorl %edi, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xccc2
movl $0x4, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75de
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/grammar.c
// Function: test_language_file
void test_language_file(void) {
  
  mpc_parser_t *Expr, *Prod, *Value, *Maths;
  
  Expr  = mpc_new("expression");
  Prod  = mpc_new("product");
  Value = mpc_new("value");
  Maths = mpc_new("maths");
  
  mpca_lang_contents(MPCA_LANG_DEFAULT, "./tests/maths.grammar", Expr, Prod, Value, Maths);
  
  mpc_cleanup(4, Expr, Prod, Value, Maths);
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xcc18(%rip), %rdi      # 0xfbce
callq 0x71ca
movq %rax, %rbx
leaq 0xcc14(%rip), %rdi      # 0xfbd9
callq 0x71ca
movq %rax, %r14
leaq 0xcc0d(%rip), %rdi      # 0xfbe1
callq 0x71ca
movq %rax, %r15
leaq 0xc317(%rip), %rdi      # 0xf2fa
callq 0x71ca
movq %rax, %r12
leaq 0xd07e(%rip), %rsi      # 0x10070
xorl %edi, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xcd9c
movl $0x4, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75de
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/grammar.c
// Function: test_missingrule
void test_missingrule(void) {
  
  int result;
  mpc_err_t *err;
  mpc_result_t r;
  mpc_parser_t *Parser = mpc_new("parser");
  
  err = mpca_lang(MPCA_LANG_DEFAULT,
    "parser        : /^/ (<missing>)* /$/ ;\n",
    Parser, NULL);
  
  PT_ASSERT(err == NULL);
  
  result = mpc_parse("<stdin>", "test", Parser, &r);
  
  PT_ASSERT(result == 0);
  PT_ASSERT(r.error != NULL);
  PT_ASSERT(strcmp(r.error->failure, "Unknown Parser 'missing'!") == 0);
  
  mpc_err_delete(r.error);
  mpc_cleanup(1, Parser);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xca27(%rip), %rdi      # 0x10327
callq 0x71ca
movq %rax, %rbx
leaq 0xd0c4(%rip), %rsi      # 0x109d3
xorl %edi, %edi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xccc2
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0xca9f(%rip), %rsi      # 0x103cc
leaq 0xc406(%rip), %r14      # 0xfd3a
movq %r14, %rdx
movl $0x110, %ecx            # imm = 0x110
callq 0x4094
leaq 0xd0b3(%rip), %rdi      # 0x109fb
leaq 0xb6c2(%rip), %rsi      # 0xf011
leaq 0x8(%rsp), %r15
movq %rbx, %rdx
movq %r15, %rcx
callq 0x6bd7
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd095(%rip), %rsi      # 0x10a03
movq %r14, %rdx
movl $0x114, %ecx            # imm = 0x114
callq 0x4094
xorl %edi, %edi
cmpq $0x0, (%r15)
setne %dil
leaq 0xd083(%rip), %rsi      # 0x10a0f
movq %r14, %rdx
movl $0x115, %ecx            # imm = 0x115
callq 0x4094
movq (%r15), %rax
movq 0x30(%rax), %rdi
leaq 0xd078(%rip), %rsi      # 0x10a1f
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd07e(%rip), %rsi      # 0x10a39
movq %r14, %rdx
movl $0x116, %ecx            # imm = 0x116
callq 0x4094
movq (%r15), %rdi
callq 0x56b0
movl $0x1, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x75de
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/grammar.c
// Function: suite_grammar
void suite_grammar(void) {
  pt_add_test(test_grammar, "Test Grammar", "Suite Grammar");
  pt_add_test(test_language, "Test Language", "Suite Grammar");
  pt_add_test(test_language_file, "Test Language File", "Suite Grammar");
  pt_add_test(test_doge, "Test Doge", "Suite Grammar");
  pt_add_test(test_partial, "Test Partial", "Suite Grammar");
  pt_add_test(test_qscript, "Test QScript", "Suite Grammar");
  pt_add_test(test_missingrule, "Test Missing Rule", "Suite Grammar");
  pt_add_test(test_regex_mode, "Test Regex Mode", "Suite Grammar");
  pt_add_test(test_digits_file, "Test Digits File", "Suite Grammar");
}

// Assembly:
pushq %rbx
leaq -0x14c2(%rip), %rdi     # 0x2b08
leaq 0xce7a(%rip), %rsi      # 0x10e4b
leaq 0xce80(%rip), %rbx      # 0x10e58
movq %rbx, %rdx
callq 0x410b
leaq -0x10c3(%rip), %rdi     # 0x2f24
leaq 0xce78(%rip), %rsi      # 0x10e66
movq %rbx, %rdx
callq 0x410b
leaq -0x1056(%rip), %rdi     # 0x2fa7
leaq 0xce70(%rip), %rsi      # 0x10e74
movq %rbx, %rdx
callq 0x410b
leaq -0xfe9(%rip), %rdi      # 0x302a
leaq 0xce6d(%rip), %rsi      # 0x10e87
movq %rbx, %rdx
callq 0x410b
leaq -0xdfb(%rip), %rdi      # 0x322e
leaq 0xce61(%rip), %rsi      # 0x10e91
movq %rbx, %rdx
callq 0x410b
leaq -0xc09(%rip), %rdi      # 0x3436
leaq 0xce58(%rip), %rsi      # 0x10e9e
movq %rbx, %rdx
callq 0x410b
leaq -0x765(%rip), %rdi      # 0x38f0
leaq 0xce4f(%rip), %rsi      # 0x10eab
movq %rbx, %rdx
callq 0x410b
leaq -0x682(%rip), %rdi      # 0x39e9
leaq 0xce4b(%rip), %rsi      # 0x10ebd
movq %rbx, %rdx
callq 0x410b
leaq -0x3ea(%rip), %rdi      # 0x3c97
leaq 0xce45(%rip), %rsi      # 0x10ecd
movq %rbx, %rdx
popq %rbx
jmp 0x410b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/ptest.c
// Function: pt_assert_run
void pt_assert_run(int result, const char* expr, const char* file, int line) {

  num_asserts++;
  test_passing = test_passing && result;

  if (result) {
    num_assert_passes++;
  } else {
    sprintf(assert_err_buff,
      "        %i. Assert [ %s ] (%s:%i)\n",
      assert_err_num+1, expr, file, line );
    strcat(assert_err, assert_err_buff);
    assert_err_num++;
    num_assert_fails++;
  }

}

// Assembly:
pushq %rbx
incl 0x14155(%rip)           # 0x181f0
movq %rdx, %r8
cmpl $0x0, 0x1414f(%rip)     # 0x181f4
setne %al
testl %edi, %edi
setne %dl
andb %al, %dl
movzbl %dl, %eax
movl %eax, 0x1413c(%rip)     # 0x181f4
testl %edi, %edi
je 0x40c5
leaq 0x14135(%rip), %rax     # 0x181f8
jmp 0x4107
movl %ecx, %r9d
movq %rsi, %rcx
movl 0x1492f(%rip), %edx     # 0x18a00
incl %edx
leaq 0x14126(%rip), %rbx     # 0x18200
leaq 0xce07(%rip), %rsi      # 0x10ee8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1220
leaq 0x1491e(%rip), %rdi     # 0x18a10
movq %rbx, %rsi
callq 0x1210
incl 0x14900(%rip)           # 0x18a00
leaq 0x15109(%rip), %rax     # 0x19210
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/ptest.c
// Function: pt_add_test
void pt_add_test(void (*func)(void), const char* name, const char* suite) {

  test_t test;

  if (num_tests == MAX_TESTS) {
    printf("ERROR: Exceeded maximum test count of %i!\n",
      MAX_TESTS); abort();
  }

  if (strlen(name) >= MAX_NAME) {
    printf("ERROR: Test name '%s' too long (Maximum is %i characters)\n",
      name, MAX_NAME); abort();
  }

  if (strlen(suite) >= MAX_NAME) {
    printf("ERROR: Test suite '%s' too long (Maximum is %i characters)\n",
      suite, MAX_NAME); abort();
  }

  test.func = func;
  pt_title_case(test.name, name);
  pt_title_case(test.suite, suite);

  tests[num_tests] = test;
  num_tests++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movslq 0x150f4(%rip), %r12     # 0x19214
cmpq $0x800, %r12            # imm = 0x800
je 0x41bb
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x10b0
cmpq $0x200, %rax            # imm = 0x200
jae 0x41d3
movq %rbx, %rdi
callq 0x10b0
cmpq $0x200, %rax            # imm = 0x200
jae 0x41df
leaq 0x8(%rsp), %rdi
movq %r15, -0x8(%rdi)
movq %r14, %rsi
callq 0x41fa
leaq 0x208(%rsp), %rdi
movq %rbx, %rsi
callq 0x41fa
movq %r12, %rax
shlq $0xa, %rax
leaq (%rax,%r12,8), %rax
leaq 0x1508f(%rip), %rdi     # 0x19220
addq %rax, %rdi
movq %rsp, %rsi
movl $0x408, %edx            # imm = 0x408
callq 0x1180
leal 0x1(%r12), %eax
movl %eax, 0x15068(%rip)     # 0x19214
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xcd49(%rip), %rdi      # 0x10f0b
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
callq 0x10d0
callq 0x1040
leaq 0xcd5c(%rip), %rdi      # 0x10f36
movq %r14, %rsi
jmp 0x41e9
leaq 0xcd8b(%rip), %rdi      # 0x10f71
movq %rbx, %rsi
movl $0x200, %edx            # imm = 0x200
xorl %eax, %eax
callq 0x10d0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/ptest.c
// Function: pt_title_case
static void pt_title_case(char* output, const char* input) {

  int space = 1;
  unsigned int i;

  strcpy(output, input);

  for(i = 0; i < strlen(output); i++) {

    if (output[i] == '_' || output[i] == ' ') {
      space = 1;
      output[i] = ' ';
      continue;
    }

    if (space && output[i] >= 'a' && output[i] <= 'z') {
      space = 0;
      output[i] = output[i] - 32;
      continue;
    }

    space = 0;

  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1060
cmpb $0x0, (%rbx)
je 0x4261
movl $0x1, %ebp
xorl %r14d, %r14d
movl $0x1, %ecx
movzbl (%rbx,%r14), %eax
movb $0x20, %dl
movl $0x1, %r15d
cmpl $0x20, %eax
je 0x4248
cmpl $0x5f, %eax
je 0x4248
xorl %r15d, %r15d
testl %ecx, %ecx
je 0x424c
leal -0x61(%rax), %ecx
cmpb $0x19, %cl
ja 0x424c
addb $-0x20, %al
xorl %r15d, %r15d
movl %eax, %edx
movb %dl, (%rbx,%r14)
movl %ebp, %r14d
movq %rbx, %rdi
callq 0x10b0
incl %ebp
movl %r15d, %ecx
cmpq %r14, %rax
ja 0x421b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/ptest.c
// Function: ptest_signal
static void ptest_signal(int sig) {

  test_passing = 0;

  switch( sig ) {
    case SIGFPE:  sprintf(assert_err_buff,
      "        %i. Division by Zero\n", assert_err_num+1);
    break;
    case SIGILL:  sprintf(assert_err_buff,
      "        %i. Illegal Instruction\n", assert_err_num+1);
    break;
    case SIGSEGV: sprintf(assert_err_buff,
      "        %i. Segmentation Fault\n", assert_err_num+1);
    break;
    default: break;
  }

  assert_err_num++;
  strcat(assert_err, assert_err_buff);

  pt_color(RED);
  printf("Failed! \n\n%s\n", assert_err);
  pt_color(DEFAULT);

  puts("    | Stopping Execution.");
  fflush(stdout);
  exit(0);

}

// Assembly:
pushq %rbx
movl $0x0, 0x13a50(%rip)     # 0x181f4
cmpl $0xb, %edi
je 0x47c5
cmpl $0x8, %edi
je 0x47bc
cmpl $0x4, %edi
jne 0x47e2
leaq 0xca62(%rip), %rsi      # 0x1121c
jmp 0x47cc
leaq 0xca3b(%rip), %rsi      # 0x111fe
jmp 0x47cc
leaq 0xca71(%rip), %rsi      # 0x1123d
movl 0x1422e(%rip), %edx     # 0x18a00
incl %edx
leaq 0x13a25(%rip), %rdi     # 0x18200
xorl %eax, %eax
callq 0x1220
incl 0x14218(%rip)           # 0x18a00
leaq 0x14221(%rip), %rbx     # 0x18a10
leaq 0x13a0a(%rip), %rsi     # 0x18200
movq %rbx, %rdi
callq 0x1210
movl $0x4, %edi
callq 0x4845
leaq 0xc8c3(%rip), %rdi      # 0x110d2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10d0
movl $0x10, %edi
callq 0x4845
leaq 0xca33(%rip), %rdi      # 0x1125d
callq 0x1070
movq 0x137aa(%rip), %rax     # 0x17fe0
movq (%rax), %rdi
callq 0x11a0
xorl %edi, %edi
callq 0x1230
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_range
void test_regex_range(void) {

  mpc_parser_t *re0, *re1, *re2, *re3;

  re0 = mpc_re("abg[abcdef]");
  re1 = mpc_re("y*[a-z]");
  re2 = mpc_re("zz(p+)?[A-Z_0\\]123]*");
  re3 = mpc_re("^[^56hy].*$");

  /* TODO: Testing */

  mpc_delete(re0);
  mpc_delete(re1);
  mpc_delete(re2);
  mpc_delete(re3);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc83f(%rip), %rdi      # 0x11718
callq 0x9153
movq %rax, %rbx
leaq 0xc83c(%rip), %rdi      # 0x11724
callq 0x9153
movq %rax, %r14
leaq 0xc835(%rip), %rdi      # 0x1172c
callq 0x9153
movq %rax, %r15
leaq 0xc83b(%rip), %rdi      # 0x11741
callq 0x9153
movq %rax, %r12
movq %rbx, %rdi
callq 0x708b
movq %r14, %rdi
callq 0x708b
movq %r15, %rdi
callq 0x708b
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_string
void test_regex_string(void) {

  mpc_parser_t *re0 = mpc_re("\"(\\\\.|[^\"])*\"");

  PT_ASSERT(regex_test_pass(re0, "\"there\"", "\"there\""));
  PT_ASSERT(regex_test_pass(re0, "\"hello\"", "\"hello\""));
  PT_ASSERT(regex_test_pass(re0, "\"i am dan\"", "\"i am dan\""));
  PT_ASSERT(regex_test_pass(re0, "\"i a\\\"m dan\"", "\"i a\\\"m dan\""));

  mpc_delete(re0);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xc804(%rip), %rdi      # 0x1174d
callq 0x9153
movq %rax, %rbx
leaq 0xc803(%rip), %rdx      # 0x1175b
leaq -0x6e1(%rip), %r14      # 0x487e
movq 0x13062(%rip), %r15     # 0x17fc8
leaq -0x6de(%rip), %r12      # 0x488f
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc7db(%rip), %rsi      # 0x11763
leaq 0xc3ca(%rip), %r13      # 0x11359
movl %eax, %edi
movq %r13, %rdx
movl $0x67, %ecx
callq 0x4094
leaq 0xc7ed(%rip), %rdx      # 0x11792
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc7da(%rip), %rsi      # 0x1179a
movl %eax, %edi
movq %r13, %rdx
movl $0x68, %ecx
callq 0x4094
leaq 0xc7f3(%rip), %rdx      # 0x117c9
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc7e3(%rip), %rsi      # 0x117d4
movl %eax, %edi
movq %r13, %rdx
movl $0x69, %ecx
callq 0x4094
leaq 0xc802(%rip), %rdx      # 0x11809
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc7f4(%rip), %rsi      # 0x11816
movl %eax, %edi
movq %r13, %rdx
movl $0x6a, %ecx
callq 0x4094
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_lisp_comment
void test_regex_lisp_comment(void) {

  mpc_parser_t *re0 = mpc_re(";[^\\n\\r]*");

  PT_ASSERT(regex_test_pass(re0, ";comment", ";comment"));
  PT_ASSERT(regex_test_pass(re0, ";i am the\nman", ";i am the"));

  mpc_delete(re0);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xc801(%rip), %rdi      # 0x11853
callq 0x9153
movq %rax, %rbx
leaq 0xc7fc(%rip), %rdx      # 0x1185d
leaq -0x7ea(%rip), %r14      # 0x487e
movq 0x12f59(%rip), %r15     # 0x17fc8
leaq -0x7e7(%rip), %r12      # 0x488f
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc7d5(%rip), %rsi      # 0x11866
leaq 0xc2c1(%rip), %r13      # 0x11359
movl %eax, %edi
movq %r13, %rdx
movl $0x74, %ecx
callq 0x4094
leaq 0xc7e5(%rip), %rsi      # 0x11893
leaq 0xc7ec(%rip), %rdx      # 0x118a1
movq %rbx, %rdi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc7de(%rip), %rsi      # 0x118ab
movl %eax, %edi
movq %r13, %rdx
movl $0x75, %ecx
callq 0x4094
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_newline
void test_regex_newline(void) {

  mpc_parser_t *re0 = mpc_re("[a-z]*");

  PT_ASSERT(regex_test_pass(re0, "hi", "hi"));
  PT_ASSERT(regex_test_pass(re0, "hi\nk", "hi"));
  PT_ASSERT(regex_test_fail(re0, "hi\nk", "hi\nk"));

  mpc_delete(re0);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc7e0(%rip), %rdi      # 0x118df
callq 0x9153
movq %rax, %rbx
leaq 0xc7d8(%rip), %rbp      # 0x118e6
leaq -0x897(%rip), %rcx      # 0x487e
movq 0x12eac(%rip), %r12     # 0x17fc8
leaq -0x894(%rip), %r13      # 0x488f
movq %rax, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
movq %r12, %r8
movq %r13, %r9
callq 0xa93d
leaq 0xc7ab(%rip), %rsi      # 0x118e9
leaq 0xc214(%rip), %r15      # 0x11359
movl %eax, %edi
movq %r15, %rdx
movl $0x7f, %ecx
callq 0x4094
leaq 0xc7af(%rip), %r14      # 0x1190a
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
leaq -0x8ed(%rip), %rcx      # 0x487e
movq %r12, %r8
movq %r13, %r9
callq 0xa93d
leaq 0xc792(%rip), %rsi      # 0x1190f
movl %eax, %edi
movq %r15, %rdx
movl $0x80, %ecx
callq 0x4094
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
leaq -0x91e(%rip), %rcx      # 0x487e
movq %r12, %r8
movq %r13, %r9
callq 0xa8c1
leaq 0xc785(%rip), %rsi      # 0x11933
movl %eax, %edi
movq %r15, %rdx
movl $0x81, %ecx
callq 0x4094
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_multiline
void test_regex_multiline(void) {

  mpc_parser_t *re0 = mpc_re_mode("(^[a-z]*$)*", MPC_RE_MULTILINE);

  PT_ASSERT(regex_test_pass(re0, "hello\nhello", "hello\nhello"));
  PT_ASSERT(regex_test_pass(re0, "hello\nhello\n", "hello\nhello\n"));
  PT_ASSERT(regex_test_pass(re0, "\nblah\n\nblah\n", "\nblah\n\nblah\n"));
  PT_ASSERT(regex_test_fail(re0, "45234", "45234"));
  PT_ASSERT(regex_test_fail(re0, "\n45234", "\n45234"));
  PT_ASSERT(regex_test_pass(re0, "\n45234", "\n"));

  mpc_delete(re0);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc775(%rip), %rdi      # 0x1195a
movl $0x1, %esi
callq 0x915a
movq %rax, %rbx
leaq 0xc76d(%rip), %rdx      # 0x11966
leaq -0x982(%rip), %r14      # 0x487e
movq 0x12dc1(%rip), %r15     # 0x17fc8
leaq -0x97f(%rip), %r12      # 0x488f
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc749(%rip), %rsi      # 0x11972
leaq 0xc129(%rip), %r13      # 0x11359
movl %eax, %edi
movq %r13, %rdx
movl $0x8b, %ecx
callq 0x4094
leaq 0xc761(%rip), %rdx      # 0x119a7
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc753(%rip), %rsi      # 0x119b4
movl %eax, %edi
movq %r13, %rdx
movl $0x8c, %ecx
callq 0x4094
leaq 0xc776(%rip), %rdx      # 0x119ed
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc768(%rip), %rsi      # 0x119fa
movl %eax, %edi
movq %r13, %rdx
movl $0x8d, %ecx
callq 0x4094
leaq 0xc7b7(%rip), %rdx      # 0x11a5f
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa8c1
leaq 0xc774(%rip), %rsi      # 0x11a37
movl %eax, %edi
movq %r13, %rdx
movl $0x8e, %ecx
callq 0x4094
leaq 0xc785(%rip), %rbp      # 0x11a5e
movq %rbx, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa8c1
leaq 0xc76e(%rip), %rsi      # 0x11a65
movl %eax, %edi
movq %r13, %rdx
movl $0x8f, %ecx
callq 0x4094
leaq 0xbdad(%rip), %rdx      # 0x110ba
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xc768(%rip), %rsi      # 0x11a90
movl %eax, %edi
movq %r13, %rdx
movl $0x90, %ecx
callq 0x4094
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/regex.c
// Function: suite_regex
void suite_regex(void) {
  pt_add_test(test_regex_basic, "Test Regex Basic", "Suite Regex");
  pt_add_test(test_regex_range, "Test Regex Range", "Suite Regex");
  pt_add_test(test_regex_string, "Test Regex String", "Suite Regex");
  pt_add_test(test_regex_lisp_comment, "Test Regex Lisp Comment", "Suite Regex");
  pt_add_test(test_regex_boundary, "Test Regex Boundary", "Suite Regex");
  pt_add_test(test_regex_newline, "Test Regex Newline", "Suite Regex");
  pt_add_test(test_regex_multiline, "Test Regex Multiline", "Suite Regex");
  pt_add_test(test_regex_dotall, "Test Regex Dotall", "Suite Regex");
}

// Assembly:
pushq %rbx
leaq -0xd0a(%rip), %rdi      # 0x48ba
leaq 0xc6fd(%rip), %rsi      # 0x11cc8
leaq 0xc707(%rip), %rbx      # 0x11cd9
movq %rbx, %rdx
callq 0x410b
leaq -0x717(%rip), %rdi      # 0x4eca
leaq 0xc6fd(%rip), %rsi      # 0x11ce5
movq %rbx, %rdx
callq 0x410b
leaq -0x6be(%rip), %rdi      # 0x4f39
leaq 0xc6f8(%rip), %rsi      # 0x11cf6
movq %rbx, %rdx
callq 0x410b
leaq -0x5cb(%rip), %rdi      # 0x5042
leaq 0xc6f4(%rip), %rsi      # 0x11d08
movq %rbx, %rdx
callq 0x410b
leaq -0xac7(%rip), %rdi      # 0x4b5c
leaq 0xc6f6(%rip), %rsi      # 0x11d20
movq %rbx, %rdx
callq 0x410b
leaq -0x54c(%rip), %rdi      # 0x50ed
leaq 0xc6f4(%rip), %rsi      # 0x11d34
movq %rbx, %rdx
callq 0x410b
leaq -0x47c(%rip), %rdi      # 0x51d3
leaq 0xc6f1(%rip), %rsi      # 0x11d47
movq %rbx, %rdx
callq 0x410b
leaq -0x318(%rip), %rdi      # 0x534d
leaq 0xc6f0(%rip), %rsi      # 0x11d5c
movq %rbx, %rdx
popq %rbx
jmp 0x410b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/test.c
// Function: main
int main(int argc, char** argv) {
  (void) argc; (void) argv;
  pt_add_suite(suite_core);
  pt_add_suite(suite_regex);
  pt_add_suite(suite_grammar);
  pt_add_suite(suite_combinators);
  return pt_run();
}

// Assembly:
pushq %rax
leaq -0x2c47(%rip), %rdi     # 0x2a39
callq 0x426c
leaq -0xd0(%rip), %rdi       # 0x55bc
callq 0x426c
leaq -0x16d6(%rip), %rdi     # 0x3fc2
callq 0x426c
leaq -0x3d6b(%rip), %rdi     # 0x1939
callq 0x426c
popq %rax
jmp 0x4274
nop
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: giveup(char*)
static void giveup(char* msg) {
  fprintf(stderr, "fifi: ");
  fprintf(stderr, "%s", msg);
  putc('\n', stderr);
  exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x281d(%rip), %r14      # 0x3fe0
movq (%r14), %rcx
leaq 0x9d8(%rip), %rdi       # 0x21a5
movl $0x6, %esi
movl $0x1, %edx
callq 0x1160
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x10d0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x1150
movl $0x1, %edi
callq 0x1100
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: readline(_IO_FILE*)
static bool readline(FILE* fi) {
  linenum++;
  int n = 0, ch = getc(fi);
  until(n >= MAXSTR || ch == '\n' || ch < 0) {
    line[n++] = ch;
    ch = getc(fi);
  }
  unless(ch == '\n' || ch < 0) giveup("line too long!");
  line[n] = '\0';
  return !(ch < 0 && n == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x28b4(%rip)            # 0x40e0
callq 0x1060
cmpl $0xa, %eax
sete %cl
testl %eax, %eax
sets %dl
xorl %r14d, %r14d
orb %cl, %dl
je 0x1873
testl %eax, %eax
sets %dl
orb %cl, %dl
je 0x18a8
testl %eax, %eax
setns %cl
movl %r14d, %eax
leaq 0x2895(%rip), %rdx      # 0x40f0
movb $0x0, (%rax,%rdx)
testl %r14d, %r14d
setne %al
orb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
leaq 0x2873(%rip), %r15      # 0x40f0
leaq 0x1(%r12), %r14
movb %al, (%r12,%r15)
movq %rbx, %rdi
callq 0x1060
cmpl $0xa, %eax
sete %cl
je 0x1843
cmpq $0xfe, %r12
ja 0x1843
movq %r14, %r12
testl %eax, %eax
jns 0x187d
jmp 0x1843
leaq 0x800(%rip), %rdi       # 0x20af
callq 0x17b5
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: add_cmdline_t
cmd_t* add_cmdline_t(cmd_t** cmd)
{
    if (((*cmd)->next = (cmd_t*)
                malloc(sizeof(cmd_t))) == NULL)
        return NULL;

    (*cmd)->next->prev = *cmd;
    *cmd = (*cmd)->next;
    (*cmd)->next = NULL;
    (*cmd)->io = NULL;

    return *cmd;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0x20e0
movq (%rbx), %rcx
movq %rax, 0x18(%rcx)
testq %rax, %rax
je 0x3097
movq (%rbx), %rax
movq 0x18(%rax), %rcx
movq %rax, 0x20(%rcx)
movq %rcx, (%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rcx)
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
movq (%rbx), %rax
jmp 0x3099
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: release_cmd_t
void release_cmd_t(cmd_t* cmd)
{
    int     i   = 0;

    cmd_t*  tmp = NULL;

    while (cmd != NULL) {
        tmp = cmd->next;
        if (cmd->io != NULL) {
            if (cmd->io->io_name != NULL)
                free(cmd->io->io_name);
            free(cmd->io);
        }
        i = 0;
        while (cmd->args[i] != NULL) {
            free(cmd->args[i]);
            i++;
        }
        free(cmd->args);
        free(cmd);
        cmd = tmp;
    }

    return;
}

// Assembly:
testq %rdi, %rdi
je 0x3382
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r14
testq %rdi, %rdi
je 0x333d
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3338
movq %rax, %rdi
callq 0x21a0
movq 0x10(%rbx), %rdi
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3365
movl $0x8, %r15d
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax,%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x334f
movq %rax, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rbx
testq %r14, %r14
jne 0x3316
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: file_redirect
int file_redirect(cmd_t* cmd)
{
    int fd  = 0;
    
    switch (cmd->io->io_flag) {
        case    IOREAD:
        case    IOHERE:
            if (check_file_stat(cmd, 1, S_IREAD) < 0)
                return -1;
            if ((fd = open(cmd->io->io_name,
                            O_RDONLY)) < 0) {
                perror("ysh: fopen");
                close(fd);

                return -1;
            }
            close(0);
            dup2(fd, 0);
            break;
        case    IOWRITE:
            if (check_file_stat(cmd, 1, S_IWRITE) < 0)
                return -1;
            if ((fd = open(cmd->io->io_name,
                            O_WRONLY    |
                            O_CREAT     |
                            O_TRUNC, 0666)) < 0) {
                perror("ysh: fopen");
                close(fd);

                return -1;
            }
            close(cmd->io->io_unit);
            dup2(fd, cmd->io->io_unit);
            break;
        case    IOCAT:
            if (check_file_stat(cmd, 1, S_IWRITE) < 0)
                return -1;
            if ((fd = open(cmd->io->io_name,
                            O_WRONLY    |
                            O_CREAT     |
                            O_APPEND, 0666)) < 0) {
                perror("ysh: fopen");
                close(fd);

                return -1;
            }
            close(cmd->io->io_unit);
            dup2(fd, cmd->io->io_unit);
            break;
    }
    close(fd);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movzwl 0x2(%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x33da
cmpl $0x3, %eax
je 0x341a
xorl %ebp, %ebp
movl $0x0, %ebx
cmpl $0x4, %eax
jne 0x346b
movq %r14, %rdi
movl $0x1, %esi
movl $0x80, %edx
callq 0x3493
testl %eax, %eax
js 0x3474
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
xorl %ebx, %ebx
movl $0x441, %esi            # imm = 0x441
jmp 0x343f
movq %r14, %rdi
movl $0x1, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x3493
testl %eax, %eax
js 0x3474
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
xorl %eax, %eax
callq 0x2480
movl %eax, %ebp
testl %eax, %eax
js 0x3480
xorl %edi, %edi
callq 0x2060
movl %ebp, %edi
xorl %esi, %esi
jmp 0x3466
movq %r14, %rdi
movl $0x1, %esi
movl $0x80, %edx
callq 0x3493
testl %eax, %eax
js 0x3474
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
xorl %ebx, %ebx
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x2480
movl %eax, %ebp
testl %eax, %eax
js 0x3480
movq 0x10(%r14), %rax
movswl (%rax), %edi
callq 0x2060
movq 0x10(%r14), %rax
movswl (%rax), %esi
movl %ebp, %edi
callq 0x2040
movl %ebp, %edi
callq 0x2060
jmp 0x3479
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8bab(%rip), %rdi      # 0xc032
callq 0x2440
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x346b
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: check_file_stat
int check_file_stat(cmd_t* cmd, int is_redirect, mode_t chk)
{
    char*   path    = NULL;

    struct stat st;

    if (is_redirect == 1)
        path = cmd->io->io_name;
    else
        path = cmd->args[0];

    if (stat(path, &st) < 0) {
        switch (errno) {
            case    ENOENT:
                if (is_redirect == 1)
                    return 0;

                fprintf(stderr, "no such file or directory: %s\n",
                        path);

                return -1;
            case    EACCES:
                fprintf(stderr, "permission denied: %s\n",
                        path);

                return -2;
        }
    }

    if ((st.st_mode & S_IFMT) == S_IFDIR) {
        fprintf(stderr, "permission denied: %s\n",
                path);

        return -3;
    }
    if ((st.st_mode & chk) == 0) {
        fprintf(stderr, "permission denied: %s\n",
                path);

        return -4;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebp
movl %esi, %r14d
cmpl $0x1, %esi
jne 0x34b2
movq 0x10(%rdi), %rax
addq $0x8, %rax
jmp 0x34b6
movq 0x8(%rdi), %rax
movq (%rax), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2460
testl %eax, %eax
jns 0x34d9
callq 0x2390
movl (%rax), %eax
cmpl $0x2, %eax
je 0x3508
cmpl $0xd, %eax
je 0x352a
movl 0x18(%rsp), %eax
movl %eax, %ecx
andl $0xf000, %ecx           # imm = 0xF000
leaq 0x8b70(%rip), %rsi      # 0xc05c
cmpl $0x4000, %ecx           # imm = 0x4000
je 0x351c
testl %ebp, %eax
je 0x3523
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x1, %r14d
je 0x34f8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x8b23(%rip), %rsi      # 0xc03d
jmp 0x3536
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
jmp 0x3536
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
jmp 0x3536
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
leaq 0x8b26(%rip), %rsi      # 0xc05c
movq 0xdaa3(%rip), %rax      # 0x10fe0
movq (%rax), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2450
jmp 0x34fa
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: redirect
void redirect(int oldfd, int newfd)
{
    if (oldfd != newfd) {
        if (dup2(oldfd, newfd) == -1)
            close(oldfd);
    }

    return;
}

// Assembly:
pushq %rbx
cmpl %esi, %edi
je 0x3937
movl %edi, %ebx
callq 0x2040
cmpl $-0x1, %eax
je 0x3939
popq %rbx
retq
movl %ebx, %edi
popq %rbx
jmp 0x2060
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: mwait
int mwait(void)
{
    int     status  = 0;

    pid_t   pid     = 0;

    while (1) {
        if ((pid = wait(&status)) == -1) {
            if (errno == ECHILD)
                break;
            else if (errno == EINTR)
                continue;
        }
    }

    return status;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
movq %rbx, %rdi
callq 0x2070
cmpl $-0x1, %eax
jne 0x3951
callq 0x2390
cmpl $0xa, (%rax)
jne 0x3951
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: init_shash
int init_shash(SHASH** shash)
{
    int     status  = 0;

    SHASH*  shs     = NULL;

    if ((shs = (SHASH*)
                malloc(sizeof(SHASH))) == NULL) {
        status = -1; goto ERR;
    } else {
        shs->elemc      = 0;
        shs->put        = put_shash;
        shs->get        = get_shash;
        shs->getv       = getv_shash;
        shs->keys       = keys_shash;
        shs->values     = values_shash;
        shs->is_empty   = is_empty_shash;
        shs->size       = size_shash;
        shs->exists     = key_exists_shash;
        shs->remove     = remove_shash;
        shs->clear      = clear_shash;
        shs->release    = release_shash;
        shs->elem_size  = DEFAULT_ELEM_SIZE;
    }
    if (allocate_elem(&shs) < 0) {
        status = -2; goto ERR;
    }
    *shash = shs;

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            if (shs != NULL) {
                free(shs);
                shs = NULL;
            }
            break;
    }

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x70, %edi
callq 0x20e0
testq %rax, %rax
je 0x4125
movq %rax, %rbx
movl $0x0, (%rax)
leaq 0x10b(%rip), %rax       # 0x4175
movq %rax, 0x10(%rbx)
leaq 0x391(%rip), %rax       # 0x4406
movq %rax, 0x18(%rbx)
leaq 0x3a5(%rip), %rax       # 0x4425
movq %rax, 0x20(%rbx)
leaq 0x3fe(%rip), %rax       # 0x4489
movq %rax, 0x28(%rbx)
leaq 0x45d(%rip), %rax       # 0x44f3
movq %rax, 0x30(%rbx)
leaq 0x4bd(%rip), %rax       # 0x455e
movq %rax, 0x38(%rbx)
leaq 0x4bb(%rip), %rax       # 0x4567
movq %rax, 0x40(%rbx)
leaq 0x4b3(%rip), %rax       # 0x456a
movq %rax, 0x48(%rbx)
leaq 0x526(%rip), %rax       # 0x45e8
movq %rax, 0x50(%rbx)
leaq 0x5c3(%rip), %rax       # 0x4690
movq %rax, 0x58(%rbx)
leaq 0x712(%rip), %rax       # 0x47ea
movq %rax, 0x60(%rbx)
movq $0x20, 0x68(%rbx)
movl $0x100, %edi            # imm = 0x100
callq 0x20e0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x415c
movq %rax, %r15
xorl %r12d, %r12d
movl $0x1, %edi
movl $0x10, %esi
callq 0x23d0
movq %rax, (%r15,%r12,8)
testq %rax, %rax
je 0x412c
incq %r12
cmpq $0x20, %r12
jne 0x40fd
movq %rbx, (%r14)
xorl %eax, %eax
jmp 0x4169
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4169
movq $-0x1, %r14
movq 0x8(%r15,%r14,8), %rdi
testq %rdi, %rdi
je 0x4154
callq 0x21a0
movq $0x0, 0x8(%r15,%r14,8)
incq %r14
cmpq $0x1f, %r14
jb 0x4133
movq %r15, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x21a0
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: getv_shash
static
int getv_shash(SHASH* shash, const char* key, char** ptr)
{
    size_t  len     = 0;

    char*   value   = NULL;

    if ((value = shash->get(shash, key)) == NULL)
        return -1;

    len = strlen(value);
    if ((*ptr = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL)
        return -2;
    memcpy(*ptr, value, len);
    *(*(ptr) + len) = '\0';

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
callq *0x18(%rdi)
testq %rax, %rax
je 0x4471
movq %rax, %rbx
movq %rax, %rdi
callq 0x21b0
movq %rax, %r15
leaq 0x1(%rax), %rdi
callq 0x20e0
movq %rax, (%r14)
testq %rax, %rax
je 0x4478
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2470
movb $0x0, (%r12,%r15)
xorl %eax, %eax
jmp 0x447d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x447d
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: keys_shash
static
char** keys_shash(SHASH* shash)
{
    int     i       = 0;

    char**  keys    = NULL;

    if ((keys = (char**)
                malloc(sizeof(char*) * shash->size(shash))) != NULL) {
        while (i < shash->size(shash) &&
                (*(keys + i) = *(*(shash->elem + i))))
            i++;
        *(keys + i) = NULL;
    }

    return keys;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq *0x40(%rdi)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, %rbx
testq %rax, %rax
je 0x44ea
movq %r14, %rdi
callq *0x40(%r14)
testl %eax, %eax
jle 0x44e0
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movq (%rax), %rax
movq %rax, (%rbx,%r15,8)
testq %rax, %rax
je 0x44db
incq %r15
movq %r14, %rdi
callq *0x40(%r14)
cltq
cmpq %rax, %r15
jl 0x44b6
movl %r15d, %eax
jmp 0x44e2
xorl %eax, %eax
movq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: values_shash
static
char** values_shash(SHASH* shash)
{
    int     i       = 0;

    char**  values  = NULL;

    if ((values = (char**)
                malloc(sizeof(char*) * shash->size(shash))) != NULL) {
        while (i < shash->size(shash) &&
                (*(values + i) = *(*(shash->elem + i) + 1)))
            i++;
        *(values + i) = NULL;
    }

    return values;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq *0x40(%rdi)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, %rbx
testq %rax, %rax
je 0x4555
movq %r14, %rdi
callq *0x40(%r14)
testl %eax, %eax
jle 0x454b
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx,%r15,8)
testq %rax, %rax
je 0x4546
incq %r15
movq %r14, %rdi
callq *0x40(%r14)
cltq
cmpq %rax, %r15
jl 0x4520
movl %r15d, %eax
jmp 0x454d
xorl %eax, %eax
movq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: key_exists_shash
static
int key_exists_shash(SHASH* shash, const char* key)
{
    int     i       = 0,
            j       = 0;

    j = shash->elemc - 1;
    while (i < shash->elemc && i <= j) {
        if (strcmp_lite(*(*(shash->elem + i)), key) == 0)
            return i;
        if (strcmp_lite(*(*(shash->elem + j)), key) == 0)
            return j;
        i++;
        j--;
    }

    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rdi), %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
jle 0x45d7
movq %rsi, %r14
movq 0x8(%rdi), %r13
leaq -0x1(%r15), %rbp
xorl %r12d, %r12d
movq (%r13,%r12,8), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x4a7f
testl %eax, %eax
je 0x45d4
movq (%r13,%rbp,8), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x4a7f
testl %eax, %eax
je 0x45ce
incq %r12
cmpq %r15, %r12
jae 0x45d7
leaq -0x1(%rbp), %rax
cmpq %rbp, %r12
movq %rax, %rbp
jl 0x4590
jmp 0x45d7
notl %r12d
addl %r15d, %r12d
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: remove_shash
static
void remove_shash(SHASH** shash, const char* key)
{
    int     pos     = 0;

    if ((pos = (*shash)->exists(*shash, key)) < 0)
        return;

    remove_key_elem(*shash, pos);
    remove_value_elem(*shash, pos);
    while (pos < (*shash)->elemc &&
            (*((*shash)->elem + pos) = *((*shash)->elem + (pos + 1))))
        pos++;
    (*shash)->elemc--;
    *((*shash)->elem + (*shash)->elemc) = NULL;

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x48(%rdi)
testl %eax, %eax
js 0x468a
movq (%rbx), %r15
movq 0x8(%r15), %rcx
movl %eax, %r14d
movq (%rcx,%r14,8), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4633
callq 0x21a0
movq 0x8(%r15), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq (%rbx), %r15
movq 0x8(%r15), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x4651
callq 0x21a0
movq 0x8(%r15), %rax
movq (%rax,%r14,8), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
movl (%rax), %ecx
cmpl %r14d, %ecx
jle 0x4675
movq 0x8(%rax), %rax
movq 0x8(%rax,%r14,8), %rcx
movq %rcx, (%rax,%r14,8)
incq %r14
testq %rcx, %rcx
jne 0x4651
movq (%rbx), %rax
movl (%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, (%rax)
movq 0x8(%rax), %rax
movslq %ecx, %rcx
movq $0x0, -0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: clear_shash
static
void clear_shash(SHASH** shash)
{
    int     i       = 0,
            j       = 0;

    j = (*shash)->elemc - 1;
    while (i < (*shash)->elemc && i <= j) {
        if (*((*shash)->elem + i) != NULL) {
            remove_key_elem(*shash, i);
            remove_value_elem(*shash, i);
            free(*((*shash)->elem + i));
            *((*shash)->elem + i) = NULL;
        }
        if (*((*shash)->elem + j) != NULL) {
            remove_key_elem(*shash, j);
            remove_value_elem(*shash, j);
            free(*((*shash)->elem + j));
            *((*shash)->elem + j) = NULL;
        }
        i++;
        j--;
    }
    (*shash)->elemc = 0;

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movslq (%r12), %r14
testq %r14, %r14
jle 0x47d6
movq %rdi, %rbx
decq %r14
movl $0x1, %r15d
movq 0x8(%r12), %rax
movq -0x8(%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x473d
movq (%rdi), %rax
testq %rax, %rax
je 0x46f1
movq %rax, %rdi
callq 0x21a0
movq 0x8(%r12), %rax
movq -0x8(%rax,%r15,8), %rax
movq $0x0, (%rax)
movq (%rbx), %r12
movq 0x8(%r12), %rax
movq -0x8(%rax,%r15,8), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4720
movq %rax, %rdi
callq 0x21a0
movq 0x8(%r12), %rax
movq -0x8(%rax,%r15,8), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq -0x8(%rax,%r15,8), %rdi
callq 0x21a0
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, -0x8(%rax,%r15,8)
movq (%rbx), %r12
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x47b6
movq (%rdi), %rax
testq %rax, %rax
je 0x4772
movq %rax, %rdi
callq 0x21a0
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq (%rbx), %r12
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x479f
movq %rax, %rdi
callq 0x21a0
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
callq 0x21a0
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax,%r14,8)
movq (%rbx), %r12
movslq (%r12), %rax
cmpq %rax, %r15
jge 0x47d6
leaq 0x1(%r15), %rax
leaq -0x1(%r14), %rcx
cmpq %r14, %r15
movq %rcx, %r14
movq %rax, %r15
jl 0x46b4
movl $0x0, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: release_shash
static
void release_shash(SHASH* shash)
{
    int     i       = 0,
            j       = 0;

    if (shash != NULL) {
        if (shash->elem != NULL) {
            j = shash->elemc - 1;
            while (i < shash->elemc && i <= j) {
                if (*(shash->elem + i) != NULL) {
                    remove_key_elem(shash, i);
                    *(*(shash->elem + i)) = NULL;
                    remove_value_elem(shash, i);
                    *(*(shash->elem + i) + 1) = NULL;
                    free(*(shash->elem + i));
                    *(shash->elem + i) = NULL;
                }
                if (*(shash->elem + j) != NULL) {
                    remove_key_elem(shash, j);
                    *(*(shash->elem + j)) = NULL;
                    remove_value_elem(shash, j);
                    *(*(shash->elem + j) + 1) = NULL;
                    free(*(shash->elem + j));
                    *(shash->elem + j) = NULL;
                }
                i++;
                j--;
            }
            free(shash->elem);
            shash->elem = NULL;
        }
        free(shash);
        shash = NULL;
    }

    return;
}

// Assembly:
testq %rdi, %rdi
je 0x4965
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4952
movslq (%rbx), %r14
testq %r14, %r14
jle 0x494d
decq %r14
movl $0x1, %r12d
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
movq -0x8(%rcx,%r12,8), %rax
testq %rax, %rax
je 0x48ae
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4857
callq 0x21a0
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x488f
callq 0x21a0
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rdi
callq 0x21a0
movq 0x8(%rbx), %rax
movq %r15, -0x8(%rax,%r12,8)
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rax
testq %rax, %rax
je 0x4929
movq (%rax), %rdi
testq %rdi, %rdi
je 0x48db
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x4910
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21a0
movq 0x8(%rbx), %rax
movq %r15, (%rax,%r14,8)
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x4949
leaq 0x1(%r12), %rax
leaq -0x1(%r14), %rcx
cmpq %r14, %r12
movq %rcx, %r14
movq %rax, %r12
jl 0x4823
movq 0x8(%rbx), %rdi
callq 0x21a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21a0
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: clone_shash
SHASH* clone_shash(SHASH* shash)
{
    int     i       = 0;

    SHASH*  shs     = NULL;

    if (init_shash(&shs) < 0)
        return NULL;

    while (i < shash->size(shash)) {
        if (shs->put(&shs, *(*(shash->elem + i)), *(*(shash->elem + i) + 1)) < 0)
            goto ERR;
        i++;
    }

    return shs;

ERR:
    shs->release(shs);

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x403c
testl %eax, %eax
js 0x49f8
movq %rbx, %rdi
callq *0x40(%rbx)
testl %eax, %eax
jle 0x49e9
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq 0x8(%rsp), %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %r14, %rdi
callq *0x10(%rax)
testl %eax, %eax
js 0x49f0
incq %r15
movq %rbx, %rdi
callq *0x40(%rbx)
cltq
cmpq %rax, %r15
jl 0x49bb
movq 0x8(%rsp), %rax
jmp 0x49fa
movq 0x8(%rsp), %rdi
callq *0x60(%rdi)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: put_value_elem
static
int put_value_elem(SHASH** shash, const char* value, int pos)
{
    size_t  len     = 0;

    len = strlen(value);
    if ((*(*(((*shash)->elem + pos)) + 1) = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL)
        return -1;

    memcpy(*(*((*shash)->elem + pos) + 1), value, len);
    *(*(*((*shash)->elem + pos) + 1) + len) = '\0';

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x21b0
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x20e0
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movslq %ebp, %r12
movq (%rcx,%r12,8), %rcx
movq %rax, 0x8(%rcx)
testq %rax, %rax
je 0x4a71
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2470
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax,%r14)
xorl %eax, %eax
jmp 0x4a76
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq