LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: initialise
void initialise(int line){
        initq(&data);
        inite(&states);
        inite(&redo);
        getmaxyx(stdscr,by,bx);
        return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xa38e(%rip), %rdi      # 0xd1e0
callq 0x2840
leaq 0xa362(%rip), %rdi      # 0xd1c0
callq 0x7680
leaq 0xa366(%rip), %rdi      # 0xd1d0
callq 0x7680
xorl %eax, %eax
movq 0xa168(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x2e93
movq 0xa15c(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2e9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x8(%rbp)
jmp 0x2e9d
movl -0x8(%rbp), %ecx
leaq 0xa2ed(%rip), %rax      # 0xd194
movl %ecx, (%rax)
xorl %eax, %eax
movq 0xa12e(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x2ecd
movq 0xa122(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ed7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x2ed7
movl -0xc(%rbp), %ecx
leaq 0xa2bb(%rip), %rax      # 0xd19c
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: search_char
int search_char(char ch,int param,istack t){
    if(param == 0){
        node *temp = t.store;
        while(temp->next){
            if(ch == temp->val)
                return 1;
            temp = temp->next;
        }
        return 0;
    }
    else{
        point *temp = data.front;
        int i = 0;
        for(; i < param; i++)
            temp = temp->tail;
        node *trav = temp->element.store;
        while(trav->next){
            if(ch == trav->val)
                return 1;
            trav = trav->next;
        }
    }

    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
leaq 0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movb %al, -0x5(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x3164
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x315b
movsbl -0x5(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x314d
movl $0x1, -0x4(%rbp)
jmp 0x31de
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3126
movl $0x0, -0x4(%rbp)
jmp 0x31de
leaq 0xa075(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3197
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3179
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x31d5
movsbl -0x5(%rbp), %eax
movq -0x30(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x31c7
movl $0x1, -0x4(%rbp)
jmp 0x31de
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x31a3
jmp 0x31d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: getwidth
int getwidth(int y){
    point *temp = data.front;
    int i = 0;
    for(; i < y; i++){
        if(temp->tail == NULL)
            break;
        else
            temp = temp->tail;
    }
    if(ipeeps(&temp->element) == '\n')
        return (temp->element.width - 1);    
    else
        return (temp->element.width);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq 0x96fe(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3b1c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3b04
jmp 0x3b1c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3b11
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3af0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2800
cmpl $0xa, %eax
jne 0x3b3d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3b47
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: save
void save(char *fname){
    int fd = open(fname,O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR);
    //int i = 0, fd = open("random.txt", O_WRONLY | O_CREAT ,S_IRUSR | S_IWUSR);
    point *temp = data.front;
    while(temp){
        char *str = (char *)calloc(1,1);
        node *row = temp->element.store;
        char ch[2] = {'\0'};
        str = realloc(str,strlen(str)+1);
        while(row->next){
            write(fd,&row->val,1);
            row = row->next;
        }
        temp = temp->tail;
    }

    close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x2220
movl %eax, -0xc(%rbp)
leaq 0x92f5(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3f8d
movl $0x1, %esi
movq %rsi, %rdi
callq 0x2180
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x2a(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2110
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x2210
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3f7d
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x2070
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3f4f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3ef2
movl -0xc(%rbp), %edi
callq 0x2140
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: get_word
char* get_word(FILE *fp){
    char ch='\0';
    int i = 0;
    char *temp  = (char *)calloc(50,sizeof(char));
    ch = '\0';
    while(ch != EOF){
        ch= fgetc(fp);
        if(ch == 10 || ch == 13 || ch == ' ' || ch == EOF){
            temp[i] = '\0';
            if(ch == EOF)
                return NULL;
            i=0;
            return temp;
        }
        else{
        temp[i] = ch;
        i++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x32, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
je 0x4563
movq -0x10(%rbp), %rdi
callq 0x2130
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
je 0x4517
movsbl -0x11(%rbp), %eax
cmpl $0xd, %eax
je 0x4517
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
je 0x4517
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
jne 0x4547
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
jne 0x4536
movq $0x0, -0x8(%rbp)
jmp 0x4563
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4563
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x44de
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: printopt
void printopt(WINDOW *win, char** dict,int mark,int count){
    int x,y,i;
    x = 1; 
    y = 1;
    box(win,0,0);
    for(i = 0; i < 4 && i < count; i++ ){                        //show 4 or less most relevant words;
        if(mark == i+1){
            wattron(win,A_REVERSE);
            mvwprintw(win,y,x,"%s",dict[i]);
            wattroff(win,A_REVERSE);
        }
        else{
            mvwprintw(win, y, x, "%s", dict[i]);
        }
        y++;
    }
    wrefresh(win);
    return; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x2060
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x4, -0x24(%rbp)
movb %al, -0x25(%rbp)
jge 0x45e1
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x45ed
jmp 0x467f
movl -0x14(%rbp), %eax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4644
movq -0x8(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x2160
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %r8
leaq 0x5ad5(%rip), %rcx      # 0xa0fe
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x22d0
jmp 0x4668
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %r8
leaq 0x5a9d(%rip), %rcx      # 0xa0fe
movb $0x0, %al
callq 0x2100
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x45ca
movq -0x8(%rbp), %rdi
callq 0x20f0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: master_menu
void master_menu(){
    int y,x;
    getyx(stdscr,y,x);
    WINDOW *menu = create_newwin(3,bx,by-3,0);
    //wborder(menu, ' ', ' ', ' ',' ',' ',' ',' ',' ');
    wattron(menu,A_REVERSE);
    mvwprintw(menu,1,1," OPTIONS:F1 | SAVE:F5 | EXIT:F2 | ^X:CUT | ^C:COPY | SUGGESTIONS:TAB | VASU'S TEXT EDITOR | LINE NO.: %d | COORDINATES:(%d,%d)| #LINE:%d",y+stline+1,x,y,(y+stline)/10);
    wattroff(menu,A_REVERSE);
    wrefresh(menu);
    move(y,x);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movq 0x817f(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x4e78
movq 0x8173(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x4e82
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x4e82
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
movq 0x814f(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x4ea9
movq 0x8143(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x4eb3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x4eb3
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x82dc(%rip), %rax      # 0xd19c
movl (%rax), %esi
leaq 0x82cb(%rip), %rax      # 0xd194
movl (%rax), %edx
subl $0x3, %edx
movl $0x3, %edi
xorl %ecx, %ecx
callq 0x2b30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x2160
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %r8d
leaq 0x82a5(%rip), %rax      # 0xd1a4
addl (%rax), %r8d
addl $0x1, %r8d
movl -0x8(%rbp), %r9d
movl -0x4(%rbp), %r10d
movl -0x4(%rbp), %eax
leaq 0x828c(%rip), %rcx      # 0xd1a4
addl (%rcx), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl $0x1, %edx
leaq 0x50f6(%rip), %rcx      # 0xa024
movl %edx, %esi
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x22d0
movq -0x10(%rbp), %rdi
callq 0x20f0
movq 0x807f(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: line_copy
char* line_copy(int y){
    point *temp = data.front;
    while(y--){
        temp = temp->tail;
    }
    int i;
    node * traverse = temp->element.store;
    char *str = (char *)calloc(temp->element.width  + 1,1);
    for(i = 0; i < temp->element.width; i++){
        if(traverse->val == '\n')
            break;
        str[i] = traverse->val;
        traverse = traverse->next;
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
leaq 0x824e(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
je 0x4fb6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4f99
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x5028
movq -0x20(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0xa, %eax
jne 0x4fff
jmp 0x5028
movq -0x20(%rbp), %rax
movb 0x8(%rax), %dl
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4fe4
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: line_cut
char* line_cut(int y){
    point *temp = data.front;
    while(y--){
        temp = temp->tail;
    }
    int i = 0;
    char ch;
    char *str = (char *)calloc(temp->element.width  + 2,1);
    while(1){
        if(!isEmptys(&(temp->element))){
            ch = ipoploc(&(temp->element),0);
        }
        else
            break;
        if(ch == '\n'){
            inserts(&(temp->element),ch,0);
            break;
        }
        str[i++] = ch;
        str = realloc(str,strlen(str) + 2);
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
leaq 0x818e(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
je 0x5076
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5059
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x2, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x27c0
cmpl $0x0, %eax
jne 0x50be
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x26d0
movb %al, -0x15(%rbp)
jmp 0x50c0
jmp 0x5120
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
jne 0x50de
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movsbl -0x15(%rbp), %esi
xorl %edx, %edx
callq 0x24f0
jmp 0x5120
movb -0x15(%rbp), %dl
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x2210
movq %rax, -0x20(%rbp)
jmp 0x5098
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: word_cut
char* word_cut(int p,int q){
    point *temp = data.front;
    while(q--){
        temp = temp->tail;
    }
    int i = 0;
    char ch;
    char *str = (char *)calloc(2,1); 
    while(1){
        if(!isEmptys(&(temp->element)))
            ch = ipoploc(&(temp->element),p);
        else
            break;
        
        if(ch == '\n' || ch == ' '){
            inserts(&(temp->element),ch,p);
            break;
        }
        str[i++] = ch;    
        str = realloc(str,strlen(str) + 2);
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x809b(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0x5169
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x514c
movl $0x0, -0x14(%rbp)
movl $0x2, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x27c0
cmpl $0x0, %eax
jne 0x51aa
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x4(%rbp), %esi
callq 0x26d0
movb %al, -0x15(%rbp)
jmp 0x51ac
jmp 0x5216
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
je 0x51be
movsbl -0x15(%rbp), %eax
cmpl $0x20, %eax
jne 0x51d4
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movsbl -0x15(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x24f0
jmp 0x5216
movb -0x15(%rbp), %dl
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x2210
movq %rax, -0x20(%rbp)
jmp 0x5183
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: word_copy
char* word_copy(int p,int q){
    point *temp = data.front;
    while(q--){
        temp = temp->tail;
    }
    int i = 0;
    node * traverse = temp->element.store;
    while(p--){
        traverse = traverse->next;
    }
    char *str = (char *)calloc(2,1);
    while(1){
        if(!traverse->next || traverse->val == '\n' || traverse->val == ' ')
            break;
        str[i++] = traverse->val;
        str = realloc(str,strlen(str) + 2);
        traverse = traverse->next;
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x7fab(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0x5259
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x523c
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
je 0x528a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x526c
movl $0x2, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x52c2
movq -0x20(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0xa, %eax
je 0x52c2
movq -0x20(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x20, %eax
jne 0x52c4
jmp 0x5313
movq -0x20(%rbp), %rax
movb 0x8(%rax), %dl
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x2210
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x529d
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: self_destruct
void self_destruct(){
    while(!isEmptyq(&data)){
        while(!isEmptys(&(data.front->element)))
                ipops(&(data.front->element));
        dequeue(&data);
    }
    printf("\nThe Program terminated Successfully :)\nThanks For Using Vasu's Text Editor\n\n");
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x6ae6
leaq 0x66f3(%rip), %rdi      # 0xd1e0
callq 0x2ae0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6b00
jmp 0x6b46
jmp 0x6b02
leaq 0x66d7(%rip), %rax      # 0xd1e0
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x27c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6b23
jmp 0x6b38
leaq 0x66b6(%rip), %rax      # 0xd1e0
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x2660
jmp 0x6b02
leaq 0x66a1(%rip), %rdi      # 0xd1e0
callq 0x29f0
jmp 0x6ae6
leaq 0x3920(%rip), %rdi      # 0xa46d
movb $0x0, %al
callq 0x20d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/undo.c
// Function: add_event
void add_event(undo *s,char *state,int a,int b,char *c, char *d){
    event e;
    e.state = state;
    e.p1 = a;
    e.p2 = b;
    e.p3 = (char *)calloc(sizeof(c)+1,1);
    strcpy(e.p3,c);
    e.p4 = (char *)calloc(sizeof(d)+1,1);
    strcpy(e.p4,d);
    epush(s,e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
movl $0x9, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2050
movl $0x9, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x76a0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/undo.c
// Function: backtrack
void backtrack(undo *s){
    if(isEmptye(s) || (s->num == 0)){
       return; 
    }
    event e = epop(s);
    
    if(strstr(e.state,"replace")){
        undo_replace(e);        
        char *temp = e.p3;
        e.p3 = e.p4;
        e.p4 = temp;
        epush(&redo,e);
    }
    else if(strstr(e.state,"add")){
        undo_insert(e);
        
    }
    else if(strstr(e.state,"back")){
        undo_back(e);
    }
    else if(strstr(e.state,"next")){
        undo_next(e);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x77c0
cmpl $0x0, %eax
jne 0x6c34
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x6c39
jmp 0x6d67
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7740
movq -0x30(%rbp), %rdi
leaq 0x3796(%rip), %rsi      # 0xa3e7
callq 0x22e0
cmpq $0x0, %rax
je 0x6cbe
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x6d70
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x651c(%rip), %rdi      # 0xd1d0
callq 0x76a0
jmp 0x6d67
movq -0x30(%rbp), %rdi
leaq 0x3343(%rip), %rsi      # 0xa00c
callq 0x22e0
cmpq $0x0, %rax
je 0x6cf5
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x71b0
jmp 0x6d65
movq -0x30(%rbp), %rdi
leaq 0x3310(%rip), %rsi      # 0xa010
callq 0x22e0
cmpq $0x0, %rax
je 0x6d2c
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x7300
jmp 0x6d63
movq -0x30(%rbp), %rdi
leaq 0x32d0(%rip), %rsi      # 0xa007
callq 0x22e0
cmpq $0x0, %rax
je 0x6d61
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x7450
jmp 0x6d63
jmp 0x6d65
jmp 0x6d67
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/undo.c
// Function: undo_insert
void undo_insert(event e){
    int x,y;
    getyx(stdscr,y,x);
    if(strstr(e.p3,"\n")){
        backspace(e.p2,1);
        epop(&states);
        display(stline);
        refresh();
        move(y,x);
    }
    else{
        backspace(e.p2,e.p1+1);
        epop(&states);
        display(stline);
        refresh();
    }
    if(x == e.p1)
        move(y,++x);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
movq 0x5e17(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x71e0
movq 0x5e0b(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x64(%rbp)
jmp 0x71ea
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x64(%rbp)
jmp 0x71ea
movl -0x64(%rbp), %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
movq 0x5de7(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x7211
movq 0x5ddb(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x68(%rbp)
jmp 0x721b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x68(%rbp)
jmp 0x721b
movq -0x60(%rbp), %rax
movl -0x68(%rbp), %ecx
movl %ecx, -0x4(%rbp)
movq 0x10(%rax), %rdi
leaq 0x3289(%rip), %rsi      # 0xa4b9
callq 0x22e0
cmpq $0x0, %rax
je 0x7290
movq -0x60(%rbp), %rax
movl 0xc(%rax), %edi
movl $0x1, %esi
callq 0x3b50
leaq -0x30(%rbp), %rdi
leaq 0x5f69(%rip), %rsi      # 0xd1c0
callq 0x7740
leaq 0x5f41(%rip), %rax      # 0xd1a4
movl (%rax), %edi
callq 0x2cb0
movq 0x5d6f(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x20f0
movq 0x5d60(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x2240
jmp 0x72cf
movq -0x60(%rbp), %rax
movl 0xc(%rax), %edi
movl 0x8(%rax), %esi
addl $0x1, %esi
callq 0x3b50
leaq -0x58(%rbp), %rdi
leaq 0x5f13(%rip), %rsi      # 0xd1c0
callq 0x7740
leaq 0x5eeb(%rip), %rax      # 0xd1a4
movl (%rax), %edi
callq 0x2cb0
movq 0x5d19(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x20f0
movq -0x60(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0x72f6
movq 0x5cfe(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x4(%rbp)
callq 0x2240
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/undo.c
// Function: undo_back
void undo_back(event e){
    int y,x;
    getyx(stdscr,y,x);
    if(strstr(e.p3,"\n")){
        add_char('\n',e.p2,e.p1);
        add_line(e.p2);
        display(stline);
        move(y,x+1);
    }
    else{
        add_char(e.p3[0],e.p2,e.p1-1);
        display(stline);
        move(y,x+1);
    }   
    display(stline);
    move(y,x+1);
    refresh();
    return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movq 0x5cc7(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x7330
movq 0x5cbb(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x733a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x733a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
movq 0x5c97(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x7361
movq 0x5c8b(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x736b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x736b
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, -0x8(%rbp)
movq 0x10(%rax), %rdi
leaq 0x3139(%rip), %rsi      # 0xa4b9
callq 0x22e0
cmpq $0x0, %rax
je 0x73d3
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl 0x8(%rax), %edx
movl $0xa, %edi
callq 0x31f0
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x2ef0
leaq 0x5df2(%rip), %rax      # 0xd1a4
movl (%rax), %edi
callq 0x2cb0
movq 0x5c20(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
addl $0x1, %edx
callq 0x2240
jmp 0x7414
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
movb (%rax), %al
movl 0xc(%rcx), %esi
movl 0x8(%rcx), %edx
subl $0x1, %edx
movsbl %al, %edi
callq 0x31f0
leaq 0x5daf(%rip), %rax      # 0xd1a4
movl (%rax), %edi
callq 0x2cb0
movq 0x5bdd(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
addl $0x1, %edx
callq 0x2240
leaq 0x5d89(%rip), %rax      # 0xd1a4
movl (%rax), %edi
callq 0x2cb0
movq 0x5bb7(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
addl $0x1, %edx
callq 0x2240
movq 0x5b9f(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x20f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/undo.c
// Function: undo_next
void undo_next(event e){
    int x = 0,y = 0;
    getyx(stdscr,y,x);
    backspace(e.p2,0);
    epop(&states);
    clear();
    if((y == 0 ) && (stline != 0)){
        stline--;
    }
    display(stline);
    if(stline >  0){
        move(e.p2 - stline,getwidth(e.p2));
    }
    else{
        x += 2;
        move(e.p2,getwidth(e.p2 -stline));
    }
    refresh();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
xorl %eax, %eax
movq 0x5b69(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x748e
movq 0x5b5d(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x7498
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x3c(%rbp)
jmp 0x7498
movl -0x3c(%rbp), %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
movq 0x5b39(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x74bf
movq 0x5b2d(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0x74c9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x40(%rbp)
jmp 0x74c9
movq -0x38(%rbp), %rax
movl -0x40(%rbp), %ecx
movl %ecx, -0x4(%rbp)
movl 0xc(%rax), %edi
xorl %esi, %esi
callq 0x3b50
leaq -0x30(%rbp), %rdi
leaq 0x5cd8(%rip), %rsi      # 0xd1c0
callq 0x7740
movq 0x5aec(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x2090
cmpl $0x0, -0x8(%rbp)
jne 0x7523
leaq 0x5c9b(%rip), %rax      # 0xd1a4
cmpl $0x0, (%rax)
je 0x7523
leaq 0x5c8f(%rip), %rax      # 0xd1a4
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x5c83(%rip), %rax      # 0xd1a4
movl %ecx, (%rax)
leaq 0x5c7a(%rip), %rax      # 0xd1a4
movl (%rax), %edi
callq 0x2cb0
leaq 0x5c6c(%rip), %rax      # 0xd1a4
cmpl $0x0, (%rax)
jle 0x7576
movq -0x38(%rbp), %rax
movq 0x5a98(%rip), %rcx      # 0xcfe0
movq (%rcx), %rcx
movq %rcx, -0x50(%rbp)
movl 0xc(%rax), %ecx
leaq 0x5c4b(%rip), %rdx      # 0xd1a4
subl (%rdx), %ecx
movl %ecx, -0x44(%rbp)
movl 0xc(%rax), %edi
callq 0x3ad0
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movl %eax, %edx
callq 0x2240
jmp 0x75b6
movq -0x38(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, -0x4(%rbp)
movq 0x5a56(%rip), %rcx      # 0xcfe0
movq (%rcx), %rcx
movq %rcx, -0x60(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x54(%rbp)
movl 0xc(%rax), %edi
leaq 0x5c03(%rip), %rax      # 0xd1a4
subl (%rax), %edi
callq 0x3ad0
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
movl %eax, %edx
callq 0x2240
movq 0x5a23(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x20f0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/undo.c
// Function: retrack
void retrack(undo *s){
     if(isEmptye(s) || s->num == 0){
       return; 
    }
    event e = epop(s);
    if(strstr(e.state,"replace")){
        undo_replace(e);        
        char *temp = e.p3;
        e.p3 = e.p4;
        e.p4 = temp;
        epush(&states,e);       
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x77c0
cmpl $0x0, %eax
jne 0x75f4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x75f9
jmp 0x7679
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7740
movq -0x30(%rbp), %rdi
leaq 0x2dd6(%rip), %rsi      # 0xa3e7
callq 0x22e0
cmpq $0x0, %rax
je 0x7679
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x6d70
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x5b4c(%rip), %rdi      # 0xd1c0
callq 0x76a0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/events.c
// Function: epush
void epush(undo *s, event a){
    event *new = (event *)calloc(1,sizeof(event));
    *new  = a;
    if(!(s->e)){
        s->e = new;
        s->num++;
        return;
    }
    else
    {
        event *temp = s->e;
        s->e = new;
        s->e->ptr = temp;
        s->num++;
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq -0x20(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %edx
callq 0x21c0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x76fd
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x772f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/events.c
// Function: epop
event epop(undo *s){
    event e = {NULL,0,0,NULL,NULL,NULL};

    if(!s->e){
        return e;
    }
    else
    {
        event *temp = s->e;
        s->e = s->e->ptr;
        e = *temp;
        s->num--;
        free(temp);
        return e;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x2110
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x776f
jmp 0x77b4
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0x21c0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: get_time
const char * get_time(void) {
    static char time_buf[128];
    struct timeval  tv;
    time_t time;
    suseconds_t millitm;
    struct tm *ti;

    gettimeofday (&tv, NULL);

    time= tv.tv_sec;
    millitm = (tv.tv_usec + 500) / 1000;

    if (millitm == 1000) {
        ++time;
        millitm = 0;
    }

    ti = localtime(&time);
    sprintf(time_buf, "[%02d-%02d_%02d:%02d:%02d:%03d]", ti->tm_mon+1, ti->tm_mday, ti->tm_hour, ti->tm_min, ti->tm_sec, (int)millitm);
    return time_buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f4, %rax            # imm = 0x1F4
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
cmpq $0x3e8, -0x20(%rbp)     # imm = 0x3E8
jne 0x1393
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x28(%rbp), %rax
movl 0x4(%rax), %r9d
movq -0x28(%rbp), %rax
movl (%rax), %r10d
movq -0x20(%rbp), %rax
leaq 0x4d7d(%rip), %rdi      # 0x6150
leaq 0x2c2a(%rip), %rsi      # 0x4004
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x11e0
leaq 0x4d60(%rip), %rax      # 0x6150
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: sig_action
static void sig_action(int sig) {
    if (qmi_proxy_quit == 0) {
        qmi_proxy_quit = 1;
        if (thread_id)
            pthread_kill(thread_id, sig);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x4912(%rip)      # 0x61d4
jne 0x18e9
movl $0x1, 0x4906(%rip)      # 0x61d4
cmpq $0x0, 0x4902(%rip)      # 0x61d8
je 0x18e7
movq 0x48f9(%rip), %rdi      # 0x61d8
movl -0x4(%rbp), %esi
callq 0x1100
jmp 0x18e9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: qmi_proxy_init
static int qmi_proxy_init(void) {
    unsigned i;
    QCQMIMSG _QMI;
    PQCQMIMSG pQMI = &_QMI;

    dprintf("%s enter\n", __func__);

    pQMI->QMIHdr.IFType   = USB_CTL_MSG_TYPE_QMI;
    pQMI->QMIHdr.CtlFlags = 0x00;
    pQMI->QMIHdr.QMIType  = QMUX_TYPE_CTL;
    pQMI->QMIHdr.ClientId= 0x00;
    
    pQMI->CTLMsg.QMICTLMsgHdr.CtlFlags = QMICTL_FLAG_REQUEST;

    qmi_sync_done = 0;
    for (i = 0; i < 10; i++) {
        pQMI->CTLMsg.SyncReq.TransactionId = i+1;    
        pQMI->CTLMsg.SyncReq.QMICTLType = QMICTL_SYNC_REQ;
        pQMI->CTLMsg.SyncReq.Length = 0;

        pQMI->QMIHdr.Length = 
            htole16(le16toh(pQMI->CTLMsg.QMICTLMsgHdr.Length) + sizeof(QCQMI_HDR) + sizeof(QCQMICTL_MSG_HDR) - 1);

        if (send_qmi_to_cdc_wdm(pQMI) <= 0)
            break;

        sleep(1);
        if (qmi_sync_done)
            break;
    }

    dprintf("%s %s\n", __func__, qmi_sync_done ? "succful" : "fail");
    return qmi_sync_done ? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x3f09(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x1340
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x2360(%rip), %rsi      # 0x4441
leaq 0x2366(%rip), %rcx      # 0x444e
movb $0x0, %al
callq 0x1120
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x5(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x6(%rax)
movl $0x0, 0x50f0(%rip)      # 0x7210
movl $0x0, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jae 0x21b8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x28(%rbp), %rax
movw $0x27, 0x8(%rax)
movq -0x28(%rbp), %rax
movw $0x0, 0xa(%rax)
movq -0x28(%rbp), %rax
movzwl 0xa(%rax), %edi
callq 0x2620
movzwl %ax, %eax
addq $0x6, %rax
addq $0x6, %rax
subq $0x1, %rax
movzwl %ax, %edi
callq 0x2620
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x1(%rax)
movq -0x28(%rbp), %rdi
callq 0x2d90
cmpl $0x0, %eax
jg 0x2193
jmp 0x21b8
movl $0x1, %edi
callq 0x1220
cmpl $0x0, 0x506c(%rip)      # 0x7210
je 0x21a8
jmp 0x21b8
jmp 0x21aa
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2127
jmp 0x21ba
movq 0x3e0f(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1340
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movl 0x5036(%rip), %ecx      # 0x7210
leaq 0x228e(%rip), %r8       # 0x446f
leaq 0x227f(%rip), %rax      # 0x4467
cmpl $0x0, %ecx
cmovneq %rax, %r8
leaq 0x2267(%rip), %rsi      # 0x445d
leaq 0x2251(%rip), %rcx      # 0x444e
movb $0x0, %al
callq 0x1120
movl 0x5006(%rip), %edx      # 0x7210
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: qmi_start_server
static void qmi_start_server(const char* servername) {
    qmi_proxy_server_fd = create_local_server(servername);
    dprintf("qmi_proxy_server_fd = %d\n", qmi_proxy_server_fd);
    if (qmi_proxy_server_fd == -1) {
        dprintf("Failed to create %s, errno: %d (%s)\n", servername, errno, strerror(errno));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2e60
movl %eax, 0x3ef9(%rip)      # 0x6134
movq 0x3d8e(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x1340
movq -0x10(%rbp), %rdi
movq %rax, %rdx
movl 0x3ed9(%rip), %ecx      # 0x6134
leaq 0x2212(%rip), %rsi      # 0x4474
movb $0x0, %al
callq 0x1120
cmpl $-0x1, 0x3ec4(%rip)     # 0x6134
jne 0x22cc
jmp 0x2274
movq 0x3d55(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x1340
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1050
movl (%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x1200
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %r8d
movq %rax, %r9
leaq 0x21ce(%rip), %rsi      # 0x4491
movb $0x0, %al
callq 0x1120
jmp 0x22cc
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: qmi_close_server
static void qmi_close_server(const char* servername) {
    if (qmi_proxy_server_fd != -1) {
        dprintf("%s %s close server\n", __func__, servername);
        close(qmi_proxy_server_fd);
        qmi_proxy_server_fd = -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $-0x1, 0x3e41(%rip)     # 0x6134
je 0x233f
jmp 0x22f7
movq 0x3cd2(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x1340
movq -0x10(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %r8
leaq 0x220e(%rip), %rsi      # 0x452a
leaq 0x221e(%rip), %rcx      # 0x4541
movb $0x0, %al
callq 0x1120
movl 0x3e04(%rip), %edi      # 0x6134
callq 0x10e0
movl $0xffffffff, 0x3df5(%rip) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: accept_qmi_connection
static void accept_qmi_connection(int serverfd) {
    int clientfd = -1;
    unsigned char addr[128];
    socklen_t alen = sizeof(addr);
    QMI_PROXY_CONNECTION *qmi_con;

    clientfd = accept(serverfd, (struct sockaddr *)addr, &alen);

    qmi_con = (QMI_PROXY_CONNECTION *)malloc(sizeof(QMI_PROXY_CONNECTION));
    if (qmi_con) {
        qlist_init(&qmi_con->qnode);
        qlist_init(&qmi_con->client_qnode);
        qmi_con->ClientFd= clientfd;
        qmi_con->AccessTime = 0;
        dprintf("+++ ClientFd=%d\n", qmi_con->ClientFd);
        qlist_add_tail(&qmi_proxy_connection, &qmi_con->qnode);
    }

    cfmakenoblock(clientfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0x80, -0x94(%rbp)
movl -0x4(%rbp), %edi
leaq -0x90(%rbp), %rsi
leaq -0x94(%rbp), %rdx
callq 0x11d0
movl %eax, -0x8(%rbp)
movl $0x28, %edi
callq 0x1140
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
je 0x25d9
movq -0xa0(%rbp), %rdi
callq 0x2350
movq -0xa0(%rbp), %rdi
addq $0x10, %rdi
callq 0x2350
movl -0x8(%rbp), %ecx
movq -0xa0(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0xa0(%rbp), %rax
movl $0x0, 0x24(%rax)
movq 0x3a3b(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
callq 0x1340
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
movq -0xa0(%rbp), %rax
movl 0x20(%rax), %ecx
leaq 0x1dda(%rip), %rsi      # 0x4399
movb $0x0, %al
callq 0x1120
movq -0xa0(%rbp), %rsi
leaq 0x4c1c(%rip), %rdi      # 0x71f0
callq 0x2aa0
jmp 0x25db
movl -0x8(%rbp), %eax
movl %eax, -0xac(%rbp)
movl -0x8(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x1080
movl -0xac(%rbp), %edi
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x1080
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: dump_qmi
static void dump_qmi(PQCQMIMSG pQMI, int fd, const char flag)
{
    if (verbose_debug)
    {
        unsigned i;
        unsigned size = le16toh(pQMI->QMIHdr.Length) + 1;
        printf("%c %d %u: ", flag, fd, size);
        if (size > 16)
            size = 16;
        for (i = 0; i < size; i++)
            printf("%02x ", ((uint8_t *)pQMI)[i]);
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
cmpl $0x0, 0x3b75(%rip)      # 0x61d0
je 0x26d9
movq -0x8(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x2620
movzwl %ax, %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movsbl -0xd(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x1d29(%rip), %rdi      # 0x43ad
movb $0x0, %al
callq 0x10b0
cmpl $0x10, -0x18(%rbp)
jbe 0x2698
movl $0x10, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x26cb
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %esi
leaq 0x1cff(%rip), %rdi      # 0x43b8
movb $0x0, %al
callq 0x10b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x269f
leaq 0x19be(%rip), %rdi      # 0x4090
movb $0x0, %al
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-qmi-proxy.c
// Function: recv_qmi_from_client
static int recv_qmi_from_client(PQCQMIMSG pQMI, unsigned size, int clientfd) {
    if (qmi_proxy_server_fd <= 0) {
        send_qmi_to_cdc_wdm(pQMI);
    }
    else if (pQMI->QMIHdr.QMIType == QMUX_TYPE_CTL) {  
        QMI_PROXY_MSG *qmi_msg;

        if (pQMI->CTLMsg.QMICTLMsgHdr.QMICTLType == QMICTL_SYNC_REQ) {
            dprintf("do not allow client send QMICTL_SYNC_REQ\n");
            return 0;
        }

        if (qlist_empty(&qmi_proxy_ctl_msg))
            send_qmi_to_cdc_wdm(pQMI);

        qmi_msg = malloc(sizeof(QMI_PROXY_MSG) + size);
        qlist_init(&qmi_msg->qnode);
        qmi_msg->ClientFd = clientfd;
        memcpy(qmi_msg->qmi, pQMI, size);
        qlist_add_tail(&qmi_proxy_ctl_msg, &qmi_msg->qnode);
    }
    else {
        send_qmi_to_cdc_wdm(pQMI);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, 0x37ab(%rip)      # 0x6134
jg 0x2999
movq -0x10(%rbp), %rdi
callq 0x2d90
jmp 0x2a5b
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x2a50
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x27, %eax
jne 0x29ea
jmp 0x29b9
movq 0x3610(%rip), %rax      # 0x5fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1340
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x1a3a(%rip), %rsi      # 0x4414
movb $0x0, %al
callq 0x1120
movl $0x0, -0x4(%rbp)
jmp 0x2a62
leaq 0x480f(%rip), %rax      # 0x7200
cmpq 0x4808(%rip), %rax      # 0x7200
jne 0x2a03
movq -0x10(%rbp), %rdi
callq 0x2d90
movl -0x14(%rbp), %eax
movl %eax, %edi
addq $0x18, %rdi
callq 0x1140
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2350
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x14, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x1130
movq -0x20(%rbp), %rsi
leaq 0x47b7(%rip), %rdi      # 0x7200
callq 0x2aa0
jmp 0x2a59
movq -0x10(%rbp), %rdi
callq 0x2d90
jmp 0x2a5b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)