LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: states(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int states(string fname) {
    int number_of_lines = 0;
    string line;
    ifstream myfile(fname);
    
    while (std::getline(myfile, line))
        ++number_of_lines;
    
    return number_of_lines;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2250
movq -0x250(%rbp), %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x22f0
jmp 0x2f20
jmp 0x2f22
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2060
movq %rax, -0x258(%rbp)
jmp 0x2f3b
movq -0x258(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2210
movb %al, -0x259(%rbp)
jmp 0x2f59
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x2f65
jmp 0x2fa4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x2fd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x2070
jmp 0x2fd1
movl -0xc(%rbp), %eax
movl %eax, -0x260(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x2070
leaq -0x30(%rbp), %rdi
callq 0x2140
movl -0x260(%rbp), %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2140
movq -0x240(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: start_parser()
void start_parser(void)
{
    int ntoken;
    
    ntoken = yylex();
    
    while(ntoken!=DOLLAR) {
        
        
        //printTokens(ntoken);
        printf("%d ",ntoken);
        ntoken = yylex();
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x51c0
movl %eax, -0x4(%rbp)
cmpl $0x9, -0x4(%rbp)
je 0x3021
movl -0x4(%rbp), %esi
leaq 0x4072(%rip), %rdi      # 0x7082
movb $0x0, %al
callq 0x2040
callq 0x51c0
movl %eax, -0x4(%rbp)
jmp 0x3000
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: print_table_to_console(char (*) [16])
void print_table_to_console(char x[row][col]){
    
    
    
    printf("\t");
    for (int st=1; st<=MAX_STATES; st++) {
        for (int sy = 1; sy<=MAX_SYMBOLS; sy++) {
            printf("%s\t",x[getValueFromMatrix(st, sy)]);
        }
        printf("\n");
        printf("\t");

    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4045(%rip), %rdi      # 0x7088
movb $0x0, %al
callq 0x2040
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x8202(%rip), %eax      # 0xb25c
jg 0x30c9
movl $0x1, -0x10(%rbp)
cmpl $0xe, -0x10(%rbp)
jg 0x30a2
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x25e0
movq -0x18(%rbp), %rsi
cltq
shlq $0x4, %rax
addq %rax, %rsi
leaq 0x3ff6(%rip), %rdi      # 0x7086
movb $0x0, %al
callq 0x2040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3063
leaq 0x4000(%rip), %rdi      # 0x70a9
movb $0x0, %al
callq 0x2040
leaq 0x3fd1(%rip), %rdi      # 0x7088
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3051
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: run(char (*) [16], _IO_FILE*)
void run(char x[row][col], FILE *file)
{

    read_table(file,x);
    print_table_to_console(x);
    

    int accepted = slr(x);
    
    if(accepted==1)
            printf("\nProgram parsed successfully!!\n\n");
    else
         printf("\nProgram parsed successfully!!\n\n");
    


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x26b0
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x2830
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x3118
leaq 0x3f7b(%rip), %rdi      # 0x708a
movb $0x0, %al
callq 0x2040
jmp 0x3126
leaq 0x3f6b(%rip), %rdi      # 0x708a
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: main
int main(int argc, char *argv[] )
{
    if ( argc != 2 ) /* argc should be 2 for correct execution */
    {
        
        printf( "usage: %s filename", argv[0] );
    }
    else
    {
        char x[row][col];
        FILE *file = fopen( argv[1], "r" );
        MAX_STATES = states(argv[1]);
        MAX_STATES -= 2;

        if ( file == 0 )
        {
            printf( "Could not open file\n" );
        }
        else
        {
            //start_parser();
            run(x, file);
        }
    }
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1fb0, %rsp           # imm = 0x1FB0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x3169
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x3f4e(%rip), %rdi      # 0x70ab
movb $0x0, %al
callq 0x2040
jmp 0x3278
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3f46(%rip), %rsi      # 0x70be
callq 0x21e0
movq %rax, -0x1f58(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x1fa0(%rbp)
leaq -0x1f79(%rbp), %rdi
movq %rdi, -0x1f98(%rbp)
callq 0x2350
movq -0x1fa0(%rbp), %rsi
movq -0x1f98(%rbp), %rdx
leaq -0x1f78(%rbp), %rdi
callq 0x2240
jmp 0x31c2
leaq -0x1f78(%rbp), %rdi
callq 0x2ee0
movl %eax, -0x1fa4(%rbp)
jmp 0x31d6
movl -0x1fa4(%rbp), %eax
movl %eax, 0x807a(%rip)      # 0xb25c
leaq -0x1f78(%rbp), %rdi
callq 0x2140
leaq -0x1f79(%rbp), %rdi
callq 0x21d0
movl 0x805c(%rip), %eax      # 0xb25c
subl $0x2, %eax
movl %eax, 0x8053(%rip)      # 0xb25c
cmpq $0x0, -0x1f58(%rbp)
jne 0x3263
leaq 0x3ea6(%rip), %rdi      # 0x70c0
movb $0x0, %al
callq 0x2040
jmp 0x3276
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f88(%rbp)
movl %eax, -0x1f8c(%rbp)
jmp 0x3255
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f88(%rbp)
movl %eax, -0x1f8c(%rbp)
leaq -0x1f78(%rbp), %rdi
callq 0x2140
leaq -0x1f79(%rbp), %rdi
callq 0x21d0
jmp 0x3283
leaq -0x1f50(%rbp), %rdi
movq -0x1f58(%rbp), %rsi
callq 0x30d0
jmp 0x3278
xorl %eax, %eax
addq $0x1fb0, %rsp           # imm = 0x1FB0
popq %rbp
retq
movq -0x1f88(%rbp), %rdi
callq 0x2340
nop
// File: sangwoojun[P]rv32emulator/cachesim.cpp
// Function: cache_peek(unsigned int, int)
int cache_peek(uint32_t addr, int bytes) {
	uint32_t idx = cache_calc_idx(addr);
	uint32_t tag = cache_calc_tag(addr);

	if ( cache_calc_idx(addr) != cache_calc_idx(addr+bytes-1) ) {
		printf( "ERROR: request spans line boundary\n" );
	}

	for ( int i = 0; i < CACHE_WAYS; i++ ) {
		if ( g_tags[idx][i] == tag && is_flag_valid(g_flags[idx][i]) ) return i;
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x25c0
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x25e0
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %edi
callq 0x25c0
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %edi
addl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x25c0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
je 0x26f4
leaq 0x8917(%rip), %rdi      # 0xb004
movb $0x0, %al
callq 0x2040
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jge 0x2757
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x10263(%rip), %rax     # 0x12970
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x274a
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x10644(%rip), %rax     # 0x12d70
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2640
testb $0x1, %al
jne 0x2742
jmp 0x274a
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x275e
jmp 0x274c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26fb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sangwoojun[P]rv32emulator/cachesim.cpp
// Function: cache_write(unsigned int, unsigned int, int)
void cache_write(uint32_t addr, uint32_t data, int bytes) {
	uint32_t idx = cache_calc_idx(addr);
	uint32_t tag = cache_calc_tag(addr);
	uint32_t wid = cache_calc_word_idx(addr);
	int boff = (addr&(0x3));
	int way = cache_peek(addr,bytes);
	if ( way < 0 ) {
		return;
	}
	

	switch ( bytes ) {
		case 1: {
			uint8_t* cl = (((uint8_t*)&(g_cache[idx][way][wid]))+boff);
			*cl = (data&(0xff));
			break;
		}
		case 2: {
			uint8_t* cl = (((uint8_t*)&(g_cache[idx][way][wid]))+boff);
			*(uint16_t*)cl = (data&(0xffff));
			break;
		}
		case 4: {
			g_cache[idx][way][wid] = data;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
callq 0x25c0
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x25e0
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edi
callq 0x25f0
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x26a0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x27c4
jmp 0x289f
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x27ec
jmp 0x27d1
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x2831
jmp 0x27db
movl -0x34(%rbp), %eax
subl $0x4, %eax
je 0x2878
jmp 0x289f
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xfd78(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
jmp 0x289f
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xfd33(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, (%rax)
jmp 0x289f
movl -0x8(%rbp), %edx
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xfce9(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x18(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sangwoojun[P]rv32emulator/cachesim.cpp
// Function: cache_read(unsigned int, int)
uint32_t cache_read(uint32_t addr, int bytes) {
	uint32_t idx = cache_calc_idx(addr);
	uint32_t tag = cache_calc_tag(addr);
	uint32_t wid = cache_calc_word_idx(addr);
	int boff = (addr&(0x3));
	int way = cache_peek(addr,bytes);
	if ( way < 0 ) {
		return 0xffffffff;
	}
	
	uint32_t ret = 0xffffffff;
	switch ( bytes ) {
		case 1: {
			uint8_t* cl = (((uint8_t*)&(g_cache[idx][way][wid]))+boff);
			ret = *cl;
			break;
		}
		case 2: {
			uint8_t* cl = (((uint8_t*)&(g_cache[idx][way][wid]))+boff);
			ret = *(uint16_t*)cl;
			break;
		}
		case 4: {
			ret = g_cache[idx][way][wid];
			break;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x25c0
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x25e0
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %edi
callq 0x25f0
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x26a0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x2908
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29e2
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x2937
jmp 0x291c
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x2976
jmp 0x2926
movl -0x3c(%rbp), %eax
subl $0x4, %eax
je 0x29b5
jmp 0x29dc
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xfc2d(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x29dc
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xfbee(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x29dc
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xfbaf(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sangwoojun[P]rv32emulator/cachesim.cpp
// Function: cache_update(unsigned int, unsigned int)
void cache_update(uint32_t addr, uint32_t data) {
	uint32_t idx = cache_calc_idx(addr);
	uint32_t tag = cache_calc_tag(addr);
	uint32_t wid = cache_calc_word_idx(addr);
	int way = cache_peek(addr,4);
	if ( way < 0 ) {
		for ( int i = 0; i < CACHE_WAYS; i++ ) {
			if ( !is_flag_valid(g_flags[idx][i]) ) {
				way = i;
				break;
			}
		}
	}

	g_cache[idx][way][wid] = data;
	g_tags[idx][way] = tag;
	g_flags[idx][way] = set_flag_valid(g_flags[idx][way]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x25c0
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
callq 0x25e0
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x25f0
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edi
movl $0x4, %esi
callq 0x26a0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x2a79
movl $0x0, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jge 0x2a77
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x10322(%rip), %rax     # 0x12d70
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2640
testb $0x1, %al
jne 0x2a6a
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x2a77
jmp 0x2a6c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a3c
jmp 0x2a79
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xfae8(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xfec1(%rip), %rax      # 0x12970
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x102a7(%rip), %rax     # 0x12d70
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2660
movb %al, %dl
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x10289(%rip), %rax     # 0x12d70
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sangwoojun[P]rv32emulator/cachesim.cpp
// Function: cache_flush(unsigned int, unsigned char*)
void cache_flush(uint32_t addr, uint8_t* mem) {
	uint32_t idx = cache_calc_idx(addr);
	//uint32_t wid = cache_calc_word_idx(addr);

	//choose way
	//int way = rand()%CACHE_WAYS;
	int way = 0;

	if (!is_flag_valid(g_flags[idx][way])) return;
	uint32_t tag = g_tags[idx][way];

	//write to mem
	//set flag to empty
	for ( int i = 0; i < CACHE_LINE_WORD; i++ ) {
		uint32_t data = g_cache[idx][way][i];
		uint32_t maddr = cache_reassemble_addr(idx, tag) + (i*4);
		*(uint32_t*)(mem+maddr) = data;
		g_flags[idx][way] = set_flag_invalid(g_flags[idx][way]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x25c0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x10243(%rip), %rax     # 0x12d70
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2640
testb $0x1, %al
jne 0x2b46
jmp 0x2c01
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xfe1e(%rip), %rax      # 0x12970
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x1, -0x20(%rbp)
jge 0x2c01
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xf9f0(%rip), %rax      # 0x12570
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x2620
movl -0x20(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %edx, (%rax,%rcx)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x101a5(%rip), %rax     # 0x12d70
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2680
movb %al, %dl
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x10187(%rip), %rax     # 0x12d70
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b6a
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sangwoojun[P]rv32emulator/emulator.cpp
// Function: parse_imm(char*, int, int, bool)
uint32_t parse_imm(char* tok, int bits, int line, bool strict = true) {
	if ( !(tok[0]>='0'&&tok[0]<='9') && tok[0] != '-' && strict) {
		print_syntax_error(line, "Malformed immediate value" );
	}
	long int imml = strtol(tok, NULL, 0);


	if (imml > ((1<<bits)-1) || imml < -(1<<(bits-1)) ) {
		printf( "Syntax error at token %s\n", tok);
		exit(1);
	}
	uint64_t uv = *(uint64_t*)&imml;
	uint32_t hv = (uv&UINT32_MAX);

	return hv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x3751
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x3772
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x3772
testb $0x1, -0x11(%rbp)
je 0x3772
movl -0x10(%rbp), %edi
leaq 0x7d5e(%rip), %rsi      # 0xb4cb
callq 0x2c90
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2300
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jg 0x37bd
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl %ecx, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x37d9
movq -0x8(%rbp), %rsi
leaq 0x7d1d(%rip), %rdi      # 0xb4e5
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x2250
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x28(%rbp), %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sangwoojun[P]rv32emulator/emulator.cpp
// Function: parse_mem(char*, int*, unsigned int*, int, int)
void parse_mem(char* tok, int* reg, uint32_t* imm, int bits, int line) {
	char* imms = strtok(tok, "(");
	char* regs = strtok(NULL, ")");
	*imm = parse_imm(imms, bits, line);
	*reg = parse_reg(regs, line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7cd9(%rip), %rsi      # 0xb4ff
callq 0x2390
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x7cc7(%rip), %rsi      # 0xb501
callq 0x2390
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl $0x1, %ecx
callq 0x3720
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
movl $0x1, %edx
callq 0x3250
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sangwoojun[P]rv32emulator/emulator.cpp
// Function: mem_write(unsigned char*, unsigned int, unsigned int, instr_type)
void mem_write(uint8_t* mem, uint32_t addr, uint32_t data, instr_type op) {
	//printf( "Storing %x to %d\n", data, addr );
	int bytes = 0;
	switch (op ) {
		case SB: bytes = 1; break;
		case SH: bytes = 2; break;
		case SW: bytes = 4; break;
	}
	if ( addr < MEM_BYTES && addr + bytes <= MEM_BYTES ) {
		mem_write_reqs ++;
		int way = cache_peek(addr,bytes);
		if ( way < 0 ) {
			cache_flush(addr, mem);
			uint32_t waddr = addr-(addr&((1<<(2+CACHE_LINE_WORD_SZ))-1));
			for ( int i = 0; i < CACHE_LINE_WORD; i++ ) {
				cache_update(waddr+(i*4), *(uint32_t*)&(mem[waddr+(i*4)]));
			}
			mem_flush_words += CACHE_LINE_WORD;
		} else {
			cache_write_hits ++;
		}
		cache_write(addr,data,bytes);
	} else if ( addr == MEM_BYTES ) {
		printf( "[System output]: 0x%x\n", data );
	} else {
		printf( "0x%x -- 0x%x\n", addr, data);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x16, %eax
je 0x38bd
jmp 0x38a9
movl -0x28(%rbp), %eax
subl $0x17, %eax
je 0x38c6
jmp 0x38b3
movl -0x28(%rbp), %eax
subl $0x23, %eax
je 0x38cf
jmp 0x38d6
movl $0x1, -0x18(%rbp)
jmp 0x38d6
movl $0x2, -0x18(%rbp)
jmp 0x38d6
movl $0x4, -0x18(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jae 0x399d
movl -0xc(%rbp), %eax
addl -0x18(%rbp), %eax
cmpl $0x10000, %eax          # imm = 0x10000
ja 0x399d
movl 0xf5ba(%rip), %eax      # 0x12eb4
addl $0x1, %eax
movl %eax, 0xf5b1(%rip)      # 0x12eb4
movl -0xc(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x26a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x397e
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2b00
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %ecx
andl $0x3, %ecx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0x396d
movl -0x20(%rbp), %edi
movl -0x24(%rbp), %eax
shll $0x2, %eax
addl %eax, %edi
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %edx
shll $0x2, %edx
addl %edx, %ecx
movl %ecx, %ecx
movl (%rax,%rcx), %esi
callq 0x29f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3938
movl 0xf53d(%rip), %eax      # 0x12eb0
addl $0x1, %eax
movl %eax, 0xf534(%rip)      # 0x12eb0
jmp 0x398d
movl 0xf534(%rip), %eax      # 0x12eb8
addl $0x1, %eax
movl %eax, 0xf52b(%rip)      # 0x12eb8
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2770
jmp 0x39cf
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jne 0x39b9
movl -0x10(%rbp), %esi
leaq 0x7b53(%rip), %rdi      # 0xb503
movb $0x0, %al
callq 0x2040
jmp 0x39cd
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x7b54(%rip), %rdi      # 0xb51a
movb $0x0, %al
callq 0x2040
jmp 0x39cf
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sangwoojun[P]rv32emulator/emulator.cpp
// Function: append_source(char const*, char const*, char const*, char const*, source*, instr*)
void append_source(const char* op, const char* a1, const char* a2, const char* a3, source* src, instr* i) {
	char tbuf[128]; // not safe... static size... but should be okay since label length enforced
	if ( op && a1 && !a2 && !a3 ) {
		sprintf(tbuf, "%s %s", op, a1);
	} else if ( op && a1 && a2 && !a3 ) {
		sprintf(tbuf, "%s %s, %s", op, a1, a2);
	} else if ( op && a1 && a2 && a3 ) {
		sprintf(tbuf, "%s %s, %s, %s", op, a1, a2, a3);
	} else {
		return;
	}
	int slen = strlen(tbuf);
	if ( slen + src->offset < MAX_SRC_LEN ) {
		strncpy(src->src+src->offset, tbuf, strlen(tbuf));

		i->psrc = src->src+src->offset;
		src->offset += slen+1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3bd1
cmpq $0x0, -0x10(%rbp)
je 0x3bd1
cmpq $0x0, -0x18(%rbp)
jne 0x3bd1
cmpq $0x0, -0x20(%rbp)
jne 0x3bd1
leaq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x7963(%rip), %rsi      # 0xb528
movb $0x0, %al
callq 0x2060
jmp 0x3c5c
cmpq $0x0, -0x8(%rbp)
je 0x3c10
cmpq $0x0, -0x10(%rbp)
je 0x3c10
cmpq $0x0, -0x18(%rbp)
je 0x3c10
cmpq $0x0, -0x20(%rbp)
jne 0x3c10
leaq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x7927(%rip), %rsi      # 0xb52e
movb $0x0, %al
callq 0x2060
jmp 0x3c5a
cmpq $0x0, -0x8(%rbp)
je 0x3c53
cmpq $0x0, -0x10(%rbp)
je 0x3c53
cmpq $0x0, -0x18(%rbp)
je 0x3c53
cmpq $0x0, -0x20(%rbp)
je 0x3c53
leaq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x78ee(%rip), %rsi      # 0xb538
movb $0x0, %al
callq 0x2060
jmp 0x3c58
jmp 0x3cfb
jmp 0x3c5a
jmp 0x3c5c
leaq -0xb0(%rbp), %rdi
callq 0x2100
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
movq -0x28(%rbp), %rcx
addl 0x8(%rcx), %eax
cmpl $0x100000, %eax         # imm = 0x100000
jge 0x3cfb
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0xc8(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2100
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
callq 0x2120
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x88(%rax)
movl -0xb4(%rbp), %ecx
addl $0x1, %ecx
movq -0x28(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sangwoojun[P]rv32emulator/emulator.cpp
// Function: parse_data_element(int, int, unsigned char*, int)
int parse_data_element(int line, int size, uint8_t* mem, int offset) {
	while (char* t = strtok(NULL, " \t\r\n") ) {
		errno = 0;
		int64_t v = strtol(t, NULL, 0);
		int64_t vs = (v>>(size*8));
		if ( errno == ERANGE || (vs > 0 && vs != -1 ) ) {
			printf( "Value out of bounds at line %d : %s\n", line, t);
			exit(2);
		}
		//printf ( "parse_data_element %d: %d %ld %d %d\n", line, size, v, errno, sizeof(long int));
		memcpy(&mem[offset], &v, size);
		offset += size;
		//strtok(NULL, ",");
	}
	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x77a6(%rip), %rsi      # 0xb556
callq 0x2390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3e52
callq 0x2030
movl $0x0, (%rax)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2300
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x8(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
sarq %cl, %rax
movq %rax, -0x30(%rbp)
callq 0x2030
cmpl $0x22, (%rax)
je 0x3e0d
cmpq $0x0, -0x30(%rbp)
jle 0x3e2c
cmpq $-0x1, -0x30(%rbp)
je 0x3e2c
movl -0x4(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x7740(%rip), %rdi      # 0xb55b
movb $0x0, %al
callq 0x2040
movl $0x2, %edi
callq 0x2250
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movslq -0x8(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x2190
movl -0x8(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3da5
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sangwoojun[P]rv32emulator/emulator.cpp
// Function: parse_data_zero(int, unsigned char*, int)
int parse_data_zero(int line, uint8_t* mem, int offset) {
	char* t = strtok(NULL, " \t\r\n");
	int bytes = atoi(t);
	memset(&mem[offset], 0, bytes);

	return offset + bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x76d9(%rip), %rsi      # 0xb556
callq 0x2390
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2380
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movslq -0x24(%rbp), %rdx
xorl %esi, %esi
callq 0x2140
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeIsWideChar(unsigned long)
static int unicodeIsWideChar(unsigned long cp)
{
    int i;
    for (i = 0; i < unicodeWideCharTableSize; i++) {
        if (unicodeWideCharTable[i][0] <= cp && cp <= unicodeWideCharTable[i][1]) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xb5a0(%rip), %eax      # 0x12348
jge 0x6df7
movslq -0x14(%rbp), %rcx
leaq 0xb59b(%rip), %rax      # 0x12350
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x6dea
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0xb57c(%rip), %rcx      # 0x12350
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
ja 0x6dea
movl $0x1, -0x4(%rbp)
jmp 0x6dfe
jmp 0x6dec
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6d9f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::Readline(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool Readline(const char *prompt, std::string& line) {
    if (isUnsupportedTerm()) {
        printf("%s",prompt);
        fflush(stdout);
        std::getline(std::cin, line);
        return false;
    } else {
        return linenoiseRaw(prompt, line);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x7190
testb $0x1, %al
jne 0x6f0b
jmp 0x6f42
movq -0x10(%rbp), %rsi
leaq 0x462d(%rip), %rdi      # 0xb543
movb $0x0, %al
callq 0x2040
movq 0x8094(%rip), %rax      # 0xefb8
movq (%rax), %rdi
callq 0x2230
movq -0x18(%rbp), %rsi
movq 0x80a9(%rip), %rdi      # 0xefe0
callq 0x2070
movb $0x0, -0x1(%rbp)
jmp 0x6f54
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7210
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::AddHistory(char const*)
inline bool AddHistory(const char* line) {
    if (history_max_len == 0) return false;

    /* Don't add duplicated lines. */
    if (!history.empty() && history.back() == line) return false;

    /* If we reached the max length, remove the older line. */
    if (history.size() == history_max_len) {
        history.erase(history.begin());
    }
    history.push_back(line);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0xb5dc(%rip)      # 0x12550
jne 0x6f7f
movb $0x0, -0x1(%rbp)
jmp 0x707c
leaq 0xbf12(%rip), %rdi      # 0x12e98
callq 0x8030
testb $0x1, %al
jne 0x6fb6
leaq 0xbf02(%rip), %rdi      # 0x12e98
callq 0x9950
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x9920
testb $0x1, %al
jne 0x6fad
jmp 0x6fb6
movb $0x0, -0x1(%rbp)
jmp 0x707c
leaq 0xbedb(%rip), %rdi      # 0x12e98
callq 0x8b60
cmpq 0xb587(%rip), %rax      # 0x12550
jne 0x6ffc
leaq 0xbec6(%rip), %rdi      # 0x12e98
callq 0x9a00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9a30
movq -0x18(%rbp), %rsi
leaq 0xbea5(%rip), %rdi      # 0x12e98
callq 0x9990
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x23f0
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x22d0
jmp 0x7024
leaq 0xbe6d(%rip), %rdi      # 0x12e98
leaq -0x48(%rbp), %rsi
callq 0x9a70
jmp 0x7036
leaq -0x48(%rbp), %rdi
callq 0x2160
leaq -0x49(%rbp), %rdi
callq 0x2200
movb $0x1, -0x1(%rbp)
jmp 0x707c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7071
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2160
leaq -0x49(%rbp), %rdi
callq 0x2200
jmp 0x7087
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x23e0
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::isUnsupportedTerm()
inline bool isUnsupportedTerm(void) {
#ifndef _WIN32
    char *term = getenv("TERM");
    int j;

    if (term == NULL) return false;
    for (j = 0; unsupported_term[j]; j++)
        if (!strcasecmp(term,unsupported_term[j])) return true;
#endif
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x47e8(%rip), %rdi      # 0xb987
callq 0x2260
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x71b5
movb $0x0, -0x1(%rbp)
jmp 0x7202
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x8059(%rip), %rax      # 0xf220
cmpq $0x0, (%rax,%rcx,8)
je 0x71fe
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x8043(%rip), %rax      # 0xf220
movq (%rax,%rcx,8), %rsi
callq 0x2210
cmpl $0x0, %eax
jne 0x71f1
movb $0x1, -0x1(%rbp)
jmp 0x7202
jmp 0x71f3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x71bc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::linenoiseRaw(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool linenoiseRaw(const char *prompt, std::string& line) {
    bool quit = false;

    if (!isatty(STDIN_FILENO)) {
        /* Not a tty: read from file / pipe. */
        std::getline(std::cin, line);
    } else {
        /* Interactive editing. */
        if (enableRawMode(STDIN_FILENO) == false) {
            return quit;
        }

        char buf[LINENOISE_MAX_LINE];
        auto count = linenoiseEdit(STDIN_FILENO, STDOUT_FILENO, buf, LINENOISE_MAX_LINE, prompt);
        if (count == -1) {
            quit = true;
        } else {
            line.assign(buf, count);
        }

        disableRawMode(STDIN_FILENO);
        printf("\n");
    }
    return quit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorl %edi, %edi
callq 0x23d0
cmpl $0x0, %eax
jne 0x7245
movq -0x18(%rbp), %rsi
movq 0x7da2(%rip), %rdi      # 0xefe0
callq 0x2070
jmp 0x72bd
xorl %edi, %edi
callq 0x72e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7260
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x72c5
leaq -0x1020(%rbp), %rdx
movq -0x10(%rbp), %r8
xorl %edi, %edi
movl $0x1, %esi
movl $0x1000, %ecx           # imm = 0x1000
callq 0x73b0
movl %eax, -0x1024(%rbp)
cmpl $-0x1, -0x1024(%rbp)
jne 0x7291
movb $0x1, -0x19(%rbp)
jmp 0x72a8
movq -0x18(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movslq -0x1024(%rbp), %rdx
callq 0x22b0
xorl %edi, %edi
callq 0x79e0
leaq 0x455c(%rip), %rdi      # 0xb812
movb $0x0, %al
callq 0x2040
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::getColumns(int, int)
inline int getColumns(int ifd, int ofd) {
#ifdef _WIN32
    CONSOLE_SCREEN_BUFFER_INFO b;

    if (!GetConsoleScreenBufferInfo(hOut, &b)) return 80;
    return b.srWindow.Right - b.srWindow.Left;
#else
    struct winsize ws;

    if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
        /* ioctl() failed. Try to query the terminal itself. */
        int start, cols;

        /* Get the initial position so we can restore it later. */
        start = getCursorPosition(ifd,ofd);
        if (start == -1) goto failed;

        /* Go to right margin and get position. */
        if (write(ofd,"\x1b[999C",6) != 6) goto failed;
        cols = getCursorPosition(ifd,ofd);
        if (cols == -1) goto failed;

        /* Restore position. */
        if (cols > start) {
            char seq[32];
            snprintf(seq,32,"\x1b[%dD",cols-start);
            if (write(ofd,seq,strlen(seq)) == -1) {
                /* Can't recover... */
            }
        }
        return cols;
    } else {
        return ws.ws_col;
    }

failed:
    return 80;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x2310
cmpl $-0x1, %eax
je 0x7a85
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0x7b2d
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x8830
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x7a9e
jmp 0x7b36
movl -0xc(%rbp), %edi
leaq 0x3ef6(%rip), %rsi      # 0xb99e
movl $0x6, %edx
callq 0x20a0
cmpq $0x6, %rax
je 0x7aba
jmp 0x7b36
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x8830
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x7ad0
jmp 0x7b36
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x7b25
leaq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %ecx
subl -0x18(%rbp), %ecx
movl $0x20, %esi
leaq 0x3eb7(%rip), %rdx      # 0xb9a5
movb $0x0, %al
callq 0x23b0
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2100
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x20a0
cmpq $-0x1, %rax
jne 0x7b23
jmp 0x7b23
jmp 0x7b25
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7b3d
movzwl -0x12(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7b3d
movl $0x50, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeReadUTF8Char(int, char*, int*)
inline int unicodeReadUTF8Char(int fd, char* buf, int* cp)
{
    int nread = read(fd,&buf[0],1);

    if (nread <= 0) { return nread; }

    unsigned char byte = buf[0];

    if ((byte & 0x80) == 0) {
        ;
    } else if ((byte & 0xE0) == 0xC0) {
        nread = read(fd,&buf[1],1);
        if (nread <= 0) { return nread; }
    } else if ((byte & 0xF0) == 0xE0) {
        nread = read(fd,&buf[1],2);
        if (nread <= 0) { return nread; }
    } else if ((byte & 0xF8) == 0xF0) {
        nread = read(fd,&buf[1],3);
        if (nread <= 0) { return nread; }
    } else {
        return -1;
    }

    return unicodeUTF8CharToCodePoint(buf, 4, cp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2330
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x7b88
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7c73
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x7ba4
jmp 0x7c5e
movzbl -0x1d(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x7bdf
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edx
callq 0x2330
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x7bdd
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7c73
jmp 0x7c5c
movzbl -0x1d(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x7c17
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl $0x2, %edx
callq 0x2330
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x7c15
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7c73
jmp 0x7c5a
movzbl -0x1d(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x7c4f
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl $0x3, %edx
callq 0x2330
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x7c4d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7c73
jmp 0x7c58
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c73
jmp 0x7c5a
jmp 0x7c5c
jmp 0x7c5e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4, %esi
callq 0x8910
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::linenoiseEditBackspace(linenoise::linenoiseState*)
inline void linenoiseEditBackspace(struct linenoiseState *l) {
    if (l->pos > 0 && l->len > 0) {
        int glen = unicodePrevGraphemeLen(l->buf,l->pos);
        memmove(l->buf+l->pos-glen,l->buf+l->pos,l->len-l->pos);
        l->pos-=glen;
        l->len-=glen;
        l->buf[l->len] = '\0';
        refreshLine(l);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jle 0x81a2
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jle 0x81a2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x8d30
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x38(%rcx), %eax
movslq %eax, %rdx
callq 0x23c0
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x38(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x8280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::linenoiseEditDelete(linenoise::linenoiseState*)
inline void linenoiseEditDelete(struct linenoiseState *l) {
    if (l->len > 0 && l->pos < l->len) {
        int glen = unicodeGraphemeLen(l->buf,l->len,l->pos);
        memmove(l->buf+l->pos,l->buf+l->pos+glen,l->len-l->pos-glen);
        l->len-=glen;
        l->buf[l->len] = '\0';
        refreshLine(l);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jle 0x826e
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x826e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %edx
callq 0x8e80
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x38(%rcx), %eax
subl -0xc(%rbp), %eax
movslq %eax, %rdx
callq 0x23c0
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x8280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::refreshLine(linenoise::linenoiseState*)
inline void refreshLine(struct linenoiseState *l) {
    if (mlmode)
        refreshMultiLine(l);
    else
        refreshSingleLine(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0xac72(%rip)      # 0x12f05
je 0x82a0
movq -0x8(%rbp), %rdi
callq 0x8fb0
jmp 0x82a9
movq -0x8(%rbp), %rdi
callq 0x93c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::linenoiseEditHistoryNext(linenoise::linenoiseState*, int)
inline void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
    if (history.size() > 1) {
        /* Update the current history entry before to
         * overwrite it with the next one. */
        history[history.size() - 1 - l->history_index] = l->buf;
        /* Show the new entry */
        l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
        if (l->history_index < 0) {
            l->history_index = 0;
            return;
        } else if (l->history_index >= (int)history.size()) {
            l->history_index = static_cast<int>(history.size())-1;
            return;
        }
        memset(l->buf, 0, l->buflen);
        strcpy(l->buf,history[history.size() - 1 - l->history_index].c_str());
        l->len = l->pos = static_cast<int>(strlen(l->buf));
        refreshLine(l);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xab22(%rip), %rdi      # 0x12e98
callq 0x8b60
cmpq $0x1, %rax
jbe 0x84c4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0xab00(%rip), %rdi      # 0x12e98
callq 0x8b60
movq %rax, %rsi
subq $0x1, %rsi
movq -0x8(%rbp), %rax
movslq 0x4c(%rax), %rax
subq %rax, %rsi
leaq 0xaae2(%rip), %rdi      # 0x12e98
callq 0x8bf0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x22c0
movl -0xc(%rbp), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %eax
cmpl $0x1, %edx
cmovel %eax, %ecx
movq -0x8(%rbp), %rax
addl 0x4c(%rax), %ecx
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
jge 0x83fe
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
jmp 0x84c4
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x1c(%rbp)
leaq 0xaa89(%rip), %rdi      # 0x12e98
callq 0x8b60
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x843b
leaq 0xaa73(%rip), %rdi      # 0x12e98
callq 0x8b60
movl %eax, %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0x84c4
jmp 0x843d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdx
xorl %esi, %esi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0xaa31(%rip), %rdi      # 0x12e98
callq 0x8b60
movq %rax, %rsi
subq $0x1, %rsi
movq -0x8(%rbp), %rax
movslq 0x4c(%rax), %rax
subq %rax, %rsi
leaq 0xaa13(%rip), %rdi      # 0x12e98
callq 0x8bf0
movq %rax, %rdi
callq 0x20e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x21b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2100
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x8280
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::linenoiseEditDeletePrevWord(linenoise::linenoiseState*)
inline void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
    int old_pos = l->pos;
    int diff;

    while (l->pos > 0 && l->buf[l->pos-1] == ' ')
        l->pos--;
    while (l->pos > 0 && l->buf[l->pos-1] != ' ')
        l->pos--;
    diff = old_pos - l->pos;
    memmove(l->buf+l->pos,l->buf+old_pos,l->len-old_pos+1);
    l->len -= diff;
    refreshLine(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x38(%rcx)
movb %al, -0x11(%rbp)
jle 0x8747
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x8750
jmp 0x875f
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x8716
jmp 0x8761
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x38(%rcx)
movb %al, -0x12(%rbp)
jle 0x8792
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x879b
jmp 0x87aa
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x8761
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0x38(%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x23c0
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x8280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)