LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/tests/core.c
// Function: test_repeat
void test_repeat(void) {

  int success;
  mpc_result_t r;
  mpc_parser_t *p = mpc_count(3, mpcf_strfold, mpc_digit(), free);

  success = mpc_parse("test", "046", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "046");
  free(r.output);

  success = mpc_parse("test", "046aa", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "046");
  free(r.output);

  success = mpc_parse("test", "04632", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "046");
  free(r.output);

  success = mpc_parse("test", "04", p, &r);
  PT_ASSERT(!success);
  mpc_err_delete(r.error);

  mpc_delete(p);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xaf20
movq %rax, %rdx
movl $0x3, %edi
leaq 0x79b4(%rip), %rsi      # 0xad60
movq 0x18c15(%rip), %rcx     # 0x1bfc8
callq 0xa6f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x10c4a(%rip), %rdi     # 0x14011
leaq 0x111bf(%rip), %rsi     # 0x1458d
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x10c64(%rip), %rsi     # 0x14048
leaq 0x10d59(%rip), %rdx     # 0x14144
movl $0x78, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
leaq 0x1118d(%rip), %rsi     # 0x1458d
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1117a(%rip), %rsi     # 0x14591
leaq 0x10d26(%rip), %rdx     # 0x14144
movl $0x79, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rdx
leaq 0x10bd5(%rip), %rdi     # 0x14011
leaq 0x1116d(%rip), %rsi     # 0x145b0
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x10bef(%rip), %rsi     # 0x14048
leaq 0x10ce4(%rip), %rdx     # 0x14144
movl $0x7d, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
leaq 0x11118(%rip), %rsi     # 0x1458d
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11105(%rip), %rsi     # 0x14591
leaq 0x10cb1(%rip), %rdx     # 0x14144
movl $0x7e, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rdx
leaq 0x10b60(%rip), %rdi     # 0x14011
leaq 0x110fe(%rip), %rsi     # 0x145b6
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x10b7a(%rip), %rsi     # 0x14048
leaq 0x10c6f(%rip), %rdx     # 0x14144
movl $0x82, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
leaq 0x110a3(%rip), %rsi     # 0x1458d
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11090(%rip), %rsi     # 0x14591
leaq 0x10c3c(%rip), %rdx     # 0x14144
movl $0x83, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rdx
leaq 0x10aeb(%rip), %rdi     # 0x14011
leaq 0x1108f(%rip), %rsi     # 0x145bc
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x10af9(%rip), %rsi     # 0x14047
leaq 0x10bef(%rip), %rdx     # 0x14144
movl $0x87, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdi
callq 0x9160
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/tests/core.c
// Function: test_reader
void test_reader(void) {

  mpc_parser_t* Line = mpc_many(
    mpcf_strfold,
    mpc_apply(mpc_re("[^\\n]*(\\n|$)"), read_line));

  line_count = 0;

  PT_ASSERT(mpc_test_pass(Line,
    "hello\nworld\n\nthis\nis\ndan",
    "hello\nworld\n\nthis\nis\ndan", streq, free, strprint));

  PT_ASSERT(line_count == 6);

  line_count = 0;

  PT_ASSERT(mpc_test_pass(Line,
    "abcHVwufvyuevuy3y436782\n\n\nrehre\nrew\n-ql.;qa\neg",
    "abcHVwufvyuevuy3y436782\n\n\nrehre\nrew\n-ql.;qa\neg", streq, free, strprint));

  PT_ASSERT(line_count == 7);

  mpc_delete(Line);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10dee(%rip), %rdi     # 0x1463d
callq 0xbc90
movq %rax, %rdi
leaq 0x112(%rip), %rsi       # 0x3970
callq 0xa170
movq %rax, %rsi
leaq 0x74f3(%rip), %rdi      # 0xad60
callq 0xa650
movq %rax, -0x8(%rbp)
movl $0x0, 0x189d4(%rip)     # 0x1c254
movq -0x8(%rbp), %rdi
leaq 0x10dbf(%rip), %rdx     # 0x1464a
leaq -0xb92(%rip), %rcx      # 0x2d00
movq 0x1872f(%rip), %r8      # 0x1bfc8
leaq -0xb70(%rip), %r9       # 0x2d30
movq %rdx, %rsi
callq 0xd780
movl %eax, %edi
leaq 0x10db2(%rip), %rsi     # 0x14663
leaq 0x1088c(%rip), %rdx     # 0x14144
movl $0xc5, %ecx
callq 0x5780
cmpl $0x6, 0x1898b(%rip)     # 0x1c254
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x10df8(%rip), %rsi     # 0x146d0
leaq 0x10865(%rip), %rdx     # 0x14144
movl $0xc7, %ecx
callq 0x5780
movl $0x0, 0x18961(%rip)     # 0x1c254
movq -0x8(%rbp), %rdi
leaq 0x10de2(%rip), %rdx     # 0x146e0
leaq -0xc05(%rip), %rcx      # 0x2d00
movq 0x186bc(%rip), %r8      # 0x1bfc8
leaq -0xbe3(%rip), %r9       # 0x2d30
movq %rdx, %rsi
callq 0xd780
movl %eax, %edi
leaq 0x10deb(%rip), %rsi     # 0x1470f
leaq 0x10819(%rip), %rdx     # 0x14144
movl $0xcd, %ecx
callq 0x5780
cmpl $0x7, 0x18918(%rip)     # 0x1c254
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x10e5f(%rip), %rsi     # 0x147aa
leaq 0x107f2(%rip), %rdx     # 0x14144
movl $0xcf, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/tests/core.c
// Function: test_tokens
void test_tokens(void) {

  mpc_parser_t* Tokens = mpc_many(
    mpcf_strfold,
    mpc_apply(mpc_strip(mpc_re("\\s*([a-zA-Z_]+|[0-9]+|,|\\.|:)")), print_token));

  token_count = 0;

  PT_ASSERT(mpc_test_pass(Tokens,
    "  hello 4352 ,  \n foo.bar   \n\n  test:ing   ",
    "hello4352,foo.bartest:ing", streq, free, strprint));

  PT_ASSERT(token_count == 9);

  mpc_delete(Tokens);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10e1b(%rip), %rdi     # 0x147ba
callq 0xbc90
movq %rax, %rdi
callq 0xb8f0
movq %rax, %rdi
leaq 0xaa(%rip), %rsi        # 0x3a60
callq 0xa170
movq %rax, %rsi
leaq 0x739b(%rip), %rdi      # 0xad60
callq 0xa650
movq %rax, -0x8(%rbp)
movl $0x0, 0x18880(%rip)     # 0x1c258
movq -0x8(%rbp), %rdi
leaq 0x10df5(%rip), %rsi     # 0x147d8
leaq 0x10e1a(%rip), %rdx     # 0x14804
leaq -0xcf1(%rip), %rcx      # 0x2d00
movq 0x185d0(%rip), %r8      # 0x1bfc8
leaq -0xccf(%rip), %r9       # 0x2d30
callq 0xd780
movl %eax, %edi
leaq 0x10e11(%rip), %rsi     # 0x1481e
leaq 0x10730(%rip), %rdx     # 0x14144
movl $0xe7, %ecx
callq 0x5780
cmpl $0x9, 0x18833(%rip)     # 0x1c258
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x10e66(%rip), %rsi     # 0x1489a
leaq 0x10709(%rip), %rdx     # 0x14144
movl $0xe9, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/tests/core.c
// Function: test_eoi
void test_eoi(void) {

  mpc_parser_t* Line = mpc_re("[^\\n]*$");

  PT_ASSERT(mpc_test_pass(Line, "blah", "blah", streq, free, strprint));
  PT_ASSERT(mpc_test_pass(Line, "blah\n", "blah\n", streq, free, strprint));

  mpc_delete(Line);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10e1c(%rip), %rdi     # 0x148ab
callq 0xbc90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12042(%rip), %rdx     # 0x15ae5
leaq -0xdaa(%rip), %rcx      # 0x2d00
movq 0x18517(%rip), %r8      # 0x1bfc8
leaq -0xd88(%rip), %r9       # 0x2d30
movq %rdx, %rsi
callq 0xd780
movl %eax, %edi
leaq 0x10dea(%rip), %rsi     # 0x148b3
leaq 0x10674(%rip), %rdx     # 0x14144
movl $0xf3, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0x12ecb(%rip), %rdx     # 0x169b0
leaq -0xdec(%rip), %rcx      # 0x2d00
movq 0x184d5(%rip), %r8      # 0x1bfc8
leaq -0xdca(%rip), %r9       # 0x2d30
movq %rdx, %rsi
callq 0xd780
movl %eax, %edi
leaq 0x10de3(%rip), %rsi     # 0x148ee
leaq 0x10632(%rip), %rdx     # 0x14144
movl $0xf4, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/tests/core.c
// Function: suite_core
void suite_core(void) {
  pt_add_test(test_ident,  "Test Ident",  "Suite Core");
  pt_add_test(test_maths,  "Test Maths",  "Suite Core");
  pt_add_test(test_strip,  "Test Strip",  "Suite Core");
  pt_add_test(test_repeat, "Test Repeat", "Suite Core");
  pt_add_test(test_copy,   "Test Copy",   "Suite Core");
  pt_add_test(test_reader, "Test Reader", "Suite Core");
  pt_add_test(test_tokens, "Test Tokens", "Suite Core");
  pt_add_test(test_eoi,    "Test EOI",    "Suite Core");
  pt_add_test(test_sepby,  "Test SepBy",  "Suite Core");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x13eb(%rip), %rdi     # 0x2a70
leaq 0x10cf9(%rip), %rsi     # 0x14b5b
leaq 0x10cfd(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0x1115(%rip), %rdi     # 0x2d60
leaq 0x10cf5(%rip), %rsi     # 0x14b71
leaq 0x10ce3(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0xc6f(%rip), %rdi      # 0x3220
leaq 0x10ce6(%rip), %rsi     # 0x14b7c
leaq 0x10cc9(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0xb19(%rip), %rdi      # 0x3390
leaq 0x10cd7(%rip), %rsi     # 0x14b87
leaq 0x10caf(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0x943(%rip), %rdi      # 0x3580
leaq 0x10cc9(%rip), %rsi     # 0x14b93
leaq 0x10c95(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0x69d(%rip), %rdi      # 0x3840
leaq 0x10cb9(%rip), %rsi     # 0x14b9d
leaq 0x10c7b(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0x567(%rip), %rdi      # 0x3990
leaq 0x10cab(%rip), %rsi     # 0x14ba9
leaq 0x10c61(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0x491(%rip), %rdi      # 0x3a80
leaq 0x10c9d(%rip), %rsi     # 0x14bb5
leaq 0x10c47(%rip), %rdx     # 0x14b66
callq 0x5850
leaq -0x3fb(%rip), %rdi      # 0x3b30
leaq 0x10c8c(%rip), %rsi     # 0x14bbe
leaq 0x10c2d(%rip), %rdx     # 0x14b66
callq 0x5850
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x107cf(%rip), %rdi     # 0x14bce
callq 0x9350
movq %rax, -0x8(%rbp)
leaq 0x107ca(%rip), %rdi     # 0x14bd9
callq 0x9350
movq %rax, -0x10(%rbp)
leaq 0x107c2(%rip), %rdi     # 0x14be1
callq 0x9350
movq %rax, -0x18(%rbp)
leaq 0xfecb(%rip), %rdi      # 0x142fa
callq 0x9350
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
xorl %edi, %edi
leaq 0x10b56(%rip), %rsi     # 0x14fa7
movb $0x0, %al
callq 0xff70
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x4, %edi
movb $0x0, %al
callq 0x9a50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1073f(%rip), %rdi     # 0x14bce
callq 0x9350
movq %rax, -0x8(%rbp)
leaq 0x1073a(%rip), %rdi     # 0x14bd9
callq 0x9350
movq %rax, -0x10(%rbp)
leaq 0x10732(%rip), %rdi     # 0x14be1
callq 0x9350
movq %rax, -0x18(%rbp)
leaq 0xfe3b(%rip), %rdi      # 0x142fa
callq 0x9350
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
xorl %edi, %edi
leaq 0x10b8f(%rip), %rsi     # 0x15070
movb $0x0, %al
callq 0x10060
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x4, %edi
movb $0x0, %al
callq 0x9a50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10398(%rip), %rdi     # 0x15327
callq 0x9350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
xorl %edi, %edi
leaq 0x10a2e(%rip), %rsi     # 0x159d3
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0xff70
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x10404(%rip), %rsi     # 0x153cc
leaq 0xfd6b(%rip), %rdx      # 0x14d3a
movl $0x110, %ecx            # imm = 0x110
callq 0x5780
movq -0x20(%rbp), %rdx
leaq 0x10a17(%rip), %rdi     # 0x159fb
leaq 0xf026(%rip), %rsi      # 0x14011
leaq -0x18(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x109f9(%rip), %rsi     # 0x15a03
leaq 0xfd29(%rip), %rdx      # 0x14d3a
movl $0x114, %ecx            # imm = 0x114
callq 0x5780
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x109e0(%rip), %rsi     # 0x15a0f
leaq 0xfd04(%rip), %rdx      # 0x14d3a
movl $0x115, %ecx            # imm = 0x115
callq 0x5780
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
leaq 0x109d0(%rip), %rsi     # 0x15a1f
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x109d3(%rip), %rsi     # 0x15a39
leaq 0xfccd(%rip), %rdx      # 0x14d3a
movl $0x116, %ecx            # imm = 0x116
callq 0x5780
movq -0x18(%rbp), %rdi
callq 0x6ed0
movq -0x20(%rbp), %rsi
movl $0x1, %edi
movb $0x0, %al
callq 0x9a50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq -0x175b(%rip), %rdi     # 0x3f40
leaq 0x107a9(%rip), %rsi     # 0x15e4b
leaq 0x107af(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0x12c5(%rip), %rdi     # 0x43f0
leaq 0x107aa(%rip), %rsi     # 0x15e66
leaq 0x10795(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0x124f(%rip), %rdi     # 0x4480
leaq 0x1079e(%rip), %rsi     # 0x15e74
leaq 0x1077b(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0x11d9(%rip), %rdi     # 0x4510
leaq 0x10797(%rip), %rsi     # 0x15e87
leaq 0x10761(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0xfe3(%rip), %rdi      # 0x4720
leaq 0x10787(%rip), %rsi     # 0x15e91
leaq 0x10747(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0xddd(%rip), %rdi      # 0x4940
leaq 0x1077a(%rip), %rsi     # 0x15e9e
leaq 0x1072d(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0x7b7(%rip), %rdi      # 0x4f80
leaq 0x1076d(%rip), %rsi     # 0x15eab
leaq 0x10713(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0x6b1(%rip), %rdi      # 0x50a0
leaq 0x10765(%rip), %rsi     # 0x15ebd
leaq 0x106f9(%rip), %rdx     # 0x15e58
callq 0x5850
leaq -0x41b(%rip), %rdi      # 0x5350
leaq 0x1075b(%rip), %rsi     # 0x15ecd
leaq 0x106df(%rip), %rdx     # 0x15e58
callq 0x5850
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl 0x16ac4(%rip), %eax     # 0x1c260
addl $0x1, %eax
movl %eax, 0x16abb(%rip)     # 0x1c260
xorl %eax, %eax
cmpl $0x0, 0x16ab6(%rip)     # 0x1c264
movb %al, -0x1d(%rbp)
je 0x57bd
cmpl $0x0, -0x4(%rbp)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x16a99(%rip)     # 0x1c264
cmpl $0x0, -0x4(%rbp)
je 0x57e2
movl 0x16a91(%rip), %eax     # 0x1c268
addl $0x1, %eax
movl %eax, 0x16a88(%rip)     # 0x1c268
jmp 0x583d
movl 0x17288(%rip), %edx     # 0x1ca70
addl $0x1, %edx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl -0x1c(%rbp), %r9d
leaq 0x16a72(%rip), %rdi     # 0x1c270
leaq 0x106e3(%rip), %rsi     # 0x15ee8
movb $0x0, %al
callq 0x2200
leaq 0x1726d(%rip), %rdi     # 0x1ca80
leaq 0x16a56(%rip), %rsi     # 0x1c270
callq 0x21f0
movl 0x1724b(%rip), %eax     # 0x1ca70
addl $0x1, %eax
movl %eax, 0x17242(%rip)     # 0x1ca70
movl 0x17a4c(%rip), %eax     # 0x1d280
addl $0x1, %eax
movl %eax, 0x17a43(%rip)     # 0x1d280
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x800, 0x17a13(%rip)   # imm = 0x800
jne 0x588b
leaq 0x10691(%rip), %rdi     # 0x15f0b
movl $0x800, %esi            # imm = 0x800
movb $0x0, %al
callq 0x20d0
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x20b0
cmpq $0x200, %rax            # imm = 0x200
jb 0x58b8
movq -0x10(%rbp), %rsi
leaq 0x1068f(%rip), %rdi     # 0x15f36
movl $0x200, %edx            # imm = 0x200
movb $0x0, %al
callq 0x20d0
callq 0x2040
movq -0x18(%rbp), %rdi
callq 0x20b0
cmpq $0x200, %rax            # imm = 0x200
jb 0x58e5
movq -0x18(%rbp), %rsi
leaq 0x1069d(%rip), %rdi     # 0x15f71
movl $0x200, %edx            # imm = 0x200
movb $0x0, %al
callq 0x20d0
callq 0x2040
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x420(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x5960
leaq -0x420(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movq -0x18(%rbp), %rsi
callq 0x5960
movslq 0x17962(%rip), %rax     # 0x1d284
leaq 0x17967(%rip), %rdi     # 0x1d290
imulq $0x408, %rax, %rax      # imm = 0x408
addq %rax, %rdi
leaq -0x420(%rbp), %rsi
movl $0x408, %edx            # imm = 0x408
callq 0x2160
movl 0x1793a(%rip), %eax     # 0x1d284
addl $0x1, %eax
movl %eax, 0x17931(%rip)     # 0x1d284
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2060
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x5a3d
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0x59cb
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x59df
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movb $0x20, (%rax,%rcx)
jmp 0x5a2f
cmpl $0x0, -0x14(%rbp)
je 0x5a28
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x5a28
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jg 0x5a28
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
subl $0x20, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movb %dl, (%rax,%rcx)
jmp 0x5a2f
movl $0x0, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x598b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, 0x1624f(%rip)     # 0x1c264
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x4, %eax
je 0x6056
jmp 0x6022
movl -0x8(%rbp), %eax
subl $0x8, %eax
je 0x6036
jmp 0x602c
movl -0x8(%rbp), %eax
subl $0xb, %eax
je 0x6076
jmp 0x6096
movl 0x16a34(%rip), %edx     # 0x1ca70
addl $0x1, %edx
leaq 0x1622a(%rip), %rdi     # 0x1c270
leaq 0x101b1(%rip), %rsi     # 0x161fe
movb $0x0, %al
callq 0x2200
jmp 0x6098
movl 0x16a14(%rip), %edx     # 0x1ca70
addl $0x1, %edx
leaq 0x1620a(%rip), %rdi     # 0x1c270
leaq 0x101af(%rip), %rsi     # 0x1621c
movb $0x0, %al
callq 0x2200
jmp 0x6098
movl 0x169f4(%rip), %edx     # 0x1ca70
addl $0x1, %edx
leaq 0x161ea(%rip), %rdi     # 0x1c270
leaq 0x101b0(%rip), %rsi     # 0x1623d
movb $0x0, %al
callq 0x2200
jmp 0x6098
jmp 0x6098
movl 0x169d2(%rip), %eax     # 0x1ca70
addl $0x1, %eax
movl %eax, 0x169c9(%rip)     # 0x1ca70
leaq 0x169d2(%rip), %rdi     # 0x1ca80
leaq 0x161bb(%rip), %rsi     # 0x1c270
callq 0x21f0
movl $0x4, %edi
callq 0x6110
leaq 0x10007(%rip), %rdi     # 0x160d2
leaq 0x169ae(%rip), %rsi     # 0x1ca80
movb $0x0, %al
callq 0x20d0
movl $0x10, %edi
callq 0x6110
leaq 0x10173(%rip), %rdi     # 0x1625d
callq 0x2070
movq 0x15eea(%rip), %rax     # 0x1bfe0
movq (%rax), %rdi
callq 0x2180
xorl %edi, %edi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xff45(%rip), %rdi      # 0x166d4
callq 0xbc90
movq %rax, -0x8(%rbp)
leaq 0xff41(%rip), %rdi      # 0x166e0
callq 0xbc90
movq %rax, -0x10(%rbp)
leaq 0xff39(%rip), %rdi      # 0x166e8
callq 0xbc90
movq %rax, -0x18(%rbp)
leaq 0xff3e(%rip), %rdi      # 0x166fd
callq 0xbc90
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9160
movq -0x10(%rbp), %rdi
callq 0x9160
movq -0x18(%rbp), %rdi
callq 0x9160
movq -0x20(%rbp), %rdi
callq 0x9160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfefa(%rip), %rdi      # 0x16709
callq 0xbc90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfef4(%rip), %rdx      # 0x16717
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xfeeb(%rip), %rsi      # 0x1671f
leaq 0xfada(%rip), %rdx      # 0x16315
movl $0x67, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xfefe(%rip), %rdx      # 0x1674e
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xfef5(%rip), %rsi      # 0x16756
leaq 0xfaad(%rip), %rdx      # 0x16315
movl $0x68, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xff08(%rip), %rdx      # 0x16785
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xff02(%rip), %rsi      # 0x16790
leaq 0xfa80(%rip), %rdx      # 0x16315
movl $0x69, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xff1b(%rip), %rdx      # 0x167c5
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xff17(%rip), %rsi      # 0x167d2
leaq 0xfa53(%rip), %rdx      # 0x16315
movl $0x6a, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xff20(%rip), %rdi      # 0x1680f
callq 0xbc90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xff16(%rip), %rdx      # 0x16819
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xff0e(%rip), %rsi      # 0x16822
leaq 0xf9fa(%rip), %rdx      # 0x16315
movl $0x74, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xff1f(%rip), %rsi      # 0x1684f
leaq 0xff26(%rip), %rdx      # 0x1685d
callq 0x6140
movl %eax, %edi
leaq 0xff22(%rip), %rsi      # 0x16867
leaq 0xf9c9(%rip), %rdx      # 0x16315
movl $0x75, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xff1c(%rip), %rdi      # 0x1689b
callq 0xbc90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xff0f(%rip), %rdx      # 0x168a2
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xff01(%rip), %rsi      # 0x168a5
leaq 0xf96a(%rip), %rdx      # 0x16315
movl $0x7f, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xff06(%rip), %rsi      # 0x168c6
leaq 0xfedb(%rip), %rdx      # 0x168a2
callq 0x6140
movl %eax, %edi
leaq 0xfef6(%rip), %rsi      # 0x168cb
leaq 0xf939(%rip), %rdx      # 0x16315
movl $0x80, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xfed5(%rip), %rdx      # 0x168c6
movq %rdx, %rsi
callq 0x61e0
movl %eax, %edi
leaq 0xfeed(%rip), %rsi      # 0x168ef
leaq 0xf90c(%rip), %rdx      # 0x16315
movl $0x81, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfed7(%rip), %rdi      # 0x16916
movl $0x1, %esi
callq 0xbcb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfeca(%rip), %rdx      # 0x16922
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xfec5(%rip), %rsi      # 0x1692e
leaq 0xf8a5(%rip), %rdx      # 0x16315
movl $0x8b, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xfede(%rip), %rdx      # 0x16963
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xfeda(%rip), %rsi      # 0x16970
leaq 0xf878(%rip), %rdx      # 0x16315
movl $0x8c, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xfef7(%rip), %rdx      # 0x169a9
movq %rdx, %rsi
callq 0x6140
movl %eax, %edi
leaq 0xfef3(%rip), %rsi      # 0x169b6
leaq 0xf84b(%rip), %rdx      # 0x16315
movl $0x8d, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xff3c(%rip), %rdx      # 0x16a1b
movq %rdx, %rsi
callq 0x61e0
movl %eax, %edi
leaq 0xff03(%rip), %rsi      # 0x169f3
leaq 0xf81e(%rip), %rdx      # 0x16315
movl $0x8e, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xff0e(%rip), %rdx      # 0x16a1a
movq %rdx, %rsi
callq 0x61e0
movl %eax, %edi
leaq 0xff04(%rip), %rsi      # 0x16a21
leaq 0xf7f1(%rip), %rdx      # 0x16315
movl $0x8f, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
leaq 0xfee1(%rip), %rsi      # 0x16a1a
leaq 0xf57a(%rip), %rdx      # 0x160ba
callq 0x6140
movl %eax, %edi
leaq 0xfefe(%rip), %rsi      # 0x16a4c
leaq 0xf7c0(%rip), %rdx      # 0x16315
movl $0x90, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq -0xb7b(%rip), %rdi      # 0x6220
leaq 0xfee2(%rip), %rsi      # 0x16c84
leaq 0xfeec(%rip), %rdx      # 0x16c95
callq 0x5850
leaq -0x635(%rip), %rdi      # 0x6780
leaq 0xfee5(%rip), %rsi      # 0x16ca1
leaq 0xfed2(%rip), %rdx      # 0x16c95
callq 0x5850
leaq -0x5cf(%rip), %rdi      # 0x6800
leaq 0xfedc(%rip), %rsi      # 0x16cb2
leaq 0xfeb8(%rip), %rdx      # 0x16c95
callq 0x5850
leaq -0x509(%rip), %rdi      # 0x68e0
leaq 0xfed4(%rip), %rsi      # 0x16cc4
leaq 0xfe9e(%rip), %rdx      # 0x16c95
callq 0x5850
leaq -0x9a3(%rip), %rdi      # 0x6460
leaq 0xfed2(%rip), %rsi      # 0x16cdc
leaq 0xfe84(%rip), %rdx      # 0x16c95
callq 0x5850
leaq -0x4ad(%rip), %rdi      # 0x6970
leaq 0xfecc(%rip), %rsi      # 0x16cf0
leaq 0xfe6a(%rip), %rdx      # 0x16c95
callq 0x5850
leaq -0x407(%rip), %rdi      # 0x6a30
leaq 0xfec5(%rip), %rsi      # 0x16d03
leaq 0xfe50(%rip), %rdx      # 0x16c95
callq 0x5850
leaq -0x2e1(%rip), %rdi      # 0x6b70
leaq 0xfec0(%rip), %rsi      # 0x16d18
leaq 0xfe36(%rip), %rdx      # 0x16c95
callq 0x5850
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x303d(%rip), %rdi     # 0x3e50
callq 0x5a50
leaq -0x109(%rip), %rdi      # 0x6d90
callq 0x5a50
leaq -0x1815(%rip), %rdi     # 0x5690
callq 0x5a50
leaq -0x44b1(%rip), %rdi     # 0x2a00
callq 0x5a50
callq 0x5a80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: main
global int main(int argc, char** argv) {
  // set_new_handler(newhandler);
  unless(argc == 3) {
    usage();
    return 2;
  }
  tempfile = tmpfile();
  if (tempfile == NULL)
    giveup("can't create temp file");
  sourcefn = argv[1];
  infile = openfile(sourcefn, "r");
  outfile = openfile(argv[2], "w");
  pass1();
  rewind(tempfile);
  pass2();
  fclose(tempfile);
  fclose(infile);
  fclose(outfile);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x3, 0x10(%rsp)
je 0x129e
callq 0x1360
movl $0x2, 0x14(%rsp)
jmp 0x1348
callq 0x1130
movq %rax, 0x2e36(%rip)      # 0x40e0
cmpq $0x0, 0x2e2e(%rip)      # 0x40e0
jne 0x12c0
leaq 0xd49(%rip), %rdi       # 0x2004
callq 0x1380
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2e18(%rip)      # 0x40e8
movq 0x2e11(%rip), %rdi      # 0x40e8
leaq 0xe6e(%rip), %rsi       # 0x214c
callq 0x13e0
movq %rax, 0x2e06(%rip)      # 0x40f0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0xd21(%rip), %rsi       # 0x201b
callq 0x13e0
movq %rax, 0x2df2(%rip)      # 0x40f8
callq 0x1420
movq 0x2dce(%rip), %rdi      # 0x40e0
callq 0x1040
callq 0x15e0
movq 0x2dbd(%rip), %rdi      # 0x40e0
callq 0x10b0
movq 0x2dc1(%rip), %rdi      # 0x40f0
callq 0x10b0
movq 0x2dbd(%rip), %rdi      # 0x40f8
callq 0x10b0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq 0x2c54(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xe13(%rip), %rsi       # 0x21a9
movb $0x0, %al
callq 0x1150
movq 0x2c3c(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0xce5(%rip), %rsi       # 0x2097
movb $0x0, %al
callq 0x1150
movq 0x2c20(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1160
movl $0x1, %edi
callq 0x1110
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: openfile(char*, char*)
static FILE* openfile(char* fn, char* rw) {
  FILE* fi = fopen(fn, rw);
  if (fi == NULL) {
    // const char *ops = (rw[0] == 'r') ? "open" : "create";
    giveup("can't open or create file");
  }
  return fi;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1100
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1414
leaq 0xc2a(%rip), %rdi       # 0x2039
callq 0x1380
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: pass1()
static void pass1() {
  regex_t re;
  // size_t nmatch;
  regmatch_t* pmatch = NULL;
  x_regcomp(&re, "(.*)mkfilter\\(\"([^\"]*)\"\\)(.*)");
  numfspecs = linenum = 0;
  bool ok = readline(infile);

  pmatch = new regmatch_t[4];

  while (ok) {
    if (regexec(&re, line, 4, pmatch, 0) == 0) {
      char* s1 = getsubst(line, pmatch[1].rm_so, pmatch[1].rm_eo);
      char* s2 = getsubst(line, pmatch[2].rm_so, pmatch[2].rm_eo);
      char* s3 = getsubst(line, pmatch[3].rm_so, pmatch[3].rm_eo);

      if (numfspecs >= MAXFSPECS)
        giveup("too many filter specs!");
      fspeclist[numfspecs++] = s2; /* arg of mkfilter(...) */
      sprintf(line, "%s(&_fspecs_%d)%s", s1, numfspecs,
              s3); /* replace "mkfilter(...)" by "(&_fspecs_n)" */
      delete s1;
      delete s3;
    }
    writeline(tempfile);
    ok = readline(infile);
  }
  regfree(&re);
}

// Assembly:
subq $0x78, %rsp
movq $0x0, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0xc1a(%rip), %rsi       # 0x2053
callq 0x1700
movl $0x0, 0x2cb8(%rip)      # 0x4100
movl $0x0, 0x2cb2(%rip)      # 0x4104
movq 0x2c97(%rip), %rdi      # 0x40f0
callq 0x1740
andb $0x1, %al
movb %al, 0x2f(%rsp)
movl $0x20, %edi
callq 0x1030
movq %rax, 0x30(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x15c7
movq 0x30(%rsp), %rcx
leaq 0x38(%rsp), %rdi
leaq 0x2c81(%rip), %rsi      # 0x4110
movl $0x4, %edx
xorl %r8d, %r8d
callq 0x1120
cmpl $0x0, %eax
jne 0x15a4
movq 0x30(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x30(%rsp), %rax
movl 0xc(%rax), %edx
leaq 0x2c54(%rip), %rdi      # 0x4110
callq 0x1830
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x30(%rsp), %rax
movl 0x14(%rax), %edx
leaq 0x2c33(%rip), %rdi      # 0x4110
callq 0x1830
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %esi
movq 0x30(%rsp), %rax
movl 0x1c(%rax), %edx
leaq 0x2c12(%rip), %rdi      # 0x4110
callq 0x1830
movq %rax, 0x10(%rsp)
cmpl $0x64, 0x2bf5(%rip)     # 0x4104
jl 0x151d
leaq 0xb59(%rip), %rdi       # 0x2071
callq 0x1380
movq 0x18(%rsp), %rdx
movl 0x2bdc(%rip), %eax      # 0x4104
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x2bd1(%rip)      # 0x4104
movslq %eax, %rcx
leaq 0x2ce3(%rip), %rax      # 0x4220
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rdx
movl 0x2bb8(%rip), %ecx      # 0x4104
movq 0x10(%rsp), %r8
leaq 0x2bb8(%rip), %rdi      # 0x4110
leaq 0xb29(%rip), %rsi       # 0x2088
movb $0x0, %al
callq 0x1050
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1585
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x10d0
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x15a2
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x10d0
jmp 0x15a4
movq 0x2b35(%rip), %rdi      # 0x40e0
callq 0x18a0
movq 0x2b39(%rip), %rdi      # 0x40f0
callq 0x1740
andb $0x1, %al
movb %al, 0x2f(%rsp)
jmp 0x1473
leaq 0x38(%rsp), %rdi
callq 0x10c0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: pass2()
static void pass2() {
  regex_t re;
  x_regcomp(&re, "^[ \t]*#include [<\"]filters.h[>\"]");
  linenum = 0;
  bool ok = readline(tempfile);
  bool incl = false;
  setlinenum(linenum, sourcefn);
  while (ok && !incl) {
    writeline(outfile);
    if (regexec(&re, line, 0, NULL, 0) == 0) {
      incl = true;
    }
    ok = readline(tempfile);
  }
  unless(incl) giveup("no ``#include'' of file ``filters.h'' in input file");
  setlinenum(1, "<<generated_fspecs>>");
  writefspecs();
  setlinenum(linenum, sourcefn);
  while (ok) {
    writeline(outfile);
    ok = readline(tempfile);
  }
  regfree(&re);
}

// Assembly:
subq $0x48, %rsp
leaq 0x8(%rsp), %rdi
leaq 0xace(%rip), %rsi       # 0x20be
callq 0x1700
movl $0x0, 0x2b01(%rip)      # 0x4100
movq 0x2ada(%rip), %rdi      # 0x40e0
callq 0x1740
andb $0x1, %al
movb %al, 0x7(%rsp)
movb $0x0, 0x6(%rsp)
movl 0x2ae4(%rip), %edi      # 0x4100
movq 0x2ac5(%rip), %rsi      # 0x40e8
callq 0x18d0
xorl %eax, %eax
testb $0x1, 0x7(%rsp)
movb %al, 0x5(%rsp)
je 0x163f
movb 0x6(%rsp), %al
xorb $-0x1, %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
testb $0x1, %al
jne 0x1649
jmp 0x168e
movq 0x2aa8(%rip), %rdi      # 0x40f8
callq 0x18a0
leaq 0x8(%rsp), %rdi
leaq 0x2aaf(%rip), %rsi      # 0x4110
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x1120
cmpl $0x0, %eax
jne 0x167a
movb $0x1, 0x6(%rsp)
movq 0x2a5f(%rip), %rdi      # 0x40e0
callq 0x1740
andb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x1628
testb $0x1, 0x6(%rsp)
jne 0x16a1
leaq 0xa43(%rip), %rdi       # 0x20df
callq 0x1380
movl $0x1, %edi
leaq 0xa66(%rip), %rsi       # 0x2113
callq 0x18d0
callq 0x1900
movl 0x2a43(%rip), %edi      # 0x4100
movq 0x2a24(%rip), %rsi      # 0x40e8
callq 0x18d0
testb $0x1, 0x7(%rsp)
je 0x16f0
movq 0x2a21(%rip), %rdi      # 0x40f8
callq 0x18a0
movq 0x29fd(%rip), %rdi      # 0x40e0
callq 0x1740
andb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x16c9
leaq 0x8(%rsp), %rdi
callq 0x10c0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl 0x29b1(%rip), %eax      # 0x4100
addl $0x1, %eax
movl %eax, 0x29a8(%rip)      # 0x4100
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1060
movl %eax, 0x8(%rsp)
movb $0x1, %al
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
movb %al, 0x7(%rsp)
jge 0x1797
movb $0x1, %al
cmpl $0xa, 0x8(%rsp)
movb %al, 0x7(%rsp)
je 0x1797
cmpl $0x0, 0x8(%rsp)
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x17a3
jmp 0x17d3
movl 0x8(%rsp), %eax
movb %al, %dl
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rsp)
movslq %eax, %rcx
leaq 0x2950(%rip), %rax      # 0x4110
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rdi
callq 0x1060
movl %eax, 0x8(%rsp)
jmp 0x176e
cmpl $0xa, 0x8(%rsp)
je 0x17ed
cmpl $0x0, 0x8(%rsp)
jl 0x17ed
leaq 0x8c7(%rip), %rdi       # 0x20af
callq 0x1380
movslq 0xc(%rsp), %rcx
leaq 0x2917(%rip), %rax      # 0x4110
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
cmpl $0x0, 0x8(%rsp)
movb %al, 0x6(%rsp)
jge 0x1816
cmpl $0x0, 0xc(%rsp)
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: getsubst(char*, int, int)
static char* getsubst(
    char* line,
    int start,
    int end) {  // char *s1 = re -> startp[ns], *s2 = re -> endp[ns];
  // unless (s1 != NULL && s2 != NULL && s2 >= s1) giveup("bad regexp subst!");
  int len = end - start;
  char* s = new char[len + 1];
  memcpy(s, line + start, len);
  s[len] = '\0';
  return s;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x18(%rsp), %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1030
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rax
addq %rax, %rsi
movslq 0x14(%rsp), %rdx
callq 0x10a0
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: writefspecs()
static void writefspecs() {
  putc('\n', outfile);
  for (int i = 0; i < numfspecs; i++) {
    char* spec = fspeclist[i];
    const char* prep = starts(spec, "-Av") ? "mkaverage" : "mkfilter";
    char cmd[MAXSTR + 1];
    int p = 0;
    appends(cmd, p, "%s/%s %s -l | ", TOOLSDIR, (char*)prep, spec);
    appends2(cmd, p, "%s/gencode -f", TOOLSDIR);
    FILE* pfi = popen(cmd, "r");
    if (pfi == NULL)
      giveup("popen failed! (%s)");
    int ch = getc(pfi);
    until(ch < 0) {
      if (ch == '$')
        fprintf(outfile, "%d", i + 1);
      else
        putc(ch, outfile);
      ch = getc(pfi);
    }
    int code = pclose(pfi);
    if (code != 0)
      fprintf(stderr, "gencode failed: cmd was \"%s\"\n", cmd);
  }
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq 0x27ea(%rip), %rsi      # 0x40f8
movl $0xa, %edi
callq 0x1160
movl $0x0, 0x144(%rsp)
movl 0x144(%rsp), %eax
cmpl 0x27d4(%rip), %eax      # 0x4104
jge 0x1ab0
movslq 0x144(%rsp), %rcx
leaq 0x28db(%rip), %rax      # 0x4220
movq (%rax,%rcx,8), %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rdi
leaq 0x7d7(%rip), %rsi       # 0x2137
callq 0x1ac0
movb %al, %dl
leaq 0x7d7(%rip), %rax       # 0x2145
leaq 0x7c6(%rip), %rcx       # 0x213b
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x130(%rsp)
movl $0x0, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
movq 0x130(%rsp), %r8
movq 0x138(%rsp), %r9
leaq 0x1c(%rsp), %rsi
leaq 0x7a1(%rip), %rdx       # 0x214e
leaq 0x7a9(%rip), %rcx       # 0x215d
callq 0x1b30
leaq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
leaq 0x79d(%rip), %rdx       # 0x2167
leaq 0x78c(%rip), %rcx       # 0x215d
callq 0x1bb0
leaq 0x20(%rsp), %rdi
leaq 0x76a(%rip), %rsi       # 0x214c
callq 0x1070
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1a00
leaq 0x77a(%rip), %rdi       # 0x2175
callq 0x1380
movq 0x10(%rsp), %rdi
callq 0x1060
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
setl %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a1e
jmp 0x1a66
cmpl $0x24, 0xc(%rsp)
jne 0x1a46
movq 0x26cc(%rip), %rdi      # 0x40f8
movl 0x144(%rsp), %edx
addl $0x1, %edx
leaq 0x74b(%rip), %rsi       # 0x2188
movb $0x0, %al
callq 0x1150
jmp 0x1a56
movl 0xc(%rsp), %edi
movq 0x26a7(%rip), %rsi      # 0x40f8
callq 0x1160
movq 0x10(%rsp), %rdi
callq 0x1060
movl %eax, 0xc(%rsp)
jmp 0x1a0e
movq 0x10(%rsp), %rdi
callq 0x1140
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x1a98
movq 0x255e(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x6fa(%rip), %rsi       # 0x218b
movb $0x0, %al
callq 0x1150
jmp 0x1a9a
movl 0x144(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x144(%rsp)
jmp 0x1923
addq $0x148, %rsp            # imm = 0x148
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/t_arc4rand_bench.c
// Function: main
int
main(int argc, const char** argv)
{

    if (argc > 1) {
        int i;

        int fd = open("/dev/urandom", O_RDONLY);
        if (fd < 0) error(1, errno, "Can't open dev/urandom");


        printf("size,      arc4rand,\tsysrand,\tspeed-up\n");
        for (i = 1; i < argc; ++i) {
            int z = atoi(argv[i]);
            if (z <= 0) continue;
            bench(fd, z, NITER);
        }


        close(fd);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x12e0
leaq 0x2dd9(%rip), %rdi      # 0x4030
xorl %esi, %esi
movb $0x0, %al
callq 0x10e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1283
callq 0x1040
movl (%rax), %esi
movl $0x1, %edi
leaq 0x2dc1(%rip), %rdx      # 0x403d
movb $0x0, %al
callq 0x3b50
leaq 0x2dca(%rip), %rdi      # 0x4054
movb $0x0, %al
callq 0x1050
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12d8
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1100
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x12bc
jmp 0x12cd
movl -0x18(%rbp), %edi
movslq -0x1c(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x12f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1298
movl -0x18(%rbp), %edi
callq 0x1080
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)