LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/rand.c
// Function: rand_name
void
rand_name(char *name, size_t max)
{
    /* This thing sucks ... */
    const char *vowels = "aeiou";
    const char *consonants = "bcdfghjklmnpqrstvwxyz";
    int length = rand_range(6, max);
    int spaces = 0;
    int letters = 0;
    for (int i = 0; i < length; i++) {
        float spacep = letters / 3.0f * powf(0.1f, 1.0f / (10 * spaces + 1));
        if (i > 0 && rand_uniform(0, 1.0) < spacep) {
            name[i] = ' ';
            letters = 0;
        } else {
            if (i % 2)
                name[i] = consonants[rand_range(0, strlen(consonants))];
            else
                name[i] = vowels[rand_range(0, strlen(vowels))];
            if (letters == 0)
                name[i] = toupper((int)name[i]);
            letters++;
        }
    }
    name[length] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1571(%rip), %rax      # 0x9b38
movq %rax, -0x18(%rbp)
leaq 0x156c(%rip), %rax      # 0x9b3e
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %esi
movl $0x6, %edi
callq 0x8580
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x8741
cvtsi2ssl -0x2c(%rbp), %xmm0
movss 0x151d(%rip), %xmm1     # 0x9b34
divss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
imull $0xa, -0x28(%rbp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
movss 0x1321(%rip), %xmm1     # 0x9954
divss %xmm0, %xmm1
movss 0x14f1(%rip), %xmm0     # 0x9b30
callq 0x11e0
movaps %xmm0, %xmm1
movss -0x38(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x8690
xorps %xmm0, %xmm0
movss 0x12ee(%rip), %xmm1     # 0x9954
callq 0x8510
movaps %xmm0, %xmm1
movss -0x34(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x8690
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl $0x0, -0x2c(%rbp)
jmp 0x8731
movl -0x30(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x86d3
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
movl %eax, %esi
xorl %edi, %edi
callq 0x8580
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x8704
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10c0
movl %eax, %esi
xorl %edi, %edi
callq 0x8580
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0x2c(%rbp)
jne 0x8728
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1060
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8733
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x85fe
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/device_unix.c
// Function: device_init
void
device_init(void)
{
    printf("\e[2J");
    tcgetattr(STDIN_FILENO, &termios_orig);
    struct termios raw;
    memcpy(&raw, &termios_orig, sizeof(raw));
    raw.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
    raw.c_oflag &= ~OPOST;
    raw.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
    raw.c_cflag &= ~(CSIZE|PARENB);
    raw.c_cflag |= CS8;
    tcsetattr(STDIN_FILENO, TCSANOW, &raw);
    fputs("\e[?25l", stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x13e5(%rip), %rdi      # 0x9b54
movb $0x0, %al
callq 0x10e0
xorl %edi, %edi
leaq 0xda81(%rip), %rsi      # 0x16200
callq 0x1200
leaq -0x3c(%rbp), %rdi
leaq 0xda71(%rip), %rsi      # 0x16200
movl $0x3c, %edx
callq 0x1190
movl -0x3c(%rbp), %eax
andl $0xfffffa14, %eax       # imm = 0xFFFFFA14
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
andl $0xffff7fb4, %eax       # imm = 0xFFFF7FB4
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
andl $0xfffffecf, %eax       # imm = 0xFFFFFECF
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x34(%rbp)
xorl %esi, %esi
leaq -0x3c(%rbp), %rdx
movl %esi, %edi
callq 0x1210
movq 0x4800(%rip), %rax      # 0xcfe0
movq (%rax), %rsi
leaq 0x136f(%rip), %rdi      # 0x9b59
callq 0x1110
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/device_unix.c
// Function: device_move
void
device_move(int x, int y)
{
    cursor_x = x;
    cursor_y = y;
    device_font_last = (font_t)FONT_INVALID;
    printf("\e[%d;%dH", y + 1, x + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xd9f5(%rip)      # 0x1623c
movl -0x8(%rbp), %eax
movl %eax, 0xd9f0(%rip)      # 0x16240
movb $-0x1, -0xc(%rbp)
movb $-0x1, -0xb(%rbp)
movb $0x1, -0xa(%rbp)
movb $0x1, -0x9(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x7006(%rip)      # 0xf86f
movl -0x8(%rbp), %esi
addl $0x1, %esi
movl -0x4(%rbp), %edx
addl $0x1, %edx
leaq 0x12ef(%rip), %rdi      # 0x9b6b
movb $0x0, %al
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/device_unix.c
// Function: device_cursor_get
void
device_cursor_get(int *x, int *y)
{
    if (x)
        *x = cursor_x;
    if (y)
        *y = cursor_y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x88af
movl 0xd993(%rip), %ecx      # 0x1623c
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x88c2
movl 0xd984(%rip), %ecx      # 0x16240
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/device_unix.c
// Function: device_putc
void
device_putc(font_t font, uint16_t c)
{
    uint8_t utf8[7];
    utf8[utf32_to_8(c, utf8)] = '\0';
    if (font_equal(device_font_last, font))
        fputs((char *)utf8, stdout);
    else
        printf("\e[%d;%dm%s",
               font.fore + 30 + (font.fore_bright ? 60 : 0),
               font.back + 40 + (font.back_bright ? 60 : 0),
               (char *)utf8);
    device_font_last = font;
    cursor_x++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %edi
leaq -0xd(%rbp), %rsi
callq 0x8990
movb $0x0, -0xd(%rbp,%rax)
movl 0x6f75(%rip), %edi      # 0xf86f
movl -0x4(%rbp), %esi
callq 0x8ae0
testb $0x1, %al
jne 0x8908
jmp 0x891d
leaq -0xd(%rbp), %rdi
movq 0x46cd(%rip), %rax      # 0xcfe0
movq (%rax), %rsi
callq 0x1110
jmp 0x8963
movzbl -0x4(%rbp), %esi
addl $0x1e, %esi
movb -0x2(%rbp), %dl
xorl %eax, %eax
movl $0x3c, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addl %eax, %esi
movzbl -0x3(%rbp), %edx
addl $0x28, %edx
movb -0x1(%rbp), %dil
xorl %eax, %eax
movl $0x3c, %ecx
testb $0x1, %dil
cmovnel %ecx, %eax
addl %eax, %edx
leaq -0xd(%rbp), %rcx
leaq 0x1218(%rip), %rdi      # 0x9b74
movb $0x0, %al
callq 0x10e0
movl -0x4(%rbp), %eax
movl %eax, 0x6f03(%rip)      # 0xf86f
movl 0xd8ca(%rip), %eax      # 0x1623c
addl $0x1, %eax
movl %eax, 0xd8c1(%rip)      # 0x1623c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/device_unix.c
// Function: device_getch
int
device_getch(void)
{
    int r;
    unsigned char c;
    if ((r = read(STDIN_FILENO, &c, sizeof(c))) < 0) {
        return r;
    } else if (c == '\e') {
        if (!device_kbhit(0))
            return c;
        unsigned char code[2];
        read(STDIN_FILENO, code, sizeof(code));
        return code[1] + 256;
    } else {
        if (c == 3) {
            /* SIGINT */
            device_free();
            exit(EXIT_FAILURE);
        }
        return c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x1160
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jge 0x8b88
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8be4
movzbl -0x9(%rbp), %eax
cmpl $0x1b, %eax
jne 0x8bc5
xorl %eax, %eax
movl %eax, %edi
callq 0x8bf0
testb $0x1, %al
jne 0x8ba7
movzbl -0x9(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8be4
leaq -0xb(%rbp), %rsi
xorl %edi, %edi
movl $0x2, %edx
callq 0x1160
movzbl -0xa(%rbp), %eax
addl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
jmp 0x8be4
movzbl -0x9(%rbp), %eax
cmpl $0x3, %eax
jne 0x8bdd
callq 0x8800
movl $0x1, %edi
callq 0x1250
movzbl -0x9(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/device_unix.c
// Function: device_kbhit
bool
device_kbhit(uint64_t useconds)
{
    struct timeval tv = {useconds / 1000000, useconds % 1000000};
    fd_set fds;
    FD_ZERO(&fds);
    FD_SET(STDIN_FILENO, &fds);
    return select(1, &fds, NULL, NULL, &tv) > 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movq %rdx, -0x10(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpq $0x10, %rax
jae 0x8c6d
movq -0xa8(%rbp), %rax
movl -0x9c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x8c3b
jmp 0x8c6f
movq -0x98(%rbp), %rax
orq $0x1, %rax
movq %rax, -0x98(%rbp)
movl $0x1, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rdx
callq 0x11a0
cmpl $0x0, %eax
setg %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/device_unix.c
// Function: device_entropy
void
device_entropy(void *buffer, size_t size)
{
    FILE *in = fopen("/dev/urandom", "r");
    if (in == NULL || fread(buffer, size, 1, in) != 1) {
        /* Fallback */
        uint32_t pid = getpid();
        uint64_t state = device_uepoch() ^ (pid < 32);
        xorshift_fill(&state, buffer, size);
    }
    if (in)
        fclose(in);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe20(%rip), %rdi       # 0x9b87
leaq 0x7cd(%rip), %rsi       # 0x953b
callq 0x1220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8d9a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x1080
cmpq $0x1, %rax
je 0x8dcf
callq 0x10a0
movl %eax, -0x1c(%rbp)
callq 0x8cb0
cmpl $0x20, -0x1c(%rbp)
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
xorq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x8400
cmpq $0x0, -0x18(%rbp)
je 0x8ddf
movq -0x18(%rbp), %rdi
callq 0x10b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/elmd1001v2/ref/module.h
// Function: is_equal_block
int is_equal_block(block blk1, block blk2){
	int i; 
	for(i=0; i<16; i++){
		if(blk1[i] != blk2[i]) return -1;
	} 
	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x10, -0x1c(%rsp)
jge 0x3592
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x3583
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x359a
jmp 0x3585
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x3552
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/elmd1001v2/ref/module.h
// Function: AES
static void AES(int r, u8 Is_Encrypt, block res, block inp, AES_KEY *key)
{
	if(r == 10)
	{
		if(Is_Encrypt == ENCRYPT)
			AES_encrypt(inp, res, key);
		else
			AES_decrypt(inp, res, key);
	}
	else if(r == 6)
	{
		if(Is_Encrypt == ENCRYPT )
			AES_encrypt_r6(inp, res, key);
		else
			AES_decrypt_r6(inp, res, key);
	} 
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movl %edi, 0x24(%rsp)
movb %al, 0x23(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpl $0xa, 0x24(%rsp)
jne 0x3b1b
movzbl 0x23(%rsp), %eax
cmpl $0x1, %eax
jne 0x3b05
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1070
jmp 0x3b19
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1050
jmp 0x3b5a
cmpl $0x6, 0x24(%rsp)
jne 0x3b58
movzbl 0x23(%rsp), %eax
cmpl $0x1, %eax
jne 0x3b42
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1040
jmp 0x3b56
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1060
jmp 0x3b58
jmp 0x3b5a
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/elmd1001v2/ref/module.h
// Function: mult_inv2
static void mult_inv2(block b, block s) {int i; block d; unsigned char temp = s[15]&1;
   	for (i=1; i<16; i++)	{d[i] = (s[i-1] << 7) | (s[i] >> 1) ;}
   	d[0] = (s[0] >> 1); if(temp==1){d[15] ^= 0x43; d[0] ^= 0x80;}
	copy_block(b,d);}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl 0xf(%rax), %eax
andl $0x1, %eax
movb %al, 0xf(%rsp)
movl $0x1, 0x24(%rsp)
cmpl $0x10, 0x24(%rsp)
jge 0x3c0d
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x7, %eax
movq 0x28(%rsp), %rcx
movslq 0x24(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
sarl %ecx
orl %ecx, %eax
movb %al, %cl
movslq 0x24(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3bc6
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
sarl %eax
movb %al, 0x10(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x1, %eax
jne 0x3c3f
movzbl 0x1f(%rsp), %eax
xorl $0x43, %eax
movb %al, 0x1f(%rsp)
movzbl 0x10(%rsp), %eax
xorl $0x80, %eax
movb %al, 0x10(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3ee0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/elmd1001v2/ref/encrypt.c
// Function: process_AD
static void process_AD(
	block W, block Delta_1, const block npub, block param, 
	const u8 *ad, u64 adlen) {	

	block Delta_2, blk, result;
	u8 Is_complete = 1, ozs[16];
	int i; for(i=1; i<16; i++){ozs[i]=0x00;} ozs[0] = 0x80; 

	

	/* ===== make the first block blk based on npub and param ===== */
	load_block(blk, npub, param, 8, 8);
	
	while(1){ 
		
		/* ============= Process the current Block ==================== */
		process_block(Delta_1, Delta_2, result, blk, W, Is_complete, ENCRYPT, 0, AD);
				
		/* === Compute the next Block and updating the pointers and counters ===*/
		if(adlen==0) break; 
		
		else if(adlen <= 16) {
			load_block(blk, ad, ozs, adlen, 16-adlen); 
			if(adlen != 16) Is_complete = 0;
			adlen = 0; 
		}

		else {load_block(blk, ad, ozs, 16, 0); ad +=16; adlen -=16;}
	}

}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
movb $0x1, 0x3f(%rsp)
movl $0x1, 0x1c(%rsp)
cmpl $0x10, 0x1c(%rsp)
jge 0x3cbf
movslq 0x1c(%rsp), %rax
movb $0x0, 0x20(%rsp,%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3ca1
movb $-0x80, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movl $0x8, %r8d
movl %r8d, %ecx
callq 0x3de0
movq 0x98(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq 0xa0(%rsp), %r8
xorl %eax, %eax
movzbl 0x3f(%rsp), %r9d
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x3f30
cmpq $0x0, 0x78(%rsp)
jne 0x3d37
jmp 0x3dce
cmpq $0x10, 0x78(%rsp)
ja 0x3d86
leaq 0x50(%rsp), %rdi
movq 0x80(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x78(%rsp), %rax
movb %al, %cl
movl $0x10, %eax
subq 0x78(%rsp), %rax
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x3de0
cmpq $0x10, 0x78(%rsp)
je 0x3d7b
movb $0x0, 0x3f(%rsp)
movq $0x0, 0x78(%rsp)
jmp 0x3dc7
leaq 0x50(%rsp), %rdi
movq 0x80(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movl $0x10, %ecx
xorl %r8d, %r8d
callq 0x3de0
movq 0x80(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x78(%rsp)
jmp 0x3dc9
jmp 0x3ce7
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/elmd1001v2/ref/module.h
// Function: process_block
static void process_block(
	block Delta_1, block Delta_2, 
	block result, const block in_blk, block W,
	u8 Is_complete, u8 Is_Encrypt, u8 Is_final,  u8 type_block) {

	block YY, XX, Y, X; 
	int i;
	
	/* ==============   Mask  ================= */
	if(type_block == AD || type_block == MESSAGE)
		mask(Delta_1, XX, in_blk, Is_complete);	
	else
		mask(Delta_1, XX, in_blk, 1);	

	/* ==============  AES Encrypt =============== */
	if(type_block == AD)  { AES(rd, ENCRYPT, X, XX, &aes_key1); } 
	if(type_block == MESSAGE) { AES(rd, ENCRYPT, X, XX, &aes_key1); }				
	if(type_block == CIPHERTEXT){  AES(rd, ENCRYPT, X, XX, &aes_key1); } 

	/* ============= Linear Mixing =============== */
	linear_mix(W, Y, X, Is_Encrypt, Is_final);
	
	/* ============= AES Decrypt ================== */
	if(type_block == MESSAGE) {  AES(rd, DECRYPT, YY, Y, &aes_key2); }   
	if(type_block == CIPHERTEXT){  AES(rd, DECRYPT, YY, Y, &aes_key2); }
	
	/* =============== Mask ======================= */
	if(type_block == MESSAGE)
		mask(Delta_2, result, YY, 1);	
	if(type_block == CIPHERTEXT)
		mask(Delta_2, result, YY, Is_complete);

}

// Assembly:
subq $0x88, %rsp
movb %r9b, %al
movb 0xa0(%rsp), %r9b
movb 0x98(%rsp), %r9b
movb 0x90(%rsp), %r9b
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movb %al, 0x5f(%rsp)
movzbl 0xa0(%rsp), %eax
cmpl $0x0, %eax
je 0x3f8c
movzbl 0xa0(%rsp), %eax
cmpl $0x1, %eax
jne 0x3faa
movq 0x80(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x68(%rsp), %rdx
movzbl 0x5f(%rsp), %ecx
callq 0x49b0
jmp 0x3fc6
movq 0x80(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x68(%rsp), %rdx
movl $0x1, %ecx
callq 0x49b0
movzbl 0xa0(%rsp), %eax
cmpl $0x0, %eax
jne 0x3ff3
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movl $0xa, %edi
movl $0x1, %esi
movq 0x4fe2(%rip), %r8       # 0x8fd0
callq 0x3ac0
movzbl 0xa0(%rsp), %eax
cmpl $0x1, %eax
jne 0x4020
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movl $0xa, %edi
movl $0x1, %esi
movq 0x4fb5(%rip), %r8       # 0x8fd0
callq 0x3ac0
movzbl 0xa0(%rsp), %eax
cmpl $0x2, %eax
jne 0x404d
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movl $0xa, %edi
movl $0x1, %esi
movq 0x4f88(%rip), %r8       # 0x8fd0
callq 0x3ac0
movq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movb 0x90(%rsp), %al
movzbl %al, %ecx
movzbl 0x98(%rsp), %r8d
callq 0x4a10
movzbl 0xa0(%rsp), %eax
cmpl $0x1, %eax
jne 0x409e
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movl $0xa, %edi
xorl %esi, %esi
movq 0x4f47(%rip), %r8       # 0x8fe0
callq 0x3ac0
movzbl 0xa0(%rsp), %eax
cmpl $0x2, %eax
jne 0x40c8
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movl $0xa, %edi
xorl %esi, %esi
movq 0x4f1d(%rip), %r8       # 0x8fe0
callq 0x3ac0
movzbl 0xa0(%rsp), %eax
cmpl $0x1, %eax
jne 0x40ee
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movl $0x1, %ecx
callq 0x49b0
movzbl 0xa0(%rsp), %eax
cmpl $0x2, %eax
jne 0x4114
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movzbl 0x5f(%rsp), %ecx
callq 0x49b0
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/elmd1001v2/ref/module.h
// Function: mult_2
static void mult_2(block b, block s) {int i; block d; unsigned char temp = s[0]>>7;
   	for (i=0; i<15; i++)	{d[i] = (s[i] << 1) | (s[i+1] >> 7);}
 	d[15] = (s[15] << 1); if(temp==1){d[15] ^= alpha_128;} 
	copy_block(b,d);}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
sarl $0x7, %eax
movb %al, 0xf(%rsp)
movl $0x0, 0x24(%rsp)
cmpl $0xf, 0x24(%rsp)
jge 0x496c
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movzbl (%rax,%rcx), %eax
shll %eax
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
movb %al, %cl
movslq 0x24(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4925
movq 0x28(%rsp), %rax
movzbl 0xf(%rax), %eax
shll %eax
movb %al, 0x1f(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x1, %eax
jne 0x4993
movzbl 0x1f(%rsp), %eax
xorl $0x87, %eax
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3ee0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/elmd1001v2/ref/module.h
// Function: linear_mix
static void linear_mix(block W, block Y, block X, u8 Is_Encrypt, u8 Is_final){
	block w_2, w_3; mult_3(w_3, W); mult_2(w_2, W); 	
	if((Is_final == 1)&&(Is_Encrypt == DECRYPT)) { X[15] = X[15]^1; }	
	xor_block(Y, X, w_3);
	if((Is_final == 1)&&(Is_Encrypt == ENCRYPT)) {Y[15] = Y[15]^1;}	
	if(Is_Encrypt == ENCRYPT)		{xor_block(W, X, w_2);}
	else if(Is_Encrypt == DECRYPT)	{xor_block(W, X, W);}
	
}

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb %cl, 0x2f(%rsp)
movb %al, 0x2e(%rsp)
movq %rsp, %rdi
movq 0x40(%rsp), %rsi
callq 0x3b60
leaq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x4900
movzbl 0x2e(%rsp), %eax
cmpl $0x1, %eax
jne 0x4a74
movzbl 0x2f(%rsp), %eax
cmpl $0x0, %eax
jne 0x4a74
movq 0x30(%rsp), %rax
movzbl 0xf(%rax), %eax
xorl $0x1, %eax
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, 0xf(%rax)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rsp, %rdx
callq 0x4180
movzbl 0x2e(%rsp), %eax
cmpl $0x1, %eax
jne 0x4ab0
movzbl 0x2f(%rsp), %eax
cmpl $0x1, %eax
jne 0x4ab0
movq 0x38(%rsp), %rax
movzbl 0xf(%rax), %eax
xorl $0x1, %eax
movb %al, %cl
movq 0x38(%rsp), %rax
movb %cl, 0xf(%rax)
movzbl 0x2f(%rsp), %eax
cmpl $0x1, %eax
jne 0x4ad0
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x4180
jmp 0x4af0
movzbl 0x2f(%rsp), %eax
cmpl $0x0, %eax
jne 0x4aee
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x4180
jmp 0x4af0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/wordlength.c
// Function: main
int main()
{
    int c, state, wl;
    int length[MAX_WORD_LENGTH + 1];

    for (int i = 0; i <= MAX_WORD_LENGTH; ++i)
        length[i] = 0;

    state = OUT;
    wl = 0;
    while ((c = getchar()) != EOF) {
        if (c == ' ' || c == '\n' || c == '\t') {
            if (state == IN) {
                state = OUT;
                ++length[wl <= MAX_WORD_LENGTH ? wl - 1 : MAX_WORD_LENGTH];
            }
        } else {
            if (state == OUT) {
                state = IN;
                wl = 0;
            }
            ++wl;
        }
    }

    for (int j = 0; j <= MAX_WORD_LENGTH; ++j) {
        if (j == MAX_WORD_LENGTH)
            printf(">%d: ", MAX_WORD_LENGTH);
        else
            printf(" %2d: ", j + 1);

        for (int k = 0; k < length[j]; ++k)
            putchar('#');
        putchar('\n');
    }


    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0xa, -0x44(%rbp)
jg 0x1193
movslq -0x44(%rbp), %rax
movl $0x0, -0x40(%rbp,%rax,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1176
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
callq 0x1050
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x1219
cmpl $0x20, -0x8(%rbp)
je 0x11c0
cmpl $0xa, -0x8(%rbp)
je 0x11c0
cmpl $0x9, -0x8(%rbp)
jne 0x11fa
cmpl $0x1, -0xc(%rbp)
jne 0x11f8
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0x10(%rbp)
jg 0x11de
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x11e8
movl $0xa, %eax
movl %eax, -0x50(%rbp)
jmp 0x11e8
movl -0x50(%rbp), %eax
cltq
movl -0x40(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x40(%rbp,%rax,4)
jmp 0x1217
cmpl $0x0, -0xc(%rbp)
jne 0x120e
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11a1
movl $0x0, -0x48(%rbp)
cmpl $0xa, -0x48(%rbp)
jg 0x1293
cmpl $0xa, -0x48(%rbp)
jne 0x1241
leaq 0xdd1(%rip), %rdi       # 0x2004
movl $0xa, %esi
movb $0x0, %al
callq 0x1040
jmp 0x1255
movl -0x48(%rbp), %esi
addl $0x1, %esi
leaq 0xdbc(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movslq -0x48(%rbp), %rcx
cmpl -0x40(%rbp,%rcx,4), %eax
jge 0x127e
movl $0x23, %edi
callq 0x1030
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x125c
movl $0xa, %edi
callq 0x1030
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x1220
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: hashmap_standalone_hash
size_t hashmap_standalone_hash(char *inp){
    size_t output = 0;
    size_t i = 0;
    size_t l = strlen(inp);
    while((i + 1) <= l){
        output = output*17 + inp[i++];
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
ja 0x12ed
imulq $0x11, -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movsbq (%rcx,%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x12b9
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: hashmap_hash
size_t hashmap_hash(hashmap_t *hm, char *inp){
    size_t output = 0;
    size_t i = 0;
    size_t l = strlen(inp);
    while((i + 1) <= l){
        output = output*17 + inp[i++];
    }
    return output % hm->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
ja 0x1361
imulq $0x11, -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movsbq (%rcx,%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x132d
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
movq %rdx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: hashmap_init
hashmap_t *hashmap_init(size_t size){
    hashmap_t *hm = calloc(1, sizeof(hashmap_t));
    hm->map = calloc(size, sizeof(hashmap_vector_t));
    hm->size = size;
    for(size_t i = 0; i < hm->size; i++){
        hm->map[i].len = 3;
        hm->map[i].cursor = 0;
        hm->map[i].list = calloc(1, sizeof(struct sh_alias));
    }
    return hm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x143b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq $0x3, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x13cb
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: hashmap_free
int hashmap_free(hashmap_t *hm){
    for(int i = 0; i < hm->size; i++){
        free(hm->map[i].list);
    }
    free(hm->map);
    free(hm);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1497
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1463
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: hashmap_set
int hashmap_set(hashmap_t *hm, char *name, char *command){
    size_t c = hashmap_standalone_hash(name);
    size_t n = hashmap_hash(hm, name);
    hm->map[n].list[hm->map[n].cursor].id = c;
    hm->map[n].list[hm->map[n].cursor].name = name;
    hm->map[n].list[hm->map[n].cursor++].command = command;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1290
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1300
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
imulq $0x18, -0x28(%rbp), %rsi
addq %rsi, %rdx
imulq $0x18, 0x8(%rdx), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
imulq $0x18, -0x28(%rbp), %rsi
addq %rsi, %rdx
imulq $0x18, 0x8(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rsi
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rsi
movq 0x8(%rsi), %rdx
movq %rdx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: hashmap_item_exists
ssize_t hashmap_item_exists(hashmap_t *hm, char *inp){
    size_t c = hashmap_standalone_hash(inp);
    size_t n = hashmap_hash(hm, inp);
    hashmap_vector_t a = hm->map[n];
    for(size_t i = 0; i < a.len; i++){
        if(a.list[i].id == c){
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1290
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1300
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x1646
movq -0x30(%rbp), %rax
imulq $0x18, -0x48(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1636
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x164e
jmp 0x1638
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x160d
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: hashmap_get
struct sh_alias *hashmap_get(hashmap_t *hm, char *name){
    if(hashmap_item_exists(hm, name) != -1){
        size_t id = hashmap_standalone_hash(name);
        hashmap_vector_t v = hm->map[hashmap_hash(hm, name)];
        for(size_t i = 0; i < v.len; i++){
            if(v.list[i].id == id){
                return &v.list[i];
            }
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b0
cmpq $-0x1, %rax
je 0x171d
movq -0x18(%rbp), %rdi
callq 0x1290
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1300
movq %rax, %rcx
movq -0x48(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x171b
movq -0x28(%rbp), %rax
imulq $0x18, -0x40(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x170b
movq -0x28(%rbp), %rax
imulq $0x18, -0x40(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1725
jmp 0x170d
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x16da
jmp 0x171d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: parse_arg
struct sh_args *parse_arg(struct sh_args *args, int argc, char **argv){
    for(int i = 1; i < argc; i++){
        if(argv[i][0] == '-'){
            if(!strcmp(argv[i], "-c")){
                args->has_command = true;
                if(i + 1 < argc){
                    args->command = argv[++i];
                }
                else {
                    fprintf(stderr, "%s: -c option requires an argument\n", argv[i]);
                }
            }
            else if(!strcmp(argv[i], "-s")){
                args->standard_input = true;
            }
            else if(!strcmp(argv[i], "-i")){
                args->interactive = true;
            }
        }
        else {
            fprintf(stderr, "%s: invalid argument %s\n", argv[0], argv[i]);
        }
    }
    return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x18ce
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1893
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1834(%rip), %rsi      # 0x3015
callq 0x10f0
cmpl $0x0, %eax
jne 0x1842
movq -0x8(%rbp), %rax
movb $0x1, 0x2(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cmpl -0xc(%rbp), %eax
jge 0x181c
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1840
movq 0x37d5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x17df(%rip), %rsi      # 0x3018
movb $0x0, %al
callq 0x1110
jmp 0x1891
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x17e7(%rip), %rsi      # 0x303c
callq 0x10f0
cmpl $0x0, %eax
jne 0x1869
movq -0x8(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x188f
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x17c3(%rip), %rsi      # 0x303f
callq 0x10f0
cmpl $0x0, %eax
jne 0x188d
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
jmp 0x188f
jmp 0x1891
jmp 0x18be
movq 0x375e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x178b(%rip), %rsi      # 0x3042
movb $0x0, %al
callq 0x1110
jmp 0x18c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17aa
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: command_get_argc
int command_get_argc(char *buffer){
    int n = 0;
    char *p;
    while(p = strchr(buffer, ' ')){
        n++;
        buffer = p + 1;
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1922
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x18f3
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: sh_is_builtin
int sh_is_builtin(char *command){
    if(!strcmp(command, "exit")){
        return shb_exit;
    }
    else if(!strcmp(command, "cd")){
        return shb_cd;
    }
    else if(!strcmp(command, "alias")){
        puts("alias");
        return shb_alias;
    }
    else if(!strcmp(command, "unalias")){
        return shb_unalias;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14d9(%rip), %rsi      # 0x3010
callq 0x10f0
cmpl $0x0, %eax
jne 0x1b4a
movl $0x0, -0x4(%rbp)
jmp 0x1bbd
movq -0x10(%rbp), %rdi
leaq 0x1506(%rip), %rsi      # 0x305b
callq 0x10f0
cmpl $0x0, %eax
jne 0x1b68
movl $0x3, -0x4(%rbp)
jmp 0x1bbd
movq -0x10(%rbp), %rdi
leaq 0x14ed(%rip), %rsi      # 0x3060
callq 0x10f0
cmpl $0x0, %eax
jne 0x1b92
leaq 0x14dc(%rip), %rdi      # 0x3060
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x1bbd
movq -0x10(%rbp), %rdi
leaq 0x14c1(%rip), %rsi      # 0x305e
callq 0x10f0
cmpl $0x0, %eax
jne 0x1bb0
movl $0x2, -0x4(%rbp)
jmp 0x1bbd
jmp 0x1bb2
jmp 0x1bb4
jmp 0x1bb6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: sh_cd
int sh_cd(char *path){
    if(!path){
        char *res = getenv("HOME");
        if(res){
            path = res;
        }
        else {
            return 0;
        }
    }
    int cd_res = chdir(path);
    if(cd_res == -1){
        fprintf(stderr, "cd: %s: %s\n", strerror(errno), path);
        return errno;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1edf
leaq 0x11e4(%rip), %rdi      # 0x309e
callq 0x1030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ed4
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1edd
movl $0x0, -0x4(%rbp)
jmp 0x1f37
jmp 0x1edf
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1f30
movq 0x3100(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1170
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
leaq 0x1186(%rip), %rsi      # 0x30a3
movb $0x0, %al
callq 0x1110
callq 0x1050
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f37
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: run_builtin
int run_builtin(enum sh_builtins code, struct sh_command *command){
    if(code == shb_exit){
        if(command->argc == 2){
            char **end;
            int ret = (int)strtol(command->argv[1], end, 10);
            if(end[0][0] == command->argv[1][0]){
                fprintf(stderr, "sh: exit: %s: numeric argument required\n", command->argv[1]);
                sh_exit(2);
            }
            sh_exit(ret);
        }
        sh_exit(0);
    }
    else if(code == shb_cd){
        return sh_cd(command->argv[1]);
    }
    else if(code == shb_alias){
        if(command->argc == 2){
            return sh_add_alias(command->argv[1]);
        }
        else {
            puts("else");
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1fdc
movq -0x10(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x1fd3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0x1120
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x1fcb
movq 0x3054(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x10f5(%rip), %rsi      # 0x30af
movb $0x0, %al
callq 0x1110
movl $0x2, %edi
callq 0x1770
movl -0x1c(%rbp), %edi
callq 0x1770
xorl %edi, %edi
callq 0x1770
jmp 0x2037
cmpl $0x3, -0x8(%rbp)
jne 0x1ff8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1ea0
movl %eax, -0x4(%rbp)
jmp 0x203e
cmpl $0x1, -0x8(%rbp)
jne 0x2033
movq -0x10(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x201e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1bd0
movl %eax, -0x4(%rbp)
jmp 0x203e
leaq 0x10b3(%rip), %rdi      # 0x30d8
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x203e
jmp 0x2035
jmp 0x2037
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: call_command
int call_command(struct sh_command *command){
    int status = 0;
    int builtin = sh_is_builtin(command->argv[0]);
    if(builtin != -1){
        status = run_builtin(builtin, command);
        return status;
    }
    pid_t pid = fork();
    if(pid == -1){
        fprintf(stderr, "sh: %s\n", strerror(errno));
        return 1;
    }
    else if(pid){
        waitpid(pid, &status, 0);
        if(WIFEXITED(status)){
            status = WEXITSTATUS(status);
        }
    }
    else {
        if(execvp(command->argv[0], command->argv) == -1){
            fprintf(stderr, "sh: %s: %s\n", command->argv[0], strerror(errno));
            for(int i = -1; command->argv[++i] != NULL; free(command->argv[i]));
            free(command->argv);
            free(command);
            exit(1);
        }
    }
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x1b20
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x2096
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1f40
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21d9
callq 0x1180
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x20df
movq 0x2f4d(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1170
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x1011(%rip), %rsi      # 0x30dd
movb $0x0, %al
callq 0x1110
movl $0x1, -0x4(%rbp)
jmp 0x21d9
cmpl $0x0, -0x1c(%rbp)
je 0x2111
movl -0x1c(%rbp), %edi
leaq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0x1140
movl -0x14(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x210c
movl -0x14(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x14(%rbp)
jmp 0x21d1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1150
cmpl $-0x1, %eax
jne 0x21cf
movq 0x2ebf(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1170
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xf78(%rip), %rsi       # 0x30e5
movb $0x0, %al
callq 0x1110
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x21af
jmp 0x2198
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
jmp 0x217b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x1040
movl $0x1, %edi
callq 0x1160
jmp 0x21d1
jmp 0x21d3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/sh.c
// Function: main
int main(int argc, char **argv){
    signal(SIGINT, sigint_handler);
    alias_hashmap = hashmap_init(100);
    struct sh_command *command = NULL;
    if(argc > 1){
        struct sh_args *args = calloc(1, sizeof(struct sh_args));
        if(args == NULL){
            fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        }
        args = parse_arg(args, argc, argv);
        if(args->command){
            command = parse_command(args->command, strlen(args->command));
            call_command(command);
            free(command);
            return 0;
        }
    }
    char *buffer = calloc(4096, sizeof(char));
    while(1){
        write(STDOUT_FILENO, SH_PROMPT, strlen(SH_PROMPT));
        ssize_t n = 0;
        n += read(STDIN_FILENO, buffer, 4096);
        if(n == 0){
            sh_exit(0);
        }
        else if(n == 1){
            continue;
        }
        buffer[n-1] = '\0';
        command = parse_command(buffer, n);
        call_command(command);
        free(command);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, %edi
leaq -0xae2(%rip), %rsi      # 0x1730
callq 0x1100
movl $0x64, %edi
callq 0x1380
movq %rax, 0x2eb8(%rip)      # 0x50e0
movq $0x0, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x22f6
movl $0x1, %edi
movl $0x10, %esi
callq 0x10e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2292
movq 0x2d9d(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1170
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0xe1c(%rip), %rsi       # 0x30a7
movb $0x0, %al
callq 0x1110
movq -0x20(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1790
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x22f4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1090
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2050
movq -0x18(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
jmp 0x22f6
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10e0
movq %rax, -0x28(%rbp)
movl $0x1, %edi
leaq 0xcef(%rip), %rsi       # 0x3004
movl $0xb, %edx
callq 0x1080
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rsi
xorl %edi, %edi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10d0
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x234f
xorl %edi, %edi
callq 0x1770
jmp 0x235a
cmpq $0x1, -0x30(%rbp)
jne 0x2358
jmp 0x2309
jmp 0x235a
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2050
movq -0x18(%rbp), %rdi
callq 0x1040
jmp 0x2309