LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/saulvargas[P]re-C-sys/test_pop.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;
    int uid;
    int i;
    recommender_t* recommender;
    idpairs_t* pairs;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    
    fclose(user_data);
    fclose(item_data);

    recommender = recommender_pop_create(recdata);

    for (uid = 0; uid < recdata->N_users; uid++) {
        pairs = recommender_recommend(recommender, uid, 100);

        for (i = 0; i < idpairs_size(pairs); i++) {
            printf("%d\t%d\t%.4f\n", uid, idpairs_keys(pairs)[i], idpairs_values(pairs)[i]);
        }
        
        idpairs_close_deep(pairs);
    }
 
    recommender_close(recommender);
 
    recdata_close(recdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsp, %rax
leaq 0x4(%rsp), %r10
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
pushq %rax
pushq %r10
callq 0x246c
popq %rcx
popq %rdx
testl %eax, %eax
je 0x1314
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
movl (%rsp), %r9d
callq 0x166a
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0x1060
movq 0x18(%rsp), %rdi
callq 0x1060
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x25c6
movq %rax, %r14
xorl %r15d, %r15d
leaq 0x1d6b(%rip), %r12      # 0x3004
movq 0x10(%rsp), %rax
cmpl (%rax), %r15d
jge 0x12fe
movq %r14, %rdi
movl %r15d, %esi
pushq $0x64
popq %rdx
callq 0x1f54
movq %rax, %r13
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x23e3
cltq
cmpq %rax, %rbx
jge 0x12f1
movq %r13, %rdi
callq 0x23e6
movl (%rax,%rbx,4), %ebp
movq %r13, %rdi
callq 0x23eb
movsd (%rax,%rbx,8), %xmm0
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movb $0x1, %al
callq 0x1080
incq %rbx
jmp 0x12b6
movq %r13, %rdi
callq 0x23bf
incl %r15d
jmp 0x1299
movq %r14, %rdi
callq 0x2025
movq 0x10(%rsp), %rdi
callq 0x1360
xorl %eax, %eax
jmp 0x1317
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: advance
static void
advance(FILE *in,FILE *out,RRA *h)
    {
    int i;
    int start = SamplesWritten;
    int more = replace(in,out,h);
    int thresholdReached = 0;
    int peak = 0;

    //printf("advancing\n");
    while (more && !(thresholdReached && peek(0) == 0 && peek(1) > 0))
        {
        if (abs(peek(0)) > peak) peak = abs(peek(0));
        if (thresholdReached == 0 && peak > AbsoluteThreshold)
            thresholdReached = 1;
        //printf("while advancing, first amp is %d\n",peek(0));
        //printf("while advancing, second amp is %d\n",peek(1));
        //printf("while advancing, thresholdReached is %d\n",thresholdReached);
        more = replace(in,out,h);
        }

    //printf("after advance, first amp is %d\n",peek(0));
    //printf("after advance, second amp is %d\n",peek(1));
    //printf("more: %d\n",more);
    //printf("thresholdReached: %d\n",thresholdReached);

    if (!more)
        {
        //printf("dumping the window, stored = %d\n",SamplesStored);
        int count = SamplesStored;
        for (i = 0; i < count; ++i)
            replace(in,out,h);
        //printf("done dumping the window, stored = %d\n",SamplesStored);
        }

    if (Report)
        fprintf(ReportFP,"no repitching of cycle with length %d, peak was %d\n",
            SamplesWritten - start,peak);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movl 0x559b(%rip), %eax      # 0x8964
movl %eax, -0x2c(%rbp)
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x34a2
testl %eax, %eax
je 0x3437
movq 0x5571(%rip), %rsi      # 0x8958
movl 0x558b(%rip), %ecx      # 0x8978
movl 0x5554(%rip), %r8d      # 0x8948
movl %ecx, %eax
cltd
idivl %r8d
movslq %edx, %rdi
testb $0x1, %r13b
je 0x341a
cmpl $0x0, (%rsi,%rdi,4)
jne 0x341a
incl %ecx
movl %ecx, %eax
cltd
idivl %r8d
movslq %edx, %rax
cmpl $0x0, (%rsi,%rax,4)
jg 0x345c
movl (%rsi,%rdi,4), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
cmpl 0x551d(%rip), %ebx      # 0x894c
setg %al
orb %al, %r13b
jmp 0x33ce
movl 0x5533(%rip), %eax      # 0x8970
xorl %r13d, %r13d
testl %eax, %eax
cmovgl %eax, %r13d
subl $0x1, %r13d
jb 0x345c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x34a2
jmp 0x3446
cmpb $0x1, 0x54c1(%rip)      # 0x8924
jne 0x3493
movq 0x54bc(%rip), %rdi      # 0x8928
movl 0x54f2(%rip), %edx      # 0x8964
subl -0x2c(%rbp), %edx
leaq 0x1fac(%rip), %rsi      # 0x5428
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: replace
static int 
replace(FILE *in,FILE *out,RRA *h)
    {
    int amp;
    fprintf(out,"%d\n",Window[WindowStart]);
    ++SamplesWritten;
    WindowStart = (WindowStart + 1) % WindowSize;
    --SamplesStored;
    amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
    if (!feof(in))
        {
        ++SamplesRead;
        ++SamplesStored;
        Window[WindowEnd] = amp;
        WindowEnd = (WindowEnd + 1) % WindowSize;
        return 1;
        }
    else
        {
        return 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x549b(%rip), %rax      # 0x8958
movslq 0x54b4(%rip), %rcx      # 0x8978
movl (%rax,%rcx,4), %edx
leaq 0x26d7(%rip), %rsi      # 0x5ba5
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2170
incl 0x5484(%rip)            # 0x8964
movl 0x5492(%rip), %eax      # 0x8978
incl %eax
cltd
idivl 0x5459(%rip)            # 0x8948
movl %edx, 0x5483(%rip)      # 0x8978
decl 0x5475(%rip)            # 0x8970
movl 0x8(%r12), %edx
leaq 0x13e6(%rip), %rcx      # 0x48ed
movq %r14, %rdi
movq %r15, %rsi
callq 0x4126
movl %eax, %r15d
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
jne 0x3552
incl 0x5439(%rip)            # 0x8960
incl 0x5443(%rip)            # 0x8970
movq 0x5424(%rip), %rax      # 0x8958
movslq 0x5439(%rip), %rcx      # 0x8974
movl %r15d, (%rax,%rcx,4)
leal 0x1(%rcx), %eax
cltd
idivl 0x53ff(%rip)            # 0x8948
movl %edx, 0x5425(%rip)      # 0x8974
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: q_bytestring_chunk
SCSP_INT q_bytestring_chunk (SCSP_USERDATA userdata, const uint8_t* buf, size_t len) {
    int i;
    for (i=0; i<len; ++i) {
        printf("%02X", (int)buf[i]);
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xdf4(%rip), %r15       # 0x200b
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x1233
movzbl (%r14,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1070
incq %r12
jmp 0x121a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: q_array_item
SCSP_INT q_array_item (SCSP_USERDATA userdata) {
    if (!just_opened) {
        printf(", ");
    }
    just_opened = 0;
    return 0;
}

// Assembly:
cmpb $0x0, 0x2e77(%rip)      # 0x4114
jne 0x12b2
pushq %rax
leaq 0xd69(%rip), %rdi       # 0x2010
xorl %eax, %eax
callq 0x1070
addq $0x8, %rsp
movb $0x0, 0x2e5b(%rip)      # 0x4114
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: q_map_key
SCSP_INT q_map_key (SCSP_USERDATA userdata) {
    if (!just_opened) {
        printf(", ");
    }
    just_opened = 0;
    return 0;
}

// Assembly:
cmpb $0x0, 0x2e30(%rip)      # 0x4114
jne 0x12f9
pushq %rax
leaq 0xd22(%rip), %rdi       # 0x2010
xorl %eax, %eax
callq 0x1070
addq $0x8, %rsp
movb $0x0, 0x2e14(%rip)      # 0x4114
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: main
int main(int argc, char* argv[]) {
    if (argc != 2) {
        printf("Usage: cbor_to_jsonesque {filename|-}\n");
        return 1;
    }
    int f;
    if (argv[1][0] == '-' && argv[1][1] == '\0') {
        f = 0;
    } else {
        f = open(argv[1], O_RDONLY);
        if (f == -1) {
            perror("open");
            return 2;
        }
    }
    
    just_opened = 0;
    
    if ( -1 == scsp_parse_from_fd(f, &q_callbacks, NULL) ) {
        fprintf(stderr, "Error reading CBOR\n");
        return 4;
    }
    
    printf("\n");
    return 0;
}

// Assembly:
pushq %rbx
cmpl $0x2, %edi
jne 0x13ee
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x13b7
cmpb $0x0, 0x1(%rdi)
je 0x1401
xorl %esi, %esi
xorl %eax, %eax
callq 0x10a0
movl %eax, %edi
cmpl $-0x1, %eax
je 0x1425
movb $0x0, 0x2d46(%rip)      # 0x4114
leaq 0x2cab(%rip), %rsi      # 0x4080
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x1dca
cmpq $-0x1, %rax
je 0x1405
pushq $0xa
popq %rdi
callq 0x1030
jmp 0x13fd
leaq 0xc6e(%rip), %rdi       # 0x2063
callq 0x1060
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
xorl %edi, %edi
jmp 0x13c7
movq 0x2bec(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xc39(%rip), %rdi       # 0x204f
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x10c0
pushq $0x4
jmp 0x13fc
leaq 0xc1e(%rip), %rdi       # 0x204a
callq 0x10b0
pushq $0x2
jmp 0x13fc
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_03/fahrenheit_celsius.c
// Function: main
int main(void)
{
  float fahr, celsius;
  int lower, upper, step;

  lower = 0;
  upper = 300;
  step = 20;

  // Printing a heading above the table
  printf("Fahr\tCelsius\n");
  printf("---------------\n");

  fahr = lower;
  while (fahr <= upper)
  {
    celsius = (5.0 / 9.0) * (fahr - 32.0);
    printf("%3.0f\t\t%6.1f\n", fahr, celsius);
    fahr = fahr + step;
  }

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xed6(%rip), %rdi       # 0x202e
callq 0x1030
leaq 0xed7(%rip), %rdi       # 0x203b
callq 0x1030
xorps %xmm0, %xmm0
leaq 0xead(%rip), %rbx       # 0x2020
movss 0xe89(%rip), %xmm1      # 0x2004
ucomiss %xmm0, %xmm1
jb 0x11c1
movss %xmm0, 0xc(%rsp)
cvtss2sd 0xc(%rsp), %xmm0
movaps %xmm0, %xmm1
addsd 0xe79(%rip), %xmm1      # 0x2010
mulsd 0xe79(%rip), %xmm1      # 0x2018
cvtsd2ss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
movq %rbx, %rdi
movb $0x2, %al
callq 0x1040
movss 0xc(%rsp), %xmm0
addss 0xe49(%rip), %xmm0      # 0x2008
jmp 0x1173
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/pdp1/mach.c
// Function: examinereg
Word
examinereg(int a)
{
	switch(a){
	case REG_PC: return pdp1.pc;
	case REG_AC: return pdp1.ac;
	case REG_IO: return pdp1.io;
	case REG_SS: return pdp1.ss;
	case REG_PF: return pdp1.pf;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x4, %edi
ja 0x3db5
movl %edi, %eax
leaq 0x24e8(%rip), %rcx      # 0x626c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xa7fd(%rip), %eax      # 0xe590
jmp 0x3db7
movl 0xe859(%rip), %eax      # 0x125f4
jmp 0x3db7
movl 0xa7e1(%rip), %eax      # 0xe584
jmp 0x3db7
movl 0xe845(%rip), %eax      # 0x125f0
jmp 0x3db7
movl 0xa7cd(%rip), %eax      # 0xe580
jmp 0x3db7
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/pdp1/mach.c
// Function: spec
static void
spec(PDP1 *pdp)
{
	// PB
	pdp->run = 0;
	if(pdp->start_sw || pdp->deposit_sw || pdp->examine_sw)
		pdp->rim = 0;

	// SP1
	pdp->run_enable = 1;
	pdp->ma = 0;
	if(pdp->start_sw)
		pdp->cyc = 0;
	if(pdp->deposit_sw)
		pdp->ac = 0;
	if(pdp->start_sw || pdp->deposit_sw || pdp->examine_sw)
		sc(pdp);

	// SP2
	if(pdp->start_sw || pdp->deposit_sw || pdp->examine_sw)
		pdp->pc |= pdp->ta;
	if(pdp->deposit_sw || pdp->examine_sw || pdp->rim)
		pdp->cyc = 1;
	if(pdp->examine_sw)
		pdp->ir |= 020>>1;
	if(pdp->deposit_sw) {
		pdp->ir |= 024>>1;
		pdp->ac |= pdp->tw;
	}

	// SP3
	if(pdp->deposit_sw || pdp->examine_sw) {
		pdp->ma |= pdp->pc;
		pdp->cychack = 1;
	}

	// SP4
	if(pdp->start_sw || pdp->continue_sw)
		pdp->run = 1;

	pdp->start_sw = 0;
	pdp->stop_sw = 0;
	pdp->continue_sw = 0;
	pdp->examine_sw = 0;
	pdp->deposit_sw = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andl $0x0, 0x4034(%rdi)
movl 0x4020(%rdi), %ecx
testl %ecx, %ecx
je 0x43ac
andl $0x0, 0x4058(%rdi)
movq $0x1, 0x4038(%rdi)
andl $0x0, 0xc(%rdi)
leaq 0x4030(%rdi), %rax
xorl %edx, %edx
cmpl %edx, 0x4030(%rdi)
jne 0x43d5
movb $0x1, %dl
jmp 0x43da
leaq 0x4030(%rdi), %rax
cmpl $0x0, 0x4030(%rdi)
je 0x4489
andl $0x0, 0x4058(%rdi)
movl $0x1, 0x4038(%rdi)
andl $0x0, 0xc(%rdi)
andl $0x0, (%rdi)
xorl %edx, %edx
testl %ecx, %ecx
setne %sil
andq $0x0, 0x4040(%rdi)
andq $0x0, 0x4050(%rdi)
andq $0x0, 0x4064(%rdi)
andl $0x0, 0x406c(%rdi)
andq $0x0, 0x10(%rdi)
movabsq $0x100000000, %r8       # imm = 0x100000000
movq %r8, 0x405c(%rdi)
xorb $0x1, %dl
orb %dl, %sil
je 0x444c
testl %ecx, %ecx
sete %sil
movl 0x4018(%rdi), %r8d
movl %r8d, 0x10(%rdi)
orb %dl, %sil
je 0x445e
movl $0x1, 0x403c(%rdi)
orb $0xa, 0x14(%rdi)
movl 0x401c(%rdi), %esi
movq %rdi, %rdx
jmp 0x447a
cmpl $0x0, 0x402c(%rdi)
je 0x44b6
movl 0x4018(%rdi), %edx
orl %edx, 0x10(%rdi)
cmpl $0x0, 0x402c(%rdi)
je 0x44b6
movl $0x1, 0x403c(%rdi)
leaq 0x14(%rdi), %rdx
movl $0x8, %esi
orl %esi, (%rdx)
movl 0x10(%rdi), %edx
movl %edx, 0xc(%rdi)
movl $0x4080, %edx           # imm = 0x4080
jmp 0x44c4
cmpl $0x0, 0x402c(%rdi)
je 0x4499
andl $0x0, 0x4058(%rdi)
movl $0x1, 0x4038(%rdi)
andl $0x0, 0xc(%rdi)
movb $0x1, %dl
cmpl $0x0, 0x402c(%rdi)
jne 0x43da
movl $0x403c, %edx           # imm = 0x403C
cmpl $0x0, 0x4058(%rdi)
je 0x44cb
movl $0x1, (%rdi,%rdx)
leaq 0x4020(%rdi), %rdx
testl %ecx, %ecx
jne 0x44df
cmpl $0x0, 0x4028(%rdi)
je 0x44e9
movl $0x1, 0x4034(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
andl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/pdp1/mach.c
// Function: initmach
void
initmach(void)
{
	memset(&pdp1, 0, sizeof(pdp1));
	pdp1.ioc = 1;

	int i = 0100;
	pdp1.core[i++] = 0760400;

	cmdchan = chancreate(sizeof(Msg), 1);
	threadcreate(simthread, &pdp1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x934e(%rip), %rbx      # 0xe580
movl $0x4084, %edx           # imm = 0x4084
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2110
movl $0x1, 0xd395(%rip)      # 0x125e0
movl $0x3e100, 0x9443(%rip)  # imm = 0x3E100
pushq $0x8
popq %rdi
pushq $0x1
popq %rsi
callq 0x39e5
movq %rax, 0xd411(%rip)      # 0x12678
leaq -0xd7a(%rip), %rdi      # 0x44f4
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x37fe
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/pdp1/mach.c
// Function: shro
static void
shro(PDP1 *pdp)
{
	int ac = AC;
	int io = IO;
	switch((MB>>9) & 017) {
	case 001:	// RAL
		ac = (AC&~B0)<<1 | (AC&B0)>>17;
		break;
	case 002:	// RIL
		io = (IO&~B0)<<1 | (IO&B0)>>17;
		break;
	case 003:	// RCL
		ac = (AC&~B0)<<1 | (IO&B0)>>17;
		io = (IO&~B0)<<1 | (AC&B0)>>17;
		break;
	case 005:	// SAL
		ac = (AC&B0) | (AC&~(B0|B1))<<1 | (AC&B0)>>17;
		break;
	case 006:	// SIL
		io = (IO&B0) | (IO&~(B0|B1))<<1 | (IO&B0)>>17;
		break;
	case 007:	// SCL
		ac = (AC&B0) | (AC&~(B0|B1))<<1 | (IO&B0)>>17;
		io = (IO&~B0)<<1 | (AC&B0)>>17;
		break;
	case 011:	// RAR
		ac = (AC&B17)<<17 | AC>>1;
		break;
	case 012:	// RIR
		io = (IO&B17)<<17 | IO>>1;
		break;
	case 013:	// RCR
		ac = (IO&B17)<<17 | AC>>1;
		io = (AC&B17)<<17 | IO>>1;
		break;
	case 015:	// SAR
		ac = (AC&B0) | AC>>1;
		break;
	case 016:	// SIR
		io = (IO&B0) | IO>>1;
		break;
	case 017:	// SCR
		ac = (AC&B0) | AC>>1;
		io = (AC&B17)<<17 | IO>>1;
		break;
	}
	AC = ac;
	IO = io;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
movl 0x8(%rdi), %edx
shrl $0x9, %edx
andl $0xf, %edx
decl %edx
cmpl $0xe, %edx
ja 0x53b1
leaq 0x117e(%rip), %rsi      # 0x6424
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movl %ecx, %edx
andl $0xfffdffff, %edx       # imm = 0xFFFDFFFF
shrl $0x11, %ecx
andl $0x1, %ecx
leal (%rcx,%rdx,2), %ecx
jmp 0x53b1
movl %eax, %edx
andl $0x20000, %edx          # imm = 0x20000
jmp 0x5354
movl $0xfffdffff, %edx       # imm = 0xFFFDFFFF
movl %ecx, %esi
andl %edx, %esi
movl %eax, %r8d
shrl $0x11, %r8d
andl $0x1, %r8d
leal (%r8,%rsi,2), %esi
andl %edx, %eax
shrl $0x11, %ecx
andl $0x1, %ecx
leal (%rcx,%rax,2), %eax
jmp 0x53af
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
andl $0xfffcffff, %ecx       # imm = 0xFFFCFFFF
movl %eax, %esi
shrl $0x11, %esi
andl $0x1, %esi
leal (%rsi,%rcx,2), %ecx
orl %edx, %ecx
andl $0xfffdffff, %eax       # imm = 0xFFFDFFFF
shrl $0x11, %edx
leal (%rdx,%rax,2), %eax
jmp 0x53b1
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
jmp 0x539f
movl %eax, %edx
andl $0xfffdffff, %edx       # imm = 0xFFFDFFFF
shrl $0x11, %eax
andl $0x1, %eax
leal (%rax,%rdx,2), %eax
jmp 0x53b1
movl %ecx, %edx
andl $0x1, %edx
shll $0x11, %edx
jmp 0x5391
movl %eax, %edx
andl $0x1, %edx
shll $0x11, %edx
shrl %eax
jmp 0x5385
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
andl $0xfffcffff, %ecx       # imm = 0xFFFCFFFF
movl %edx, %esi
shrl $0x11, %esi
leal (%rsi,%rcx,2), %ecx
jmp 0x5393
movl %eax, %edx
andl $0x20000, %edx          # imm = 0x20000
andl $0xfffcffff, %eax       # imm = 0xFFFCFFFF
movl %edx, %esi
shrl $0x11, %esi
leal (%rsi,%rax,2), %eax
orl %edx, %eax
jmp 0x53b1
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
shrl %ecx
orl %edx, %ecx
jmp 0x53b1
movl %eax, %edx
andl $0x1, %edx
shll $0x11, %edx
movl %ecx, %esi
shrl %esi
orl %edx, %esi
andl $0x1, %ecx
shll $0x11, %ecx
shrl %eax
orl %ecx, %eax
movl %esi, %ecx
movl %ecx, (%rdi)
movl %eax, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeV
int genCodeV(OpCode op, int v) { /* 命令語の生成、アドレス部にv         */
    checkMax();
    code[cIndex].opCode = op;
    code[cIndex].u.value = v;
    return cIndex;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x3037
movslq 0x4e38(%rip), %rax      # 0x70d0
imulq $0xc, %rax, %rcx
leaq 0x4e4d(%rip), %rdx      # 0x70f0
movl %ebp, (%rcx,%rdx)
movl %ebx, 0x4(%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeT
int genCodeT(OpCode op, int ti) { /* 命令語の生成、アドレスは名前表から */
    checkMax();
    code[cIndex].opCode = op;
    code[cIndex].u.addr = relAddr(ti);
    return cIndex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x3037
movslq 0x4e08(%rip), %rax      # 0x70d0
imulq $0xc, %rax, %r14
leaq 0x4e1d(%rip), %r15      # 0x70f0
movl %ebp, (%r14,%r15)
movl %ebx, %edi
callq 0x3327
movq %rax, 0x4(%r14,%r15)
movl 0x4de7(%rip), %eax      # 0x70d0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeO
int genCodeO(Operator p) {      /* 命令語の生成、アドレス部に演算命令    */
    checkMax();
    code[cIndex].opCode = opr;
    code[cIndex].u.optr = p;
    return cIndex;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x3037
movslq 0x4dcd(%rip), %rax      # 0x70d0
imulq $0xc, %rax, %rcx
leaq 0x4de2(%rip), %rdx      # 0x70f0
movl $0x1, (%rcx,%rdx)
movl %ebx, 0x4(%rcx,%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeR
int genCodeR() {                /* ret命令語の生成                      */
    if (code[cIndex].opCode == ret)
        return cIndex;          /* 直前がretなら生成せず                */
    checkMax();
    code[cIndex].opCode = ret;
    code[cIndex].u.addr.level = bLevel();
    code[cIndex].u.addr.addr = fPars(); /* パラメタ数（実行スタックの解放用） */
    return cIndex;
}

// Assembly:
pushq %rbx
movslq 0x4dad(%rip), %rax      # 0x70d0
imulq $0xc, %rax, %rcx
leaq 0x4dc2(%rip), %rbx      # 0x70f0
cmpl $0x5, (%rcx,%rbx)
je 0x2379
callq 0x3037
movslq 0x4d90(%rip), %rax      # 0x70d0
imulq $0xc, %rax, %rax
movl $0x5, (%rax,%rbx)
xorl %eax, %eax
callq 0x30f8
movslq 0x4d77(%rip), %rcx      # 0x70d0
imulq $0xc, %rcx, %rcx
movl %eax, 0x4(%rcx,%rbx)
xorl %eax, %eax
callq 0x30ff
movl %eax, %ecx
movslq 0x4d5f(%rip), %rax      # 0x70d0
imulq $0xc, %rax, %rdx
movl %ecx, 0x8(%rdx,%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/codegen.c
// Function: listCode
void listCode(FILE *fp, int showLineNumber) { /* 命令語のリスティング */
    int i;
    if (fp == NULL) {
      fp = stdin;
      fprintf(stdout, "\ncode\n");
    }
    for (i = 0; i <= cIndex; i++) {
        if (showLineNumber) fprintf(fp, "%3d: ", i);
        printCode(fp, i, '\n');
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x23ce
movq 0x4c19(%rip), %rax      # 0x6fc8
movq (%rax), %r14
movq 0x4c07(%rip), %rax      # 0x6fc0
movq (%rax), %rcx
leaq 0x1d61(%rip), %rdi      # 0x4124
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x2170
pushq $0xa
popq %rbp
leaq 0x1d53(%rip), %r15      # 0x412b
xorl %r12d, %r12d
cmpl 0x4cee(%rip), %r12d     # 0x70d0
jg 0x240a
testl %ebx, %ebx
je 0x23f8
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x2413
incl %r12d
jmp 0x23db
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/codegen.c
// Function: initMemory
void initMemory(Mem *m, const int *secretValue) { /* 目的コード（命令語）の実行メモリの初期化 */
    int i;
    m->top = m->pc = 0;             /* top:次にスタックに入れる場所、pc:命令語のカウンタ */
    m->stack[0] = m->stack[1] = 0;  /* stack[top]はcalleeで壊すディスプレイの退避場所 */
                                    /* stack[top+1]はcallerへの戻り番地 */
    m->topMax = 1;
    for (i = 2; i < MAXMEM; i++) m->stack[i] = -1;
    m->display[0] = 0;              /* 主ブロックの先頭番地は 0 */
    for (i = 1; i < MAXLEVEL; i++) m->display[i] = -1;
    m->exitCode = 0;                /* 未終了状態 */
    m->stepCount = 0;               /* 初期ステップ数は 0 */
    for (i = 0;i < MAXSCREEN; i++) m->screen[i] = '\0';
    m->breakPoint = -1;             /* ブレークポイントは未設定 */
    if (secretValue) { /* シークレットモード */
      m->stack[2] = *secretValue; /* 第3セルに値を格納 */
      m->topMax = 2;
      m->secretMode = 1;
      m->secretValue = *secretValue;
    }
}

// Assembly:
andq $0x0, 0x1f54(%rdi)
andq $0x0, (%rdi)
movl $0x1, 0x1f5c(%rdi)
pushq $0x2
popq %rax
cmpq $0x7d0, %rax            # imm = 0x7D0
je 0x27de
orl $-0x1, (%rdi,%rax,4)
incq %rax
jmp 0x27cd
andl $0x0, 0x1f40(%rdi)
xorl %eax, %eax
cmpq $0x4, %rax
je 0x27fa
orl $-0x1, 0x1f44(%rdi,%rax,4)
incq %rax
jmp 0x27e7
andq $0x0, 0x1f60(%rdi)
xorl %eax, %eax
cmpq $0x200, %rax            # imm = 0x200
je 0x2819
movb $0x0, 0x1f68(%rdi,%rax)
incq %rax
jmp 0x2804
orl $-0x1, 0x2168(%rdi)
testq %rsi, %rsi
je 0x2846
movl (%rsi), %eax
movl %eax, 0x8(%rdi)
movl $0x2, 0x1f5c(%rdi)
movl $0x1, 0x216c(%rdi)
movl (%rsi), %eax
movl %eax, 0x2170(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/codegen.c
// Function: stepBackward
void stepBackward(Mem *m) {     /* 目的コード（命令語）の1ステップ後退 */
  const int stepCount = m->stepCount;
  const int secretMode = m->secretMode, secretValue = m->secretValue;
  if (stepCount == 0) return; /* これ以上後退できない */
  initMemory(m, (secretMode ? &secretValue : NULL));
  while (m->stepCount != stepCount-1) stepForward(m); /* 1つ前のステップまで前進 */
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x1f64(%rdi), %ebp
movl 0x216c(%rdi), %eax
movl 0x2170(%rdi), %ecx
movl %ecx, 0x4(%rsp)
testl %ebp, %ebp
je 0x2de1
movq %rdi, %rbx
xorl %ecx, %ecx
testl %eax, %eax
leaq 0x4(%rsp), %rsi
cmoveq %rcx, %rsi
callq 0x27b4
decl %ebp
cmpl %ebp, 0x1f64(%rbx)
je 0x2de1
movq %rbx, %rdi
callq 0x2a6f
jmp 0x2dcf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/table.c
// Function: blockBegin
void blockBegin(int firstAddr) { /* ブロックの始まり(最初の変数の番地)で呼ばれる */
    if (level == -1) {          /* 主ブロックの時、初期設定             */
        localAddr = firstAddr;
        tIndex = 0;
        level++;
        return;
    }
    if (level == MAXLEVEL-1)
        errorF("too many nested blocks");
    lIndex[level] = tIndex;     /* 今までのブロックの情報を格納         */
    addr[level] = localAddr;
    localAddr = firstAddr;      /* 新しいブロックの最初の変数の番地     */
    level++;                    /* 新しいブロックのレベル               */
    return;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x406f(%rip), %eax      # 0x70d4
cmpl $0x4, %eax
je 0x3080
cmpl $-0x1, %eax
jne 0x3092
movl %ebx, 0x49db(%rip)      # 0x7a50
andl $0x0, 0x49d8(%rip)      # 0x7a54
xorl %eax, %eax
jmp 0x30bc
leaq 0x1235(%rip), %rdi      # 0x42bc
callq 0x3717
movl 0x4042(%rip), %eax      # 0x70d4
movl 0x49bc(%rip), %ecx      # 0x7a54
cltq
leaq 0x49bf(%rip), %rdx      # 0x7a60
movl %ecx, (%rdx,%rax,4)
movl 0x49a6(%rip), %ecx      # 0x7a50
leaq 0x49cf(%rip), %rdx      # 0x7a80
movl %ecx, (%rdx,%rax,4)
movl %ebx, 0x4996(%rip)      # 0x7a50
incl %eax
movl %eax, 0x4012(%rip)      # 0x70d4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/table.c
// Function: enterTfunc
int enterTfunc(char *id, int v) { /* 名前表に関数名と先頭番地を登録     */
    enterT(id);
    nameTable[tIndex].kind = funcId;
    nameTable[tIndex].u.f.raddr.level = level;
    nameTable[tIndex].u.f.raddr.addr = v; /* 関数の先頭番地             */
    nameTable[tIndex].u.f.pars = 0; /* パラメタ数の初期値               */
    tfIndex = tIndex;
    return tIndex;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x3122
movslq 0x48e5(%rip), %rax      # 0x7a54
imulq $0x30, %rax, %rcx
leaq 0x4926(%rip), %rdx      # 0x7aa0
movl $0x1, (%rcx,%rdx)
movl 0x3f4d(%rip), %esi      # 0x70d4
movl %esi, 0x24(%rcx,%rdx)
movl %ebx, 0x28(%rcx,%rdx)
andl $0x0, 0x2c(%rcx,%rdx)
movl %eax, 0x5bc6(%rip)      # 0x8d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/table.c
// Function: enterTpar
int enterTpar(char *id) {       /* 名前表にパラメタ名を登録             */
    enterT(id);
    nameTable[tIndex].kind = parId;
    nameTable[tIndex].u.raddr.level = level;
    nameTable[tfIndex].u.f.pars++; /* 関数のパラメタ数のカウント        */
    return tIndex;
}

// Assembly:
pushq %rax
callq 0x3122
movslq 0x48ab(%rip), %rax      # 0x7a54
imulq $0x30, %rax, %rcx
leaq 0x48ec(%rip), %rdx      # 0x7aa0
movl $0x2, (%rcx,%rdx)
movl 0x3f13(%rip), %esi      # 0x70d4
movl %esi, 0x24(%rcx,%rdx)
movslq 0x5b94(%rip), %rcx      # 0x8d60
imulq $0x30, %rcx, %rcx
incl 0x2c(%rcx,%rdx)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/table.c
// Function: enterTvar
int enterTvar(char *id) {       /* 名前表に変数名を登録                 */
    enterT(id);
    nameTable[tIndex].kind = varId;
    nameTable[tIndex].u.raddr.level = level;
    nameTable[tIndex].u.raddr.addr = localAddr++;
    return tIndex;
}

// Assembly:
pushq %rax
callq 0x3122
movslq 0x4871(%rip), %rax      # 0x7a54
imulq $0x30, %rax, %rcx
leaq 0x48b2(%rip), %rdx      # 0x7aa0
andl $0x0, (%rcx,%rdx)
movl 0x3edc(%rip), %esi      # 0x70d4
movl %esi, 0x24(%rcx,%rdx)
movl 0x484e(%rip), %esi      # 0x7a50
leal 0x1(%rsi), %edi
movl %edi, 0x4845(%rip)      # 0x7a50
movl %esi, 0x28(%rcx,%rdx)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/table.c
// Function: enterTconst
int enterTconst(char *id, int v) { /* 名前表に定数名とその値を登録      */
    enterT(id);
    nameTable[tIndex].kind = constId;
    nameTable[tIndex].u.value = v;
    return tIndex;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x3122
movslq 0x4834(%rip), %rax      # 0x7a54
imulq $0x30, %rax, %rcx
leaq 0x4875(%rip), %rdx      # 0x7aa0
movl $0x3, (%rcx,%rdx)
movl %ebx, 0x24(%rcx,%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/table.c
// Function: endpar
void endpar() {                 /* パラメタ宣言部の最後で呼ばれる       */
    int i;
    int pars = nameTable[tfIndex].u.f.pars;
    if (pars == 0)  return;
    for (i=1; i <= pars; i++)   /* 各パラメタの番地を求める             */
         nameTable[tfIndex+i].u.raddr.addr = i-1-pars;
}

// Assembly:
movslq 0x5b21(%rip), %rax      # 0x8d60
imulq $0x30, %rax, %rsi
leaq 0x4856(%rip), %rdi      # 0x7aa0
movl 0x2c(%rsi,%rdi), %eax
testl %eax, %eax
je 0x327b
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
imulq $0x30, %rdx, %rdx
negl %eax
addq %rdi, %rsi
addq $0x58, %rsi
cmpq %rcx, %rdx
je 0x327b
movl %eax, (%rsi,%rcx)
addq $0x30, %rcx
incl %eax
jmp 0x326b
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/table.c
// Function: searchT
int searchT(char *id, KindT k) { /* 名前idの名前表の位置を返す          */
                                /* 未宣言の時エラーとする               */
    int i;
    i = tIndex;
    strcpy(nameTable[0].name, id); /* 番兵をたてる                      */
    while ( strcmp(id, nameTable[i].name) )
        i--;
    if (i)                      /* 名前があった                         */
        return i;
    else {                      /* 名前がなかった                       */
        errorType("undef");
        if (k == varId) return enterTvar(id); /* 変数の時は仮登録       */
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x47b1(%rip), %r15      # 0x7a54
leaq 0x47fa(%rip), %rdi      # 0x7aa4
movq %rbx, %rsi
callq 0x2050
leaq 0x47e7(%rip), %rax      # 0x7aa0
imulq $0x30, %r15, %rcx
leaq (%rcx,%rax), %r14
addq $0x4, %r14
pushq $-0x1
popq %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20e0
incq %r12
addq $-0x30, %r14
testl %eax, %eax
jne 0x32c9
cmpq %r12, %r15
jne 0x3306
leaq 0xff7(%rip), %rdi       # 0x42e2
callq 0x35c1
xorl %eax, %eax
testl %ebp, %ebp
jne 0x330c
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31d6
movl %r15d, %eax
subq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: openSource
int openSource(char fileName[], int outHtml) { /* ソースファイルのopen */
    char *fileNameO = "g.out.html";
    if ((fpi = fopen(fileName, "r")) == NULL ) {
        printf("can't open %s\n", fileName);
        return 0;
    }
    if (outHtml) {
        if ((fphtml = fopen(fileNameO, "w")) == NULL) { /* .htmlファイルを作る */
            printf("can't open %s\n", fileNameO);
            return 0;
        }
    } else {
        fphtml = fopen("/dev/null", "w"); /* 書き込みを破棄 */
    }
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x1162(%rip), %rsi      # 0x44da
callq 0x2130
movq %rax, 0x59ec(%rip)      # 0x8d70
testq %rax, %rax
je 0x33be
testl %ebx, %ebx
je 0x33d3
leaq 0xf9c(%rip), %rdi       # 0x4330
leaq 0xe4e(%rip), %rsi       # 0x41e9
callq 0x2130
movq %rax, 0x59d1(%rip)      # 0x8d78
testq %rax, %rax
jne 0x33ed
leaq 0xf88(%rip), %rdi       # 0x433b
leaq 0xf76(%rip), %rsi       # 0x4330
xorl %ebx, %ebx
jmp 0x33ca
leaq 0xf76(%rip), %rdi       # 0x433b
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2090
jmp 0x33f0
leaq 0xf70(%rip), %rdi       # 0x434a
leaq 0xe08(%rip), %rsi       # 0x41e9
callq 0x2130
movq %rax, 0x598b(%rip)      # 0x8d78
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: initSource
void initSource() {
    lineIndex = -1;             /* 初期設定                             */
    ch = '\n';
    printed = 1;
    initCharClassT();
    fprintf(fphtml, "<HTML>\n");  /* htmlコマンド                         */
    fprintf(fphtml, "<HEAD>\n<TITLE>compiled source program</TITLE>\n</HEAD>\n");
    fprintf(fphtml, "<BODY>\n<PRE>\n");
}

// Assembly:
orl $-0x1, 0x5965(%rip)     # 0x8d80
movb $0xa, 0x5962(%rip)      # 0x8d84
movb $0x1, 0x595f(%rip)      # 0x8d88
xorl %ecx, %ecx
leaq 0x598e(%rip), %rax      # 0x8dc0
cmpq $0x400, %rcx            # imm = 0x400
je 0x3448
movl $0x27, (%rcx,%rax)
addq $0x4, %rcx
jmp 0x3432
xorl %ecx, %ecx
cmpq $0xa, %rcx
je 0x3460
movl $0x25, 0xc0(%rax,%rcx,4)
incq %rcx
jmp 0x344a
xorl %ecx, %ecx
cmpq $0x1a, %rcx
je 0x3478
movl $0x24, 0x104(%rax,%rcx,4)
incq %rcx
jmp 0x3462
xorl %ecx, %ecx
cmpq $0x1a, %rcx
je 0x3490
movl $0x24, 0x184(%rax,%rcx,4)
incq %rcx
jmp 0x347a
pushq %rbx
movaps 0xe58(%rip), %xmm0      # 0x42f0
movaps %xmm0, 0x59c1(%rip)     # 0x8e60
movl $0x17, 0x5a0f(%rip)     # 0x8eb8
movaps 0xe50(%rip), %xmm0      # 0x4300
movaps %xmm0, 0x59b9(%rip)     # 0x8e70
movaps 0xe52(%rip), %xmm0      # 0x4310
movups %xmm0, 0x59e3(%rip)     # 0x8ea8
movq 0x58ac(%rip), %rcx      # 0x8d78
leaq 0xe81(%rip), %rdi       # 0x4354
pushq $0x7
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2170
movq 0x5890(%rip), %rcx      # 0x8d78
leaq 0xe6d(%rip), %rdi       # 0x435c
pushq $0x36
popq %rsi
movq %rbx, %rdx
callq 0x2170
movq 0x5877(%rip), %rcx      # 0x8d78
leaq 0xe8b(%rip), %rdi       # 0x4393
pushq $0xd
popq %rsi
movq %rbx, %rdx
popq %rbx
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: finalSource
void finalSource() {
    if (cToken.kind == Period)
        printcToken();
    else
        errorInsert(Period);
    fprintf(fphtml, "\n</PRE>\n</BODY>\n</HTML>\n");
}

// Assembly:
pushq %rax
cmpl $0x1c, 0x5870(%rip)     # 0x8d8c
jne 0x3525
callq 0x3b10
jmp 0x352d
pushq $0x1c
popq %rdi
callq 0x3547
movq 0x5844(%rip), %rcx      # 0x8d78
leaq 0xf35(%rip), %rdi       # 0x4470
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
popq %rax
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: errorNoCheck
void errorNoCheck() {           /* エラーの個数のカウント、多すぎたら終わり */
    if (errorNo++ > MAXERROR) {
        fprintf(fphtml, "too many errors\n</PRE>\n</BODY>\n</HTML>\n");
        printf("abort compilation\n");
        exit(1);
    }
}

// Assembly:
movl 0x582c(%rip), %eax      # 0x8db0
leal 0x1(%rax), %ecx
movl %ecx, 0x5823(%rip)      # 0x8db0
cmpl $0x1f, %eax
jge 0x3593
retq
pushq %rax
movq 0x57dd(%rip), %rcx      # 0x8d78
leaq 0xdff(%rip), %rdi       # 0x43a1
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x2170
leaq 0xf9c(%rip), %rdi       # 0x4550
callq 0x2060
pushq $0x1
popq %rdi
callq 0x2160
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: errorType
void errorType(char *m) {       /* 型エラーを.htmlファイルに出力 */
    printSpaces();
    fprintf(fphtml, "<FONT COLOR=%s>%s</FONT>", TYPE_C, m);
    printcToken();
    errorNoCheck();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3ab3
movq 0x57a7(%rip), %rdi      # 0x8d78
leaq 0xdf1(%rip), %rsi       # 0x43c9
leaq 0xe03(%rip), %rdx       # 0x43e2
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2100
callq 0x3b10
popq %rbx
jmp 0x357e
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: errorDelete
void errorDelete() {            /* 今読んだトークンを読み捨てる         */
    int i = (int)cToken.kind;
    printSpaces();
    printed = 1;
    if (i < end_of_KeyWd)       /* 予約語                               */
        fprintf(fphtml, "<FONT COLOR=%s><b>%s</b></FONT>", DELETE_C, KeyWdT[i].word);
    else if (i < end_of_KeySym) /* 演算子か区切り記号                   */
        fprintf(fphtml, "<FONT COLOR=%s>%s</FONT>", DELETE_C, KeyWdT[i].word);
    else if (i==(int)Id)        /* Identfier */
        fprintf(fphtml, "<FONT COLOR=%s>%s</FONT>", DELETE_C, cToken.u.id);
    else if (i==(int)Num)       /* Num */
        fprintf(fphtml, "<FONT COLOR=%s>%d</FONT>", DELETE_C, cToken.u.value);
}

// Assembly:
pushq %rbx
movslq 0x574a(%rip), %rbx      # 0x8d8c
callq 0x3ab3
movb $0x1, 0x573a(%rip)      # 0x8d88
cmpq $0xd, %rbx
jg 0x3673
movq 0x571d(%rip), %rdi      # 0x8d78
shlq $0x4, %rbx
leaq 0x356a(%rip), %rax      # 0x6bd0
movq (%rbx,%rax), %rcx
leaq 0xd79(%rip), %rsi       # 0x43ea
jmp 0x3695
cmpl $0x1e, %ebx
ja 0x36a4
movq 0x56f9(%rip), %rdi      # 0x8d78
shlq $0x4, %rbx
leaq 0x3546(%rip), %rax      # 0x6bd0
movq (%rbx,%rax), %rcx
leaq 0xd34(%rip), %rsi       # 0x43c9
leaq 0xda7(%rip), %rdx       # 0x4443
xorl %eax, %eax
popq %rbx
jmp 0x2100
cmpl $0x21, %ebx
je 0x36cc
cmpl $0x20, %ebx
jne 0x36ef
movq 0x56c3(%rip), %rdi      # 0x8d78
leaq 0xd0d(%rip), %rsi       # 0x43c9
leaq 0xd80(%rip), %rdx       # 0x4443
leaq 0x56c6(%rip), %rcx      # 0x8d90
jmp 0x369c
movq 0x56a5(%rip), %rdi      # 0x8d78
movl 0x56b7(%rip), %ecx      # 0x8d90
leaq 0xd6b(%rip), %rsi       # 0x444b
leaq 0xd5c(%rip), %rdx       # 0x4443
xorl %eax, %eax
popq %rbx
jmp 0x2100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: errorF
void errorF(char *m) {          /* エラーメッセージを出力し、コンパイル終了 */
    errorMessage(m);
    fprintf(fphtml, "fatal errors\n</PRE>\n</BODY>\n</HTML>\n");
    if (errorNo)
        printf("total %d errors\n", errorNo);
    printf("abort compilation\n");
    exit (1);
}

// Assembly:
pushq %rax
callq 0x36f1
movq 0x5654(%rip), %rcx      # 0x8d78
leaq 0xd39(%rip), %rdi       # 0x4464
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x2170
movl 0x5674(%rip), %esi      # 0x8db0
testl %esi, %esi
je 0x374e
leaq 0xd42(%rip), %rdi       # 0x4489
xorl %eax, %eax
callq 0x2090
leaq 0xdfb(%rip), %rdi       # 0x4550
callq 0x2060
pushq $0x1
popq %rdi
callq 0x2160
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: checkGet
Token checkGet(Token t, KeyId k) { /* t.kind == k のチェック            */
    /* t.kind == k なら、次のトークンを読んで返す                       */
    /* t.kind != k ならエラーメッセージを出し、t と k が共に記号、または予約語なら */
    /* t を捨て、次のトークンを読んで返す（ t を k で置き換えたことになる） */
    /* それ以外の場合、k を挿入したことにして、t を返す                 */
    if (t.kind == k)
        return nextToken();
    if ((isKeyWd(k) && isKeyWd(t.kind)) ||
        (isKeySym(k) && isKeySym(t.kind))){
        errorDelete();
        errorInsert(k);
        return nextToken();
    }
    errorInsert(k);
    return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rsp), %eax
cmpl %esi, %eax
je 0x3a47
movl %esi, %r14d
cmpl $0xe, %esi
setb %cl
cmpl $0xe, %eax
setb %dl
testb %dl, %cl
jne 0x3a3a
leal -0x1f(%r14), %ecx
cmpl $-0x11, %ecx
setb %cl
addl $-0x1f, %eax
cmpl $-0x11, %eax
setb %al
orb %cl, %al
je 0x3a3a
leaq 0x20(%rsp), %r15
movl %r14d, %edi
callq 0x3547
movl 0x20(%r15), %eax
movl %eax, 0x20(%rbx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x3a4f
callq 0x363a
movl %r14d, %edi
callq 0x3547
movq %rbx, %rdi
callq 0x3769
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: nextChar
char nextChar() {               /* 次の１文字を返す関数                 */
    char ch;
    if (lineIndex == -1){
        if (fgets(line, MAXLINE, fpi) != NULL){
            /* puts(line); */   /* 通常のエラーメッセージの出力の場合（参考まで） */
            lineIndex = 0;
        } else
            errorF("end of file\n"); /* end of fileならコンパイル終了   */
    }
    if ((ch = line[lineIndex++]) == '\n'){ /* chに次の１文字            */
        lineIndex = -1;         /* それが改行文字なら次の行の入力準備   */
        return '\n';            /* 文字としては改行文字を返す           */
    }
    return ch;
}

// Assembly:
pushq %rax
movl 0x531a(%rip), %ecx      # 0x8d80
cmpl $-0x1, %ecx
jne 0x3a88
movq 0x52fe(%rip), %rdx      # 0x8d70
leaq 0x5757(%rip), %rdi      # 0x91d0
pushq $0x78
popq %rsi
callq 0x20d0
xorl %ecx, %ecx
testq %rax, %rax
je 0x3aa7
movslq %ecx, %rax
incl %ecx
leaq 0x573c(%rip), %rdx      # 0x91d0
movb (%rax,%rdx), %al
cmpb $0xa, %al
pushq $-0x1
popq %rdx
cmovnel %ecx, %edx
movl %edx, 0x52db(%rip)      # 0x8d80
popq %rcx
retq
leaq 0xa75(%rip), %rdi       # 0x4523
callq 0x3717
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: printSpaces
static void printSpaces() {     /* 空白や改行の印字                     */
    while (CR-- > 0)
        fprintf(fphtml, "\n");
    while (spaces-- > 0)
        fprintf(fphtml, " ");
    CR = 0; spaces = 0;
}

// Assembly:
pushq %rbx
pushq $0xa
popq %rbx
movl 0x52fb(%rip), %eax      # 0x8db8
leal -0x1(%rax), %ecx
movl %ecx, 0x52f2(%rip)      # 0x8db8
testl %eax, %eax
jle 0x3ada
movq 0x52a7(%rip), %rsi      # 0x8d78
movl %ebx, %edi
callq 0x20c0
jmp 0x3ab7
pushq $0x20
popq %rbx
movl 0x52d1(%rip), %eax      # 0x8db4
leal -0x1(%rax), %ecx
movl %ecx, 0x52c8(%rip)      # 0x8db4
testl %eax, %eax
jle 0x3b00
movq 0x5281(%rip), %rsi      # 0x8d78
movl %ebx, %edi
callq 0x20c0
jmp 0x3add
andl $0x0, 0x52b1(%rip)      # 0x8db8
andl $0x0, 0x52a6(%rip)      # 0x8db4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tyabu12[P]pl0compiler/getSource.c
// Function: printcToken
void printcToken() {            /* 現在のトークンの印字                 */
    int i = (int)cToken.kind;
    if (printed){
        printed = 0; return;
    }
    printed = 1;
    printSpaces();              /* トークンの前の空白や改行印字         */
    if (i < end_of_KeyWd)       /* 予約語                               */
        fprintf(fphtml, "<b>%s</b>", KeyWdT[i].word);
    else if (i < end_of_KeySym) /* 演算子か区切り記号                   */
        fprintf(fphtml, "%s", KeyWdT[i].word);
    else if (i == (int)Id) {    /* Identfier                            */
        switch (idKind) {
        case varId:
            fprintf(fphtml, "%s", cToken.u.id); return;
        case parId:
            fprintf(fphtml, "<i>%s</i>", cToken.u.id); return;
        case funcId:
            fprintf(fphtml, "<i>%s</i>", cToken.u.id); return;
        case constId:
            fprintf(fphtml, "<tt>%s</tt>", cToken.u.id); return;
        }
    } else if (i == (int)Num)   /* Num                                  */
        fprintf(fphtml, "%d", cToken.u.value);
}

// Assembly:
pushq %rbx
cmpb $0x1, 0x5270(%rip)      # 0x8d88
jne 0x3b23
movb $0x0, 0x5267(%rip)      # 0x8d88
popq %rbx
retq
movslq 0x5262(%rip), %rbx      # 0x8d8c
movb $0x1, 0x5257(%rip)      # 0x8d88
callq 0x3ab3
cmpl $0xd, %ebx
jg 0x3b60
movq 0x5236(%rip), %rdi      # 0x8d78
shlq $0x4, %rbx
leaq 0x3083(%rip), %rax      # 0x6bd0
movq (%rbx,%rax), %rdx
leaq 0x9d8(%rip), %rsi       # 0x4530
xorl %eax, %eax
popq %rbx
jmp 0x2100
cmpl $0x1e, %ebx
ja 0x3b81
movq 0x520c(%rip), %rsi      # 0x8d78
shlq $0x4, %rbx
leaq 0x3059(%rip), %rax      # 0x6bd0
movq (%rbx,%rax), %rdi
popq %rbx
jmp 0x20b0
cmpl $0x21, %ebx
je 0x3bb7
cmpl $0x20, %ebx
jne 0x3b21
movl 0x562f(%rip), %eax      # 0x91c0
cmpq $0x3, %rax
ja 0x3b21
leaq 0x782(%rip), %rcx       # 0x4320
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x51ca(%rip), %rdi      # 0x8d78
leaq 0x985(%rip), %rsi       # 0x453a
jmp 0x3bf1
movq 0x51ba(%rip), %rdi      # 0x8d78
movl 0x51cc(%rip), %edx      # 0x8d90
leaq 0x59d(%rip), %rsi       # 0x4168
xorl %eax, %eax
popq %rbx
jmp 0x2100
movq 0x519e(%rip), %rsi      # 0x8d78
leaq 0x51af(%rip), %rdi      # 0x8d90
jmp 0x3b7b
movq 0x518e(%rip), %rdi      # 0x8d78
leaq 0x953(%rip), %rsi       # 0x4544
leaq 0x5198(%rip), %rdx      # 0x8d90
jmp 0x3b58
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/utils/utils.c
// Function: file_open
FILE*file_open(const char*fname, const char*mode)
{
    if (strcmp(fname, "stdin") == 0) {
        return stdin;
    } else if (strcmp(fname, "stdout") == 0) {
        return stdout;
    } else if (strcmp(fname, "stderr") == 0) {
        return stderr;
    } else {
        FILE*f = fopen(fname, mode);
        if (f == NULL) {
            fprintf(stderr, "Unable to open file \"%s\" with mode \"%s\"",
                    fname, mode);
            exit(EXIT_FAILURE);
        }
        return f;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc97b(%rip), %rsi      # 0xe398
callq 0x10f0
testl %eax, %eax
je 0x1a82
leaq 0xc61c(%rip), %rsi      # 0xe049
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x1a8b
leaq 0xc95e(%rip), %rsi      # 0xe39e
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x1a94
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1170
testq %rax, %rax
jne 0x1a9e
movq 0x1458d(%rip), %rax     # 0x15ff0
movq (%rax), %rdi
leaq 0xc938(%rip), %rsi      # 0xe3a5
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
movq 0x1453f(%rip), %rax     # 0x15fc8
jmp 0x1a9b
movq 0x1452e(%rip), %rax     # 0x15fc0
jmp 0x1a9b
movq 0x14555(%rip), %rax     # 0x15ff0
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/lexer/lexer.c
// Function: lexer_conf_from_file
void lexer_conf_from_file(lexer_type_t lexer, const char*fname)
{
    FILE*f;

    size_t read;
    
    strncpy(lexer->program_name, fname, sizeof(lexer->program_name));

    if (strcmp(fname, "stdin") == 0) {
        f = stdin;
    } else {
        f = file_open(fname, "r");
    }

    fseek(f, 0, SEEK_END);
    lexer->program_len = ftell(f);
    fseek(f, 0, SEEK_SET);

    SAFE_MALLOC(lexer->program, lexer->program_len + 1);

    read = fread(lexer->program, sizeof(char), lexer->program_len, f);
    if (read != lexer->program_len) {
        fprintf(stderr, "Unable to read input file \"%s\"", fname);
        exit(EXIT_FAILURE);
    }
    lexer->program[lexer->program_len] = '\0';

    lexer->cur.program = lexer->program;
    lexer->cur.program_len = lexer->program_len;

    fclose(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x1040
leaq 0xc887(%rip), %rsi      # 0xe398
movq %rbx, %rdi
callq 0x10f0
testl %eax, %eax
je 0x1b31
leaq 0xcbad(%rip), %rsi      # 0xe6d1
movq %rbx, %rdi
callq 0x1a0c
movq %rax, %r15
jmp 0x1b3b
movq 0x14490(%rip), %rax     # 0x15fc8
movq (%rax), %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1150
movq %r15, %rdi
callq 0x1110
movq %rax, 0x8(%r14)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1150
movq 0x8(%r14), %r13
leaq 0x1(%r13), %r12
movq %r12, %rdi
callq 0x1130
movq %rax, (%r14)
testq %rax, %rax
je 0x1bb3
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x1060
cmpq 0x8(%r14), %rax
jne 0x1bda
movq (%r14), %rcx
movb $0x0, (%rcx,%rax)
movups (%r14), %xmm0
movups %xmm0, 0x110(%r14)
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1070
movq 0x14436(%rip), %rax     # 0x15ff0
movq (%rax), %rdi
leaq 0xc9fa(%rip), %rsi      # 0xe5be
leaq 0xc9e1(%rip), %rdx      # 0xe5ac
pushq $0x44
popq %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x1100
jmp 0x1bf5
movq 0x1440f(%rip), %rax     # 0x15ff0
movq (%rax), %rdi
leaq 0xc9f7(%rip), %rsi      # 0xe5e2
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/lexer/lexer.c
// Function: lexer_conf_from_buf
void lexer_conf_from_buf(lexer_type_t lexer, const char*text, const char*program_name)
{
    strncpy(lexer->program_name, program_name, sizeof(lexer->program_name));

    lexer->program_len = strlen(text);

    SAFE_MALLOC(lexer->program, lexer->program_len + 1);

    strncpy(lexer->program, text, lexer->program_len + 1);
    lexer->program[lexer->program_len] = '\0';

    lexer->cur.program = lexer->program;
    lexer->cur.program_len = lexer->program_len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rdi
movl $0x100, %edx            # imm = 0x100
movq %rax, %rsi
callq 0x1040
movq %r14, %rdi
callq 0x1080
movq %rax, %r12
movq %rax, 0x8(%rbx)
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x1130
movq %rax, (%rbx)
testq %rax, %rax
je 0x1c72
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1040
movb $0x0, (%r13,%r12)
movq %r13, 0x110(%rbx)
movq %r12, 0x118(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x14377(%rip), %rax     # 0x15ff0
movq (%rax), %rdi
leaq 0xc93b(%rip), %rsi      # 0xe5be
leaq 0xc922(%rip), %rdx      # 0xe5ac
pushq $0x59
popq %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180