LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/main.c
// Function: generate_hdd_individuals
void generate_hdd_individuals() {
    u8 ata_k1[0x20], ata_k2[0x20], edec_k1[0x20], edec_k2[0x20];

    //fetching root_key
    eid_root_key = _read_buffer((s8*) "data/eid_root_key", NULL);

    //Generate keys.
    generate_ata_keys(eid_root_key, eid_root_key + 0x20, ata_k1, ata_k2);
    generate_encdec_keys(eid_root_key, eid_root_key + 0x20, edec_k1, edec_k2);

    _hexdump(stdout, "ATA-DATA-KEY    ", 0, ata_k1, 0x20, 0);
    _hexdump(stdout, "ATA-TWEAK-KEY   ", 0, ata_k2, 0x20, 0);
    _hexdump(stdout, "ENCDEC-DATA-KEY ", 0, edec_k1, 0x20, 0);
    _hexdump(stdout, "ENCDEC-TWEAK-KEY", 0, edec_k2, 0x20, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x5b66(%rip), %rdi      # 0x10eb8
xorl %eax, %eax
movl %eax, %esi
callq 0x9960
movq %rax, %rcx
leaq 0x925b(%rip), %rax      # 0x145c0
movq %rcx, (%rax)
leaq 0x9251(%rip), %rax      # 0x145c0
movq (%rax), %rdi
leaq 0x9247(%rip), %rax      # 0x145c0
movq (%rax), %rsi
addq $0x20, %rsi
leaq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x9450
leaq 0x922c(%rip), %rax      # 0x145c0
movq (%rax), %rdi
leaq 0x9222(%rip), %rax      # 0x145c0
movq (%rax), %rsi
addq $0x20, %rsi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x9520
movq 0x8c27(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x20(%rbp), %rcx
leaq 0x5b03(%rip), %rsi      # 0x10eca
xorl %r9d, %r9d
movl $0x20, %r8d
movl %r9d, %edx
callq 0x9830
movq 0x8c01(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x40(%rbp), %rcx
leaq 0x5aee(%rip), %rsi      # 0x10edb
xorl %r9d, %r9d
movl $0x20, %r8d
movl %r9d, %edx
callq 0x9830
movq 0x8bdb(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x60(%rbp), %rcx
leaq 0x5ad9(%rip), %rsi      # 0x10eec
xorl %r9d, %r9d
movl $0x20, %r8d
movl %r9d, %edx
callq 0x9830
movq 0x8bb5(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x80(%rbp), %rcx
leaq 0x5ac4(%rip), %rsi      # 0x10efd
xorl %r9d, %r9d
movl $0x20, %r8d
movl %r9d, %edx
callq 0x9830
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/main.c
// Function: decrypt_eid
void decrypt_eid() {
    //fetching root_key
    eid_root_key = _read_buffer((s8*) "data/eid_root_key", NULL);

    //unpacking eid
    eid_unpack((s8*) "eid/eid");

    //decrypting
    eid0_decrypt((s8*) "eid/eid0", (s8*) "eid/eid0decrypted");
    eid1_decrypt((s8*) "eid/eid1", (s8*) "eid/eid1decrypted.bin");
    eid2_generate_block((s8*) "eid/eid2", EID2_BLOCKTYPE_P, (s8*) "eid/eid2pblock.bin");
    eid2_generate_block((s8*) "eid/eid2", EID2_BLOCKTYPE_S, (s8*) "eid/eid2sblock.bin");
    u8* pblock = _read_buffer("eid/eid2pblock.bin", NULL);
    eid2_decrypt_block(pblock, 0x80);
    memcpy(pblock, pblock + 0x10, 0x60);
    _write_buffer((s8*) "eid/pblockdec.bin", pblock, 0x60);
    u8* sblock = _read_buffer("eid/eid2sblock.bin", NULL);
    eid2_decrypt_block(sblock, 0x690);
    memcpy(sblock, sblock + 0x10, 0x670);
    _write_buffer((s8*) "eid/sblockdec.bin", sblock, 0x670);
    eid3_decrypt((s8*) "eid/eid3", (s8*) "eid/eid3decrypted.bin");
    eid4_decrypt((s8*) "eid/eid4", (s8*) "eid/eid4decrypted.bin");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5a49(%rip), %rdi      # 0x10eb8
xorl %eax, %eax
movl %eax, %esi
callq 0x9960
movq %rax, %rcx
leaq 0x913e(%rip), %rax      # 0x145c0
movq %rcx, (%rax)
leaq 0x5a82(%rip), %rdi      # 0x10f0e
callq 0x9bc0
leaq 0x5a7e(%rip), %rdi      # 0x10f16
leaq 0x5a80(%rip), %rsi      # 0x10f1f
callq 0xa480
leaq 0x5a86(%rip), %rdi      # 0x10f31
leaq 0x5a88(%rip), %rsi      # 0x10f3a
callq 0xac50
leaq 0x5a92(%rip), %rdi      # 0x10f50
movl $0x1, %esi
leaq 0x5a8f(%rip), %rdx      # 0x10f59
callq 0xadd0
leaq 0x5a7a(%rip), %rdi      # 0x10f50
movl $0x2, %esi
leaq 0x5a8a(%rip), %rdx      # 0x10f6c
callq 0xadd0
leaq 0x5a6b(%rip), %rdi      # 0x10f59
xorl %eax, %eax
movl %eax, %esi
callq 0x9960
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x80, %esi
callq 0xae80
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x60, %edx
callq 0x10e0
movq -0x8(%rbp), %rsi
leaq 0x5a55(%rip), %rdi      # 0x10f7f
movl $0x60, %edx
callq 0x9a20
leaq 0x5a31(%rip), %rdi      # 0x10f6c
xorl %eax, %eax
movl %eax, %esi
callq 0x9960
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x690, %esi            # imm = 0x690
callq 0xae80
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl $0x670, %edx            # imm = 0x670
callq 0x10e0
movq -0x10(%rbp), %rsi
leaq 0x5a1a(%rip), %rdi      # 0x10f91
movl $0x670, %edx            # imm = 0x670
callq 0x9a20
leaq 0x5a1b(%rip), %rdi      # 0x10fa3
leaq 0x5a1d(%rip), %rsi      # 0x10fac
callq 0xb1a0
leaq 0x5a27(%rip), %rdi      # 0x10fc2
leaq 0x5a29(%rip), %rsi      # 0x10fcb
callq 0xb2e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/main.c
// Function: hexDump
void hexDump(const void *data, size_t size) {
  size_t i;
  for (i = 0; i < size; i++) {
    printf("%02hhX%c", ((char *)data)[i], (i + 1) % 16 ? ' ' : '\n');
  }
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xb6d7
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %esi
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
andq $0xf, %rcx
movl $0xa, %edx
movl $0x20, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edx
leaq 0x59c7(%rip), %rdi      # 0x11089
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb688
leaq 0x55dd(%rip), %rdi      # 0x10cbb
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/main.c
// Function: gen_vtrm
void gen_vtrm(){
	//fetching root_key
    eid_root_key = _read_buffer((s8*) "data/eid_root_key", NULL);
	
	aes_context aes_ctxt;
    u8 iv[0x10];
	u8 indiv[0x40];
	u8 key[0x10];
	u8 block_key[0x10];
	u8 block_iv[0x10]={0x0};
	
	
	indiv_gen(eid1_indiv_seed, NULL, NULL, NULL, indiv);
	
    //Generate VTRM Block Key.
	memcpy(key, indiv + 0x20, 0x10);
    aes_setkey_enc(&aes_ctxt, key, KEY_BITS(0x10));
    memcpy(iv, indiv + 0x10, 0x10);
    aes_crypt_cbc(&aes_ctxt, AES_ENCRYPT, 0x10, iv, keyseed_for_srk2, block_key);
	
	_hexdump(stdout, "Block Key:    ", 0, block_key, 0x10, 0);
	_hexdump(stdout, "Block Iv:    ", 0, block_iv, 0x10, 0);
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
leaq 0x5396(%rip), %rdi      # 0x10eb8
xorl %eax, %eax
movl %eax, %esi
callq 0x9960
movq %rax, %rcx
leaq 0x8a8b(%rip), %rax      # 0x145c0
movq %rcx, (%rax)
leaq -0x2b0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x280(%rbp), %r8
leaq 0x8847(%rip), %rdi      # 0x143a0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x9a80
movq -0x260(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x258(%rbp), %rax
movq %rax, -0x288(%rbp)
leaq -0x290(%rbp), %rsi
leaq -0x230(%rbp), %rdi
movl $0x80, %edx
callq 0x1250
movq -0x270(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x268(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x240(%rbp), %rcx
leaq -0x2a0(%rbp), %r9
leaq -0x230(%rbp), %rdi
movl $0x1, %esi
movl $0x10, %edx
leaq 0x84e2(%rip), %r8       # 0x140c0
callq 0x2eb0
movq 0x83f6(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x2a0(%rbp), %rcx
leaq 0x550e(%rip), %rsi      # 0x11109
xorl %r9d, %r9d
movl $0x10, %r8d
movl %r9d, %edx
callq 0x9830
movq 0x83cd(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x2b0(%rbp), %rcx
leaq 0x54f4(%rip), %rsi      # 0x11118
xorl %r9d, %r9d
movl $0x10, %r8d
movl %r9d, %edx
callq 0x9830
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/main.c
// Function: gen_backup
void gen_backup(){
	//fetching root_key
    eid_root_key = _read_buffer((s8*) "data/eid_root_key", NULL);
	
	aes_context aes_ctxt;
    u8 iv[0x10];
	u8 indiv[0x40];
	u8 key[0x10];
	u8 backup_key[0x10];
	
	
	indiv_gen(eid1_indiv_seed, NULL, NULL, NULL, indiv);
	
    //Generate Backup Key.
	memcpy(key, indiv + 0x20, 0x10);
    aes_setkey_enc(&aes_ctxt, key, KEY_BITS(0x10));
    memcpy(iv, indiv + 0x10, 0x10);
    aes_crypt_cbc(&aes_ctxt, AES_ENCRYPT, 0x10, iv, seed_for_backup, backup_key);
	memcpy(iv, indiv + 0x10, 0x10);
	
	_hexdump(stdout, "Backup Key:    ", 0, backup_key, 0x10, 0);
	_hexdump(stdout, "Backup Iv:    ", 0, iv, 0x10, 0);
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
leaq 0x5266(%rip), %rdi      # 0x10eb8
xorl %eax, %eax
movl %eax, %esi
callq 0x9960
movq %rax, %rcx
leaq 0x895b(%rip), %rax      # 0x145c0
movq %rcx, (%rax)
leaq -0x280(%rbp), %r8
leaq 0x872a(%rip), %rdi      # 0x143a0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x9a80
movq -0x260(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x258(%rbp), %rax
movq %rax, -0x288(%rbp)
leaq -0x290(%rbp), %rsi
leaq -0x230(%rbp), %rdi
movl $0x80, %edx
callq 0x1250
movq -0x270(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x268(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x240(%rbp), %rcx
leaq -0x2a0(%rbp), %r9
leaq -0x230(%rbp), %rdi
movl $0x1, %esi
movl $0x10, %edx
leaq 0x83d5(%rip), %r8       # 0x140d0
callq 0x2eb0
movq -0x270(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x268(%rbp), %rax
movq %rax, -0x238(%rbp)
movq 0x82bd(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x2a0(%rbp), %rcx
leaq 0x53f2(%rip), %rsi      # 0x11126
xorl %r9d, %r9d
movl $0x10, %r8d
movl %r9d, %edx
callq 0x9830
movq 0x8294(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq -0x240(%rbp), %rcx
leaq 0x53d9(%rip), %rsi      # 0x11136
xorl %r9d, %r9d
movl $0x10, %r8d
movl %r9d, %edx
callq 0x9830
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/main.c
// Function: main
int main() {
    int i;
    printf("Select an option\n1-Decrypt eEID(missing eid5)\n2-Encrypt All eEID0 sections \n3-Generate Syscon AUTH seeds(Acording to wiki)\n4-Generate HDD Keys\n5-Generate VTRM Keys\n6-Generate Backup Keys\n0-Exit\n");
    scanf("%d", &i);
    switch (i) {
        case 1:
            decrypt_eid();
			getchar();
            break;
        case 2:
			encrypt_eid0_section_0();
			encrypt_eid0_section_6();
            encrypt_eid0_section_A();
			//getchar();
            break;
        case 3:
            syscon_auth();
			getchar();
            break;
        case 4:
            generate_hdd_individuals();
			getchar();
            break;
		case 5:
            gen_vtrm();
			getchar();
            break;
		case 6:
            gen_backup();
			getchar();
        case 0:
            break;
        default:
            printf("Incorrect Option Selected! Try Again.");
            break;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x53af(%rip), %rdi      # 0x11145
xorl %eax, %eax
movb %al, -0x11(%rbp)
callq 0x1080
movb -0x11(%rbp), %al
leaq 0x4e96(%rip), %rdi      # 0x10c40
leaq -0x8(%rbp), %rsi
callq 0x1120
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x6, %rax
ja 0xbe21
movq -0x10(%rbp), %rax
leaq 0x50d1(%rip), %rcx      # 0x10e9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0xb460
callq 0x10b0
jmp 0xbe2f
callq 0xb5b0
callq 0xb5f0
callq 0xb630
jmp 0xbe2f
callq 0xb6f0
callq 0x10b0
jmp 0xbe2f
callq 0xb340
callq 0x10b0
jmp 0xbe2f
callq 0xbb10
callq 0x10b0
jmp 0xbe2f
callq 0xbc40
callq 0x10b0
jmp 0xbe2f
leaq 0x53e0(%rip), %rdi      # 0x11208
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: GetDisplayRefreshRate
int GetDisplayRefreshRate(SDL_DisplayMode gDisplayMode) {
    int result = gDisplayMode.refresh_rate;

    if (result == 0) {
        return DEFAULT_REFRESH_RATE;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x24bd
movl $0x3c, -0x4(%rbp)
jmp 0x24c3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: InitSDL
int InitSDL(void) {
    SDL_Init(SDL_INIT_VIDEO);

    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
                        SDL_GL_CONTEXT_PROFILE_CORE);

    if (SDL_GetDesktopDisplayMode(0, &gDisplayMode) != 0) {
        return -1;
    }

    gWindow = SDL_CreateWindow(
        WINDOW_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, gWidth,
        gHeight, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    if (gWindow == NULL) {
        return -1;
    }
    LogInfo("window created with size %dx%d", gWidth, gHeight);

    gContext = SDL_GL_CreateContext(gWindow);
    if (gContext == NULL) {
        return -1;
    }

    GLenum glewError = glewInit();
    if (glewError != GLEW_OK) {
        LogError("error initializing GLEW! %s", glewGetErrorString(glewError));
    }

    if (SDL_GL_SetSwapInterval(1) < 0) {
        LogInfo("warning: unable to set vsync. %s", SDL_GetError());
    }

    if (gFullscreen) {
        SDL_SetWindowFullscreen(gWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);
    }

    SDL_ShowCursor(SDL_DISABLE);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x2260
movl $0x11, %edi
movl $0x3, %esi
callq 0x21e0
movl $0x12, %edi
movl $0x3, %esi
callq 0x21e0
movl $0x15, %edi
movl $0x1, %esi
callq 0x21e0
xorl %edi, %edi
leaq 0x3c80(%rip), %rsi      # 0x6198
callq 0x2150
cmpl $0x0, %eax
je 0x252e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x262b
movl 0x3c28(%rip), %ecx      # 0x615c
movl 0x3c25(%rip), %r8d      # 0x6160
leaq 0x1b06(%rip), %rdi      # 0x4048
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x26, %r9d
movl %edx, %esi
callq 0x2100
movq %rax, 0x3c15(%rip)      # 0x6170
cmpq $0x0, 0x3c0d(%rip)      # 0x6170
jne 0x2571
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x262b
movl 0x3be5(%rip), %edx      # 0x615c
movl 0x3be3(%rip), %ecx      # 0x6160
xorl %edi, %edi
leaq 0x1ad0(%rip), %rsi      # 0x4056
movb $0x0, %al
callq 0x21b0
movq 0x3bdc(%rip), %rdi      # 0x6170
callq 0x2180
movq %rax, 0x3bd8(%rip)      # 0x6178
cmpq $0x0, 0x3bd0(%rip)      # 0x6178
jne 0x25b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x262b
callq 0x2230
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x25dc
movl -0x8(%rbp), %edi
callq 0x20b0
movq %rax, %rdx
xorl %edi, %edi
leaq 0x1aa0(%rip), %rsi      # 0x4075
movb $0x0, %al
callq 0x2250
movl $0x1, %edi
callq 0x2140
cmpl $0x0, %eax
jge 0x2603
callq 0x21f0
movq %rax, %rdx
xorl %edi, %edi
leaq 0x1a95(%rip), %rsi      # 0x4091
movb $0x0, %al
callq 0x21b0
cmpl $0x0, 0x3b86(%rip)      # 0x6190
je 0x261d
movq 0x3b5d(%rip), %rdi      # 0x6170
movl $0x1001, %esi           # imm = 0x1001
callq 0x2040
xorl %edi, %edi
callq 0x2190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: LogShaderError
void LogShaderError(GLuint shader) {
    if (glIsShader(shader)) {
        int infoLogLength = 0;
        int maxLength = infoLogLength;

        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);

        char *infoLog = malloc(maxLength * sizeof(*infoLog));
        if (infoLog == NULL) {
            LogError("failed to malloc error log for gl shader %d of size %d",
                     shader, maxLength);
        }

        glGetShaderInfoLog(shader, maxLength, &infoLogLength, infoLog);
        if (infoLogLength > 0) {
            LogError("failed to compile shader %d:\n%s", shader, infoLog);
        }

        free(infoLog);
    } else {
        LogError("name shader %d is not a shader", shader);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x390e(%rip), %rax      # 0x5f60
movq (%rax), %rax
movl -0x4(%rbp), %edi
callq *%rax
cmpb $0x0, %al
je 0x26f7
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x38d2(%rip), %rax      # 0x5f48
movq (%rax), %rax
movl -0x4(%rbp), %edi
movl $0x8b84, %esi           # imm = 0x8B84
leaq -0xc(%rbp), %rdx
callq *%rax
movslq -0xc(%rbp), %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x26b5
movl -0x4(%rbp), %edx
movl -0xc(%rbp), %ecx
xorl %edi, %edi
leaq 0x1a04(%rip), %rsi      # 0x40b2
movb $0x0, %al
callq 0x2250
movq 0x3854(%rip), %rax      # 0x5f10
movq (%rax), %rax
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rcx
leaq -0x8(%rbp), %rdx
callq *%rax
cmpl $0x0, -0x8(%rbp)
jle 0x26ec
movl -0x4(%rbp), %edx
movq -0x18(%rbp), %rcx
xorl %edi, %edi
leaq 0x1a04(%rip), %rsi      # 0x40e9
movb $0x0, %al
callq 0x2250
movq -0x18(%rbp), %rdi
callq 0x2070
jmp 0x270a
movl -0x4(%rbp), %edx
xorl %edi, %edi
leaq 0x1a06(%rip), %rsi      # 0x4109
movb $0x0, %al
callq 0x2250
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: LogProgramError
void LogProgramError(GLuint program) {
    if (glIsProgram(program)) {
        int infoLogLength = 0;
        int maxLength = infoLogLength;

        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);

        char *infoLog = malloc(maxLength * sizeof(*infoLog));
        if (infoLog == NULL) {
            LogError("failed to malloc error log for gl program %d of size %d",
                     program, maxLength);
        }

        glGetProgramInfoLog(program, maxLength, &infoLogLength, infoLog);
        if (infoLogLength > 0) {
            LogError("failed to link program %d:\n%s", program, infoLog);
        }

        free(infoLog);
    } else {
        LogError("name program %d is not a program", program);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x382e(%rip), %rax      # 0x5f50
movq (%rax), %rax
movl -0x4(%rbp), %edi
callq *%rax
cmpb $0x0, %al
je 0x27c7
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x37d2(%rip), %rax      # 0x5f18
movq (%rax), %rax
movl -0x4(%rbp), %edi
movl $0x8b84, %esi           # imm = 0x8B84
leaq -0xc(%rbp), %rdx
callq *%rax
movslq -0xc(%rbp), %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2785
movl -0x4(%rbp), %edx
movl -0xc(%rbp), %ecx
xorl %edi, %edi
leaq 0x19aa(%rip), %rsi      # 0x4128
movb $0x0, %al
callq 0x2250
movq 0x3804(%rip), %rax      # 0x5f90
movq (%rax), %rax
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rcx
leaq -0x8(%rbp), %rdx
callq *%rax
cmpl $0x0, -0x8(%rbp)
jle 0x27bc
movl -0x4(%rbp), %edx
movq -0x18(%rbp), %rcx
xorl %edi, %edi
leaq 0x19ab(%rip), %rsi      # 0x4160
movb $0x0, %al
callq 0x2250
movq -0x18(%rbp), %rdi
callq 0x2070
jmp 0x27da
movl -0x4(%rbp), %edx
xorl %edi, %edi
leaq 0x19ab(%rip), %rsi      # 0x417e
movb $0x0, %al
callq 0x2250
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: ReadFile
char *ReadFile(const char *filepath) {
    FILE *file = fopen(filepath, "rb");
    if (file == NULL) {
        return NULL;
    }

    fseek(file, 0, SEEK_END);
    long fileSize = ftell(file);
    rewind(file);

    char *buffer = malloc((fileSize + 1) * sizeof(*buffer));
    if (buffer == NULL) {
        return NULL;
    }

    size_t result = fread(buffer, 1, fileSize, file);
    if ((long)result != fileSize) {
        return NULL;
    }

    fclose(file);

    buffer[fileSize] = 0;
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19a8(%rip), %rsi      # 0x419f
callq 0x2240
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2814
movq $0x0, -0x8(%rbp)
jmp 0x28ad
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2220
movq -0x18(%rbp), %rdi
callq 0x20a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2270
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x21c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2862
movq $0x0, -0x8(%rbp)
jmp 0x28ad
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2130
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x2890
movq $0x0, -0x8(%rbp)
jmp 0x28ad
movq -0x18(%rbp), %rdi
callq 0x2110
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: compileShader
GLboolean compileShader(GLenum type, const GLchar *source[],
                        GLuint *outShader) {
    GLuint shader = glCreateShader(type);
    glShaderSource(shader, 1, source, NULL);
    glCompileShader(shader);

    *outShader = shader;

    GLint shaderCompiled = GL_FALSE;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &shaderCompiled);
    if (shaderCompiled != GL_TRUE) {
        return GL_FALSE;
    }

    return GL_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x36fe(%rip), %rax      # 0x5fd8
movq (%rax), %rax
movl -0x8(%rbp), %edi
callq *%rax
movl %eax, -0x1c(%rbp)
movq 0x36cc(%rip), %rax      # 0x5fb8
movq (%rax), %rax
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
xorl %ecx, %ecx
callq *%rax
movq 0x3672(%rip), %rax      # 0x5f78
movq (%rax), %rax
movl -0x1c(%rbp), %edi
callq *%rax
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x20(%rbp)
movq 0x3623(%rip), %rax      # 0x5f48
movq (%rax), %rax
movl -0x1c(%rbp), %edi
movl $0x8b81, %esi           # imm = 0x8B81
leaq -0x20(%rbp), %rdx
callq *%rax
cmpl $0x1, -0x20(%rbp)
je 0x2942
movb $0x0, -0x1(%rbp)
jmp 0x2946
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: DrawFrame
void DrawFrame(double elapsedTimeSecs) {
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(gProgramId);

    glUniform1f(gUniformScaleLocation, 20.0f);
    glUniform2i(gUniformResolutionLocation, gWidth, gHeight);
    glUniform1f(gUniformTimeLocation, elapsedTimeSecs);

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movl $0x4000, %edi           # imm = 0x4000
callq 0x2160
movq 0x32c2(%rip), %rax      # 0x5ff0
movq (%rax), %rax
movl 0x3449(%rip), %edi      # 0x6180
callq *%rax
movq 0x3240(%rip), %rax      # 0x5f80
movq (%rax), %rax
movl 0x340f(%rip), %edi      # 0x6158
movss 0x12f3(%rip), %xmm0     # 0x4044
callq *%rax
movq 0x31a6(%rip), %rax      # 0x5f00
movq (%rax), %rax
movl 0x33f1(%rip), %edi      # 0x6154
movl 0x33f3(%rip), %esi      # 0x615c
movl 0x33f1(%rip), %edx      # 0x6160
callq *%rax
movq 0x3208(%rip), %rax      # 0x5f80
movq (%rax), %rax
movl 0x33cf(%rip), %edi      # 0x6150
movsd -0x8(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
callq *%rax
movl $0x4, %edi
movl $0x6, %esi
movl $0x1405, %edx           # imm = 0x1405
xorl %eax, %eax
movl %eax, %ecx
callq 0x2090
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/gl_rgb_plasma.c
// Function: DestroyGL
void DestroyGL(void) {
    glDeleteBuffers(1, &gEBO);
    glDeleteBuffers(1, &gVBO);
    glDeleteVertexArrays(1, &gVAO);
    glDeleteProgram(gProgramId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %edi
leaq 0x33cc(%rip), %rsi      # 0x618c
movq 0x31a1(%rip), %rax      # 0x5f68
callq *(%rax)
movl $0x1, %edi
leaq 0x33b3(%rip), %rsi      # 0x6188
movq 0x318c(%rip), %rax      # 0x5f68
callq *(%rax)
movl $0x1, %edi
leaq 0x339a(%rip), %rsi      # 0x6184
movq 0x31bf(%rip), %rax      # 0x5fb0
callq *(%rax)
movq 0x318e(%rip), %rax      # 0x5f88
movq (%rax), %rax
movl 0x337d(%rip), %edi      # 0x6180
callq *%rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_08/print.c
// Function: main
int main(int argc, char *argv[])
{
  if (!parse_arg_list(argc, argv))
  {
    exit(EXIT_FAILURE);
  }

  while (--argc > 0)
  {
    print_file(*++argv);

    if (argc != 1)
    {
      putc('\n', stdout);
    }
  }

  exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1210
cmpl $0x0, %eax
jne 0x11c1
movl $0x1, %edi
callq 0x1080
jmp 0x11c3
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x1205
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x1270
cmpl $0x1, -0x8(%rbp)
je 0x1203
movq 0x2de2(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1050
jmp 0x11c3
xorl %edi, %edi
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_08/print.c
// Function: parse_arg_list
boolean parse_arg_list(int argc, char *argv[])
{
  const char *program_name = argv[0];

  if (argc < 2)
  {
    fprintf(stderr, "Usage: %s [FILE]...\n", program_name);
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x1255
movq 0x2dc1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xdbf(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1060
movl $0x0, -0x4(%rbp)
jmp 0x125c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_08/print.c
// Function: print_file
void print_file(char *file_name)
{
  FILE *file_p;
  if ((file_p = fopen(file_name, "r")) == NULL)
  {
    fprintf(stderr, "%s: can't open %s.\n", program_name, file_name);
    exit(EXIT_FAILURE);
  }

  size_t line_number = 1;
  char line[MAX_LINE_LEN];
  while (fgets(line, MAX_LINE_LEN, file_p) != NULL)
  {
    if ((line_number - 1) % LINES_PER_PAGE == 0)
    {
      printf("[%s]: page %zu\n", file_name, line_number / LINES_PER_PAGE + 1);
    }

    printf("%zu: %s", line_number, line);
    ++line_number;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd8f(%rip), %rsi       # 0x2019
callq 0x1070
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x12c6
movq 0x2d58(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2db6(%rip), %rdx      # 0x4060
movq -0x8(%rbp), %rcx
leaq 0xd66(%rip), %rsi       # 0x201b
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x1080
movq $0x1, -0x18(%rbp)
leaq -0x400(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1040
cmpq $0x0, %rax
je 0x1352
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x1328
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rdx
addq $0x1, %rdx
leaq 0xd0e(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
movq -0x18(%rbp), %rsi
leaq -0x400(%rbp), %rdx
leaq 0xd05(%rip), %rdi       # 0x203f
movb $0x0, %al
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12ce
addq $0x400, %rsp            # imm = 0x400
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/fallocate2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);
	unsigned long place = 0;
	assert(fd >= 0);
	unlink(tmpfile);

	while (1) {
		int ret = fallocate(fd, 0, place, BUFLEN);
		if (errno != EINTR)
			assert(ret == 0);
		place += BUFLEN;
		if (place >= FILESIZE) {
			ret = ftruncate(fd, 0);
			assert(ret == 0);
			place = 0;
		}
		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1299(%rip), %rax      # 0x32d0
movq %rax, -0x30(%rbp)
movq 0x1296(%rip), %rax      # 0x32d8
movq %rax, -0x28(%rbp)
movq 0x1293(%rip), %rax      # 0x32e0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11e0
movl %eax, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x206d
jmp 0x208c
leaq 0x11fc(%rip), %rdi      # 0x3270
leaq 0x11fd(%rip), %rsi      # 0x3278
movl $0x14, %edx
leaq 0x1204(%rip), %rcx      # 0x328b
callq 0x1120
leaq -0x30(%rbp), %rdi
callq 0x1080
movl -0x34(%rbp), %edi
movq -0x40(%rbp), %rdx
xorl %esi, %esi
movl $0x2000, %ecx           # imm = 0x2000
callq 0x1160
movl %eax, -0x44(%rbp)
callq 0x1070
cmpl $0x4, (%rax)
je 0x20de
cmpl $0x0, -0x44(%rbp)
jne 0x20bd
jmp 0x20dc
leaq 0x11fa(%rip), %rdi      # 0x32be
leaq 0x11ad(%rip), %rsi      # 0x3278
movl $0x1a, %edx
leaq 0x11b4(%rip), %rcx      # 0x328b
callq 0x1120
jmp 0x20de
movq -0x40(%rbp), %rax
addq $0x2000, %rax           # imm = 0x2000
movq %rax, -0x40(%rbp)
cmpq $0x100000, -0x40(%rbp)  # imm = 0x100000
jb 0x2134
movl -0x34(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1110
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x210d
jmp 0x212c
leaq 0x11aa(%rip), %rdi      # 0x32be
leaq 0x115d(%rip), %rsi      # 0x3278
movl $0x1e, %edx
leaq 0x1164(%rip), %rcx      # 0x328b
callq 0x1120
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2095
// File: /workspace/github_c_makefile_star2_O0/hermantb[P]fast_convert/fast_convert.c
// Function: fast_sint32
unsigned int
fast_sint32 (int32_t v, char *str)
{
  unsigned int is_signed = v < 0;
  unsigned int len;
  char *p;
  uint32_t j = (uint32_t) v;

  if (is_signed) {
    j = ~j + 1;
    *str++ = '-';
  }
  len = log10_32 (j);
  p = str + len;
  *p = '\0';
  while (j >= 1000) {
    uint32_t d = j / 1000;

    p = (char *) memcpy (p - 3, &num3[(j - d * 1000) * 3], 3);
    j = d;
  }
  if (j >= 100) {
    memcpy (p - 3, &num3[j * 3], 3);
  }
  else if (j >= 10) {
    memcpy (p - 2, &num3[j * 3] + 1, 2);
  }
  else {
    memcpy (p - 1, &num3[j * 3] + 2, 1);
  }
  return len + is_signed;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x0, 0x24(%rsp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x12cf
movl 0x4(%rsp), %eax
xorl $-0x1, %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb $0x2d, (%rax)
movl 0x4(%rsp), %edi
callq 0x13e0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x10(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
cmpl $0x3e8, 0x4(%rsp)       # imm = 0x3E8
jb 0x1353
movl 0x4(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, (%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, %rax
addq $-0x3, %rax
movl 0x4(%rsp), %edx
imull $0x3e8, (%rsp), %esi    # imm = 0x3E8
subl %esi, %edx
imull $0x3, %edx, %edx
movl %edx, %edx
movl %edx, %esi
leaq 0x10f0a(%rip), %rdx     # 0x12240
movw (%rdx,%rsi), %di
movw %di, -0x3(%rcx)
movb 0x2(%rdx,%rsi), %dl
movb %dl, -0x1(%rcx)
movq %rax, 0x8(%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x12f5
cmpl $0x64, 0x4(%rsp)
jb 0x1380
movq 0x8(%rsp), %rax
imull $0x3, 0x4(%rsp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x10ed1(%rip), %rcx     # 0x12240
movw (%rcx,%rdx), %si
movw %si, -0x3(%rax)
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x13c5
cmpl $0xa, 0x4(%rsp)
jb 0x13a7
movq 0x8(%rsp), %rax
imull $0x3, 0x4(%rsp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x10ea4(%rip), %rcx     # 0x12240
movw 0x1(%rcx,%rdx), %cx
movw %cx, -0x2(%rax)
jmp 0x13c3
movq 0x8(%rsp), %rax
imull $0x3, 0x4(%rsp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x10e84(%rip), %rcx     # 0x12240
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x13c5
movl 0x10(%rsp), %eax
addl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hermantb[P]fast_convert/fast_convert.c
// Function: log10_32
static unsigned int
log10_32 (uint32_t v)
{
  static const unsigned int tab32[32] = {
    1, 1, 1, 1, 1, 1, 2, 2, 2, 3,
    3, 3, 3, 4, 4, 4, 5, 5, 5, 6,
    6, 6, 6, 7, 7, 7, 8, 8, 8, 9,
    9, 9
  };
  unsigned int n;

  if (v == 0) {
    return 1;
  }
#ifdef __GNUC__
  n = tab32[31 ^ __builtin_clz (v)];
#else
  n = tab32[31 ^ calc_clz32 (v)];
#endif
  return n + (v >= ipowers32[n]);
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x13f5
movl $0x1, -0x4(%rsp)
jmp 0x143a
movl -0x8(%rsp), %eax
bsrl %eax, %eax
xorl $0x1f, %eax
xorl $0x1f, %eax
movslq %eax, %rcx
leaq 0x1eb14(%rip), %rax     # 0x1ff20
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl -0x8(%rsp), %ecx
movl -0xc(%rsp), %edx
movl %edx, %esi
leaq 0x136e8(%rip), %rdx     # 0x14b10
cmpl (%rdx,%rsi,4), %ecx
setae %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hermantb[P]fast_convert/fast_convert.c
// Function: fast_sint64
unsigned int
fast_sint64 (int64_t v, char *str)
{
  unsigned int is_signed = v < 0;
  unsigned int len;
  char *p;
  uint64_t j = (uint64_t) v;

  if (is_signed) {
    j = ~j + 1;
    *str++ = '-';
  }
  len = log10_64 (j);
  p = str + len;
  *p = '\0';
#if __WORDSIZE == 64
  while (j >= 1000) {
    uint64_t d = j / 1000;

    p = (char *) memcpy (p - 3, &num3[(j - d * 1000) * 3], 3);
    j = d;
  }
  if (j >= 100) {
    memcpy (p - 3, &num3[j * 3], 3);
  }
  else if (j >= 10) {
    memcpy (p - 2, &num3[j * 3] + 1, 2);
  }
  else {
    memcpy (p - 1, &num3[j * 3] + 2, 1);
  }
#else
  if (j >= 1000000000) {
    uint64_t d = div_1000000000 (j);
    uint32_t m = j - d * 1000000000;

    do_uint (m + 1000000000, p - 10, 10);
    j = d;
    p -= 9;
    if (j >= 1000000000) {
      d = div_1000000000 (j);
      m = j - d * 1000000000;

      do_uint (m + 1000000000, p - 10, 10);
      j = d;
      p -= 9;
    }
  }
  do_uint (j, str, p - str);
#endif
  return len + is_signed;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1497
movq 0x10(%rsp), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rsp)
movb $0x2d, (%rax)
movq 0x10(%rsp), %rdi
callq 0x15a0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0x20(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
cmpq $0x3e8, 0x10(%rsp)      # imm = 0x3E8
jb 0x1525
movq 0x10(%rsp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, %rax
addq $-0x3, %rax
movq 0x10(%rsp), %rdx
imulq $0x3e8, 0x8(%rsp), %rsi # imm = 0x3E8
subq %rsi, %rdx
imulq $0x3, %rdx, %rsi
leaq 0x10d3b(%rip), %rdx     # 0x12240
movw (%rdx,%rsi), %di
movw %di, -0x3(%rcx)
movb 0x2(%rdx,%rsi), %dl
movb %dl, -0x1(%rcx)
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x14be
cmpq $0x64, 0x10(%rsp)
jb 0x1550
movq 0x18(%rsp), %rax
imulq $0x3, 0x10(%rsp), %rdx
leaq 0x10d01(%rip), %rcx     # 0x12240
movw (%rcx,%rdx), %si
movw %si, -0x3(%rax)
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x1590
cmpq $0xa, 0x10(%rsp)
jb 0x1575
movq 0x18(%rsp), %rax
imulq $0x3, 0x10(%rsp), %rdx
leaq 0x10cd6(%rip), %rcx     # 0x12240
movw 0x1(%rcx,%rdx), %cx
movw %cx, -0x2(%rax)
jmp 0x158e
movq 0x18(%rsp), %rax
imulq $0x3, 0x10(%rsp), %rdx
leaq 0x10cb9(%rip), %rcx     # 0x12240
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x1590
movl 0x20(%rsp), %eax
addl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hermantb[P]fast_convert/fast_convert.c
// Function: fast_uint32
unsigned int
fast_uint32 (uint32_t v, char *str)
{
  unsigned int len = log10_32 (v);
  char *p = str + len;

  *p = '\0';
  while (v >= 1000) {
    uint32_t d = v / 1000;

    p = (char *) memcpy (p - 3, &num3[(v - d * 1000) * 3], 3);
    v = d;
  }
  if (v >= 100) {
    memcpy (p - 3, &num3[v * 3], 3);
  }
  else if (v >= 10) {
    memcpy (p - 2, &num3[v * 3] + 1, 2);
  }
  else {
    memcpy (p - 1, &num3[v * 3] + 2, 1);
  }
  return len;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x24(%rsp), %edi
callq 0x13e0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
cmpl $0x3e8, 0x24(%rsp)      # imm = 0x3E8
jb 0x16a4
movl 0x24(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, %rax
addq $-0x3, %rax
movl 0x24(%rsp), %edx
imull $0x3e8, 0x4(%rsp), %esi # imm = 0x3E8
subl %esi, %edx
imull $0x3, %edx, %edx
movl %edx, %edx
movl %edx, %esi
leaq 0x10bba(%rip), %rdx     # 0x12240
movw (%rdx,%rsi), %di
movw %di, -0x3(%rcx)
movb 0x2(%rdx,%rsi), %dl
movb %dl, -0x1(%rcx)
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1643
cmpl $0x64, 0x24(%rsp)
jb 0x16d1
movq 0x8(%rsp), %rax
imull $0x3, 0x24(%rsp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x10b80(%rip), %rcx     # 0x12240
movw (%rcx,%rdx), %si
movw %si, -0x3(%rax)
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x1716
cmpl $0xa, 0x24(%rsp)
jb 0x16f8
movq 0x8(%rsp), %rax
imull $0x3, 0x24(%rsp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x10b53(%rip), %rcx     # 0x12240
movw 0x1(%rcx,%rdx), %cx
movw %cx, -0x2(%rax)
jmp 0x1714
movq 0x8(%rsp), %rax
imull $0x3, 0x24(%rsp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x10b33(%rip), %rcx     # 0x12240
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x1716
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hermantb[P]fast_convert/fast_convert.c
// Function: fast_uint64
unsigned int
fast_uint64 (uint64_t v, char *str)
{
  unsigned int len = log10_64 (v);
  char *p = str + len;

  *p = '\0';
#if __WORDSIZE == 64
  while (v >= 1000) {
    uint64_t d = v / 1000;

    p = (char *) memcpy (p - 3, &num3[(v - d * 1000) * 3], 3);
    v = d;
  }
  if (v >= 100) {
    memcpy (p - 3, &num3[v * 3], 3);
  }
  else if (v >= 10) {
    memcpy (p - 2, &num3[v * 3] + 1, 2);
  }
  else {
    memcpy (p - 1, &num3[v * 3] + 2, 1);
  }
#else
  if (v >= 1000000000) {
    uint64_t d = div_1000000000 (v);
    uint32_t m = v - d * 1000000000;

    do_uint (m + 1000000000, p - 10, 10);
    v = d;
    p -= 9;
    if (v >= 1000000000) {
      d = div_1000000000 (v);
      m = v - d * 1000000000;

      do_uint (m + 1000000000, p - 10, 10);
      v = d;
      p -= 9;
    }
  }
  do_uint (v, str, p - str);
#endif
  return len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15a0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
cmpq $0x3e8, 0x20(%rsp)      # imm = 0x3E8
jb 0x17b9
movq 0x20(%rsp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, %rax
addq $-0x3, %rax
movq 0x20(%rsp), %rdx
imulq $0x3e8, (%rsp), %rsi    # imm = 0x3E8
subq %rsi, %rdx
imulq $0x3, %rdx, %rsi
leaq 0x10aa6(%rip), %rdx     # 0x12240
movw (%rdx,%rsi), %di
movw %di, -0x3(%rcx)
movb 0x2(%rdx,%rsi), %dl
movb %dl, -0x1(%rcx)
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1755
cmpq $0x64, 0x20(%rsp)
jb 0x17e4
movq 0x8(%rsp), %rax
imulq $0x3, 0x20(%rsp), %rdx
leaq 0x10a6d(%rip), %rcx     # 0x12240
movw (%rcx,%rdx), %si
movw %si, -0x3(%rax)
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x1824
cmpq $0xa, 0x20(%rsp)
jb 0x1809
movq 0x8(%rsp), %rax
imulq $0x3, 0x20(%rsp), %rdx
leaq 0x10a42(%rip), %rcx     # 0x12240
movw 0x1(%rcx,%rdx), %cx
movw %cx, -0x2(%rax)
jmp 0x1822
movq 0x8(%rsp), %rax
imulq $0x3, 0x20(%rsp), %rdx
leaq 0x10a25(%rip), %rcx     # 0x12240
movb 0x2(%rcx,%rdx), %cl
movb %cl, -0x1(%rax)
jmp 0x1824
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hermantb[P]fast_convert/fast_convert.c
// Function: mul_96
static const uint64_t
mul_96 (const uint64_t n, const uint64_t m, const uint32_t o, uint32_t * low)
{
  uint64_t hi1, lo1, hi2, lo2;

__asm__ ("mulq %3": "=d" (hi1), "=a" (lo1): "%a" (n), "rm" (m):"cc");
__asm__ ("mulq %3": "=d" (hi2), "=a" (lo2): "%a" (n), "rm" ((uint64_t) o):"cc");
  lo2 >>= 32;
  lo1 += lo2;
  lo1 = (lo1 >> 32) + ((lo1 < lo2) ? UINT64_C (4294967296) : 0);
  *low = hi2 += lo1;
  return hi1 + (hi2 >> 32) + ((hi2 < lo1) ? UINT64_C (4294967296) : 0);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, -0x50(%rsp)
mulq -0x50(%rsp)
movq %rdx, -0x28(%rsp)
movq %rax, -0x30(%rsp)
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movq %rcx, -0x48(%rsp)
mulq -0x48(%rsp)
movq %rdx, -0x38(%rsp)
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
shrq $0x20, %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
addq -0x30(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
shrq $0x20, %rax
movq -0x30(%rsp), %rsi
movq -0x40(%rsp), %rdi
xorl %ecx, %ecx
movabsq $0x100000000, %rdx      # imm = 0x100000000
cmpq %rdi, %rsi
cmovbq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
addq -0x38(%rsp), %rax
movq %rax, -0x38(%rsp)
movl %eax, %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x28(%rsp), %rax
movq -0x38(%rsp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq -0x38(%rsp), %rsi
movq -0x30(%rsp), %rdi
xorl %ecx, %ecx
movabsq $0x100000000, %rdx      # imm = 0x100000000
cmpq %rdi, %rsi
cmovbq %rdx, %rcx
addq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hermantb[P]fast_convert/fast_convert.c
// Function: mul_10_add
static void
mul_10_add (uint64_t * m, uint64_t * l, uint32_t a)
{
  uint64_t hi;
  uint64_t lo;

  *m = (*m << 1) + (*l >> 63);
  *l <<= 1;
  hi = (*m << 2) + (*l >> 62);
  lo = *l << 2;
  *l += lo;
  *m += hi + (*l < lo);
  *l += a;
  *m += (*l < a);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
shrq $0x3f, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
shlq $0x2, %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
shrq $0x3e, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
shlq $0x2, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rcx
movq -0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
cmpq -0x28(%rsp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq %rax, %rcx
movq -0x8(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x14(%rsp), %eax
movl %eax, %ecx
movq -0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl -0x14(%rsp), %ecx
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x8(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTQueue_test.c
// Function: test_create
void test_create(void) {
	Queue queue = queue_create(NULL);
	queue_set_destroy_value(queue, NULL);

	TEST_ASSERT(queue != NULL);
	TEST_ASSERT(queue_size(queue) == 0);

	queue_destroy(queue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x51f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5340
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1f0b(%rip), %rsi      # 0x62e1
movl $0x11, %edx
leaq 0x206a(%rip), %rcx      # 0x644c
leaq 0x1f08(%rip), %r8       # 0x62f1
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x43fa
callq 0x2e50
jmp 0x43fc
jmp 0x43fe
movq -0x8(%rbp), %rdi
callq 0x5230
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1ec8(%rip), %rsi      # 0x62e1
movl $0x12, %edx
leaq 0x2027(%rip), %rcx      # 0x644c
leaq 0x1ed3(%rip), %r8       # 0x62ff
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x443d
callq 0x2e50
jmp 0x443f
movq -0x8(%rbp), %rdi
callq 0x5370
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTQueue_test.c
// Function: test_insert
void test_insert(void) {
	Queue queue = queue_create(NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					// Στο queue θα προσθέσουμε pointers προς τα στοιχεία αυτού του πίνακα

	// insert 1000 στοιχεία
	for (int i = 0; i < 1000; i++) {
		queue_insert_back(queue, &array[i]);
		TEST_ASSERT(queue_size(queue) == i+1);			// Το size πρέπει να μεγαλώσει
		TEST_ASSERT(queue_front(queue) == &array[0]);	// Το μπροστινό στοιχείο στην κορυφή είναι πάντα το array[0]
		TEST_ASSERT(queue_back(queue) == &array[i]);		// Το πίσω στοιχείο είναι αυτό που μόλις βάλαμε
	}

	queue_destroy(queue);
	free(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x51f0
movq %rax, -0x8(%rbp)
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2190
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x4598
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x52d0
movq -0x8(%rbp), %rdi
callq 0x5230
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1e18(%rip), %rsi      # 0x62e1
movl $0x1f, %edx
leaq 0x1f77(%rip), %rcx      # 0x644c
leaq 0x1e3a(%rip), %r8       # 0x6316
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x44ed
callq 0x2e50
jmp 0x44ef
jmp 0x44f1
movq -0x8(%rbp), %rdi
callq 0x5250
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1dd1(%rip), %rsi      # 0x62e1
movl $0x20, %edx
leaq 0x1f30(%rip), %rcx      # 0x644c
leaq 0x1e0c(%rip), %r8       # 0x632f
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4534
callq 0x2e50
jmp 0x4536
jmp 0x4538
movq -0x8(%rbp), %rdi
callq 0x5290
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1d7f(%rip), %rsi      # 0x62e1
movl $0x21, %edx
leaq 0x1ede(%rip), %rcx      # 0x644c
leaq 0x1dda(%rip), %r8       # 0x634f
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4586
callq 0x2e50
jmp 0x4588
jmp 0x458a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4484
movq -0x8(%rbp), %rdi
callq 0x5370
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq