LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conqs3.c
// Function: get_line
void get_line(char *iline, int *Ind0, int onech)
{
    char ch;
    int ind;

    ind = 1;
    do {
        read_char(&ch);
        if (ch == '\b') {       /*backspace */
            if (ind != 1) {
                if ((ind != 1) && onech) {
                    addch('\b');
                    ind = ind - 1;
                };
                if ((ind != 1) && !onech) {
                    printw("\b \b");
                    ind = ind - 1;
                }
            };
        } else if (ch != '\n') {
            printw("%c", ch);
            iline[ind] = ch;
            ind = ind + 1;
            if (onech) {
                addch(' ');
                iline[ind] = ' ';
                ind = ind + 1;
            };
        };
    }
    while (ind < 25 && ch != '\n');
    while (ind != 80) {
        iline[ind] = ' ';
        ind = ind + 1;
    };
    *Ind0 = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x15(%rbp), %rdi
callq 0xa420
movsbl -0x15(%rbp), %eax
cmpl $0x8, %eax
jne 0xa532
cmpl $0x1, -0x1c(%rbp)
je 0xa530
cmpl $0x1, -0x1c(%rbp)
je 0xa50b
cmpl $0x0, -0x14(%rbp)
je 0xa50b
movq 0x7afb(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
movl $0x8, %esi
callq 0x20a0
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0xa52e
cmpl $0x0, -0x14(%rbp)
jne 0xa52e
leaq 0x487f(%rip), %rdi      # 0xed9d
movb $0x0, %al
callq 0x2030
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa530
jmp 0xa597
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
je 0xa595
movsbl -0x15(%rbp), %esi
leaq 0x4c1f(%rip), %rdi      # 0xf165
movb $0x0, %al
callq 0x2030
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xa593
movq 0x7a7f(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x20a0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa595
jmp 0xa597
jmp 0xa599
xorl %eax, %eax
cmpl $0x19, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jge 0xa5b1
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xa4ca
jmp 0xa5be
cmpl $0x50, -0x1c(%rbp)
je 0xa5db
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa5be
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conqs3.c
// Function: get_stars
void get_stars(int s_star, float slist[nstars + 1], int *C0unt)
{
    int starnum, count;

    count = 0;
    for (starnum = 1; starnum <= nstars; starnum++) {
        if (range[0] >= r2nge[s_star][starnum]) {
            count = count + 1;
            slist[starnum] = r2nge[s_star][starnum];
        } else
            slist[starnum] = 0;
    };
    *C0unt = count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x15, -0x1c(%rbp)
jg 0xa687
leaq 0xa0a6(%rip), %rax      # 0x146c0
movl (%rax), %eax
movslq -0x4(%rbp), %rdx
leaq 0x7e79(%rip), %rcx      # 0x124a0
imulq $0x58, %rdx, %rdx
addq %rdx, %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0xa66a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x7e55(%rip), %rax      # 0x124a0
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cvtsi2ssl (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0xa67a
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0xa67c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa60d
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conqs3.c
// Function: clear_field
void clear_field(void)
{
    int new_bottom, y;
    new_bottom = y_cursor - 1;
    if (new_bottom < bottom_field) {
        for (y = new_bottom + 1; y <= bottom_field; y++) {
            point(50, y);
            printw(blank_line);
        };
    };
    bottom_field = new_bottom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa215(%rip), %rax      # 0x148c4
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0xa1fb(%rip), %rcx      # 0x148bc
cmpl (%rcx), %eax
jge 0xa704
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0xa1e4(%rip), %rcx      # 0x148bc
cmpl (%rcx), %eax
jg 0xa702
movl -0x8(%rbp), %esi
movl $0x32, %edi
callq 0x69f0
leaq 0x3cdf(%rip), %rdi      # 0xe3cf
movb $0x0, %al
callq 0x2030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa6ce
jmp 0xa704
movl -0x4(%rbp), %ecx
leaq 0xa1ae(%rip), %rax      # 0x148bc
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conqs3.c
// Function: cle3r_left
void cle3r_left(void)
{
    int i;
    for (i = 19; i <= 24; i++) {
        if (left_line[i]) {
            point(1, i);
            printw(blank_line);
            left_line[i] = false;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x13, -0x4(%rbp)
cmpl $0x18, -0x4(%rbp)
jg 0xa780
movslq -0x4(%rbp), %rcx
leaq 0xa190(%rip), %rax      # 0x148d0
cmpl $0x0, (%rax,%rcx,4)
je 0xa773
movl -0x4(%rbp), %esi
movl $0x1, %edi
callq 0x69f0
leaq 0x3c75(%rip), %rdi      # 0xe3cf
movb $0x0, %al
callq 0x2030
movslq -0x4(%rbp), %rcx
leaq 0xa164(%rip), %rax      # 0x148d0
movl $0x0, (%rax,%rcx,4)
jmp 0xa775
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa72f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conqs3.c
// Function: help
void help(int which)
{
    struct helpst *h;
    int j;

    j = 1;
    point(50, j++);
    if (which == 0)
        h = help0;
    if (which == 1)
        h = help1;
    if (which == 2)
        h = help2;
    if (which == 3)
        h = help3;
    if (which == 4)
        h = help4;
    while (h->cmd != 0) {
        printw("%2s - %-25s", h->cmd, h->does);
        point(50, j++);
        h++;
    }
    clear_field();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x32, %edi
callq 0x69f0
cmpl $0x0, -0x4(%rbp)
jne 0xa9a8
leaq 0x771c(%rip), %rax      # 0x120c0
movq %rax, -0x10(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0xa9b9
leaq 0x77ab(%rip), %rax      # 0x12160
movq %rax, -0x10(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0xa9ca
leaq 0x787a(%rip), %rax      # 0x12240
movq %rax, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0xa9db
leaq 0x7909(%rip), %rax      # 0x122e0
movq %rax, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
jne 0xa9ec
leaq 0x79a8(%rip), %rax      # 0x12390
movq %rax, -0x10(%rbp)
jmp 0xa9ee
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xaa38
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x4599(%rip), %rdi      # 0xefa7
movb $0x0, %al
callq 0x2030
movl -0x14(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x32, %edi
callq 0x69f0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xa9ee
callq 0xa6a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conqsubs.c
// Function: ressum
void ressum(void)
{
    char key;
    int value, ind;
    char iline[81];
    printw("esearch field(s):");
    get_line(iline, &ind, true);
    get_token(iline, &ind, &value, &key);
    cle3r_left();
    if (key == ' ') {
        pr2nt_res('R');
        pr2nt_res('V');
        pr2nt_res('W');
    } else {
        do {
            pr2nt_res(key);
            get_token(iline, &ind, &value, &key);
        }
        while (key != ' ');
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x3abc(%rip), %rdi      # 0xf09b
movb $0x0, %al
callq 0x2030
leaq -0x60(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x1, %edx
callq 0xa4b0
leaq -0x60(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x1(%rbp), %rcx
callq 0xa7e0
callq 0xa720
movsbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jne 0xb63b
movl $0x52, %edi
callq 0xb420
movl $0x56, %edi
callq 0xb420
movl $0x57, %edi
callq 0xb420
jmp 0xb666
jmp 0xb63d
movsbl -0x1(%rbp), %edi
callq 0xb420
leaq -0x60(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x1(%rbp), %rcx
callq 0xa7e0
movsbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jne 0xb63d
jmp 0xb666
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conqtf.c
// Function: make_tf
void make_tf(void)
{
    char task;
    int tf_num;
    boolean error;
    int new_tf;
    printw("ew tf- from tf:");
    get_char(&task);
    cle3r_left();
    tf_num = task - 'A' + 1;
    error = (tf_num < 1) || (tf_num > 26);
    if (!error)
        error = (tf[player][tf_num].eta != 0) ||
            (tf[player][tf_num].dest == 0);
    if (error) {
        error_message();
        printw("  !illegal tf");
    } else if (tf[player][tf_num].blasting) {
        error = true;
        error_message();
        printw(" !Tf is blasting a planet     ");
    } else {
        point(1, 19);
        split_tf(&tf_num, &new_tf);
        point(1, 20);
        pr3nt_tf(new_tf);
        point(1, 21);
        pr3nt_tf(tf_num);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x374d(%rip), %rdi      # 0xf11c
movb $0x0, %al
callq 0x2030
leaq -0x1(%rbp), %rdi
callq 0xa480
callq 0xa720
movsbl -0x1(%rbp), %eax
subl $0x41, %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movb $0x1, %al
cmpl $0x1, -0x8(%rbp)
movb %al, -0x11(%rbp)
jl 0xba06
cmpl $0x1a, -0x8(%rbp)
setg %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xba68
movslq -0x8(%rbp), %rax
leaq 0x7f7e(%rip), %rcx      # 0x139a0
addq $0x57c, %rcx            # imm = 0x57C
imulq $0x34, %rax, %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x0, 0x24(%rcx)
movb %al, -0x12(%rbp)
jne 0xba5d
movslq -0x8(%rbp), %rcx
leaq 0x7f5a(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xba86
callq 0xa7c0
leaq 0x30e2(%rip), %rdi      # 0xeb5c
movb $0x0, %al
callq 0x2030
jmp 0xbb0c
movslq -0x8(%rbp), %rcx
leaq 0x7f0f(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x2c(%rax)
je 0xbac0
movl $0x1, -0xc(%rbp)
callq 0xa7c0
leaq 0x3675(%rip), %rdi      # 0xf12c
movb $0x0, %al
callq 0x2030
jmp 0xbb0a
movl $0x1, %edi
movl $0x13, %esi
callq 0x69f0
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xbb20
movl $0x1, %edi
movl $0x14, %esi
callq 0x69f0
movl -0x10(%rbp), %edi
callq 0xaca0
movl $0x1, %edi
movl $0x15, %esi
callq 0x69f0
movl -0x8(%rbp), %edi
callq 0xaca0
jmp 0xbb0c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: send_all
void send_all(int socket, void* buffer, int64_t length) {
    char* ptr = (char*)buffer;
    int64_t i = 0;
    while (length > 0) {
        i = send(socket, ptr, length, 0);
        if (i < 1) {
            if(verbose_socklibc>=1) {
				WARNING("%s", "Could not send all data. Trying again.");
			}
            sleep(1);
        }
        ptr += i;
        length -= i;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x146d
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x10e0
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jge 0x1450
cmpl $0x1, 0x5d3a(%rip)      # 0x7158
jl 0x1446
movq 0x5bd1(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2c85(%rip), %rsi      # 0x40b6
leaq 0x2f5f(%rip), %rdx      # 0x4397
leaq 0x2f61(%rip), %rcx      # 0x43a0
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1260
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x13f3
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: recv_full_msg
int64_t recv_full_msg(int socket, void* buffer, int64_t length) {
    int64_t expected_length = 0;
    recv_all(socket, &expected_length, sizeof(int64_t));

	if(verbose_socklibc>=4){	
		INFO("Receiving a message of size %ld.", expected_length);
	}
	
    if (expected_length > length) {
        WARNING("Buffer of size %ld is too small to fit expected data.",
                expected_length);
    }

    recv_all(socket, buffer, expected_length);
    return expected_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x1520
cmpl $0x4, 0x5ca5(%rip)      # 0x7158
jl 0x14d8
movq 0x5b3c(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
leaq 0x2b3a(%rip), %rsi      # 0x4004
leaq 0x2b60(%rip), %rdx      # 0x4031
movb $0x0, %al
callq 0x1160
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x1505
movq 0x5b0f(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
leaq 0x2b48(%rip), %rsi      # 0x403f
leaq 0x2b33(%rip), %rdx      # 0x4031
movb $0x0, %al
callq 0x1160
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1520
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: recv_all
void recv_all(int socket, void* buffer, int64_t length) {
    char* ptr = (char*)buffer;
    int64_t i = 0;
    while (length > 0) {
        i = recv(socket, ptr, length, 0);
        if (i < 1) {
			if(verbose_socklibc>=1){
				WARNING("%s", "Could not receive all data. Trying again.");
			}
            sleep(1);
        }
        ptr += i;
        length -= i;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x15bd
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jge 0x15a0
cmpl $0x1, 0x5bea(%rip)      # 0x7158
jl 0x1596
movq 0x5a81(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2b35(%rip), %rsi      # 0x40b6
leaq 0x2e3f(%rip), %rdx      # 0x43c7
leaq 0x2e41(%rip), %rcx      # 0x43d0
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1260
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x1543
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: recv_full_msg_try
int64_t recv_full_msg_try(int socket, void* buffer, int64_t length, int times) {
    int64_t expected_length = 0;
    int64_t ret = recv_all_try(socket, &expected_length, sizeof(int64_t), times);
    if (ret < 0) {
        return ret;
    }

	if(verbose_socklibc>=4){
		INFO("Receiving a message of size %ld.", expected_length);
	}
	
    if (expected_length > length && verbose_socklibc>=1) {
        WARNING("Buffer of size %ld is too small to fit expected data.",
                expected_length);
    }

    ret = recv_all_try(socket, buffer, expected_length, times);
    if (ret < 0) {
        return ret;
    }
    return expected_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl -0x24(%rbp), %ecx
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x16c0
cltq
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x161c
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16b0
cmpl $0x4, 0x5b35(%rip)      # 0x7158
jl 0x1648
movq 0x59cc(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rcx
leaq 0x29ca(%rip), %rsi      # 0x4004
leaq 0x2a4e(%rip), %rdx      # 0x408f
movb $0x0, %al
callq 0x1160
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x167e
cmpl $0x1, 0x5aff(%rip)      # 0x7158
jl 0x167e
movq 0x5996(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rcx
leaq 0x29cf(%rip), %rsi      # 0x403f
leaq 0x2a18(%rip), %rdx      # 0x408f
movb $0x0, %al
callq 0x1160
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x16c0
cltq
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x16a8
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16b0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: recv_all_try
int recv_all_try(int socket, void* buffer, int64_t length, int times) {
    char* ptr = (char*)buffer;
    int64_t i = 0;
    int counter = 0;
    while (length > 0) {
        i = recv(socket, ptr, length, 0);
        if (i < 1) {
			if(verbose_socklibc>=3){
				WARNING("%s", "Could not receive all data. Trying again.");
			}
            sleep(1);
            counter++;
            if (counter >= times) {
				if(verbose_socklibc>=2){
					ERROR("%s", "Socket is probably broken. Giving up.");
				}
                return -1;
            }
        }
        ptr += i;
        length -= i;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x17bd
movl -0x8(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1050
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
jge 0x179d
cmpl $0x3, 0x5a38(%rip)      # 0x7158
jl 0x1748
movq 0x58cf(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2983(%rip), %rsi      # 0x40b6
leaq 0x2cc0(%rip), %rdx      # 0x43fa
leaq 0x2c8f(%rip), %rcx      # 0x43d0
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1260
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x179b
cmpl $0x2, 0x59ee(%rip)      # 0x7158
jl 0x1792
movq 0x5885(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2c8a(%rip), %rsi      # 0x4407
leaq 0x2c76(%rip), %rdx      # 0x43fa
leaq 0x2c97(%rip), %rcx      # 0x4422
movb $0x0, %al
callq 0x1160
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17c4
jmp 0x179d
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x16ed
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: errorCheck
void errorCheck(int ret, char* msg) {
    if (ret == -1) {
        if(verbose_socklibc>=1){
			perror(msg);
		}
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x19a1
cmpl $0x1, 0x57cc(%rip)      # 0x7158
jl 0x1997
movq -0x10(%rbp), %rdi
callq 0x11e0
movl $0x1, %edi
callq 0x1220
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: TCP_server_accept_client
int TCP_server_accept_client(int listenfd) {
    int connectfd;

    struct sockaddr_in client;
    socklen_t clientlen = sizeof(client);

    //accept connections
    connectfd = accept(listenfd, (struct sockaddr*)&client, &clientlen);
    errorCheck(connectfd, "Cannot accept");

    //get ip to string
    char ip[16];
    inet_ntop(AF_INET, &client.sin_addr, ip, clientlen);
	if(verbose_socklibc>=4){
		INFO("Client %s:%d connected.", ip, client.sin_port);
	}

    return connectfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x11f0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x27c8(%rip), %rsi      # 0x41a7
callq 0x1970
leaq -0x18(%rbp), %rsi
addq $0x4, %rsi
leaq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl $0x2, %edi
callq 0x1030
cmpl $0x4, 0x5754(%rip)      # 0x7158
jl 0x1a2e
movq 0x55eb(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq -0x30(%rbp), %rcx
movzwl -0x16(%rbp), %r8d
leaq 0x2795(%rip), %rsi      # 0x41b5
leaq 0x27b2(%rip), %rdx      # 0x41d9
movb $0x0, %al
callq 0x1160
movl -0x8(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: TCP_server_disconnect_client
void TCP_server_disconnect_client(int connectfd) {
    //close sockets
    int ret = close(connectfd);
    errorCheck(ret, "Cannot close socket.");
    if(verbose_socklibc>=4){
		INFO("%s", "Client disconnected.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x1120
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x2792(%rip), %rsi      # 0x41f2
callq 0x1970
cmpl $0x4, 0x56ec(%rip)      # 0x7158
jl 0x1a94
movq 0x5583(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2788(%rip), %rsi      # 0x4207
leaq 0x2790(%rip), %rdx      # 0x4216
leaq 0x27a6(%rip), %rcx      # 0x4233
movb $0x0, %al
callq 0x1160
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/socket.c
// Function: TCP_client_disconnect
void TCP_client_disconnect(int socketfd) {
    //closing sockets
    int ret = shutdown(socketfd, SHUT_RDWR);
    errorCheck(ret, "Cannot disconnect.");
    ret = close(socketfd);
    errorCheck(ret, "Cannot close socket.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0x10a0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x247f(%rip), %rsi      # 0x4384
callq 0x1970
movl -0x4(%rbp), %edi
callq 0x1120
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x22d3(%rip), %rsi      # 0x41f2
callq 0x1970
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/f5pl.c
// Function: sig_handler
void sig_handler(int sig) {
    void* array[100];
    size_t size = backtrace(array, 100);
    ERROR("I regret to inform that a segmentation fault occurred. But at least "
          "it is better than a wrong answer%s",
          ".");
    fprintf(stderr,
            "[%s::DEBUG]\033[1;35m Here is the backtrace in case it is of any "
            "use:\n",
            __func__);
    backtrace_symbols_fd(&array[2], size - 1, STDERR_FILENO);
    fprintf(stderr, "\033[0m\n");
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movl %edi, -0x4(%rbp)
leaq -0x330(%rbp), %rdi
movl $0x64, %esi
callq 0x10c0
cltq
movq %rax, -0x338(%rbp)
movq 0x4779(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1ed3(%rip), %rsi      # 0x475c
leaq 0x1f4b(%rip), %rdx      # 0x47db
leaq 0x1e04(%rip), %rcx      # 0x469b
movb $0x0, %al
callq 0x1160
movq 0x4753(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1f38(%rip), %rsi      # 0x47e7
leaq 0x1f25(%rip), %rdx      # 0x47db
movb $0x0, %al
callq 0x1160
leaq -0x330(%rbp), %rdi
addq $0x10, %rdi
movq -0x338(%rbp), %rax
subq $0x1, %rax
movl %eax, %esi
movl $0x2, %edx
callq 0x1060
movq 0x4712(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1f83(%rip), %rsi      # 0x4873
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1220
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/error.c
// Function: malloc_chk
void malloc_chk(void* ret, const char* func, const char* file, int line) {
    if (ret != NULL)
        return;
    fprintf(
        stderr,
        "[%s::ERROR]\033[1;31m Failed to allocate memory : "
        "%s.\033[0m\n[%s::DEBUG]\033[1;35m Error occured at %s:%d.\033[0m\n\n",
        func, strerror(errno), func, file, line);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3164
addq $0x40, %rsp
popq %rbp
retq
movq 0x3e8d(%rip), %rax      # 0x6ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1070
movl (%rax), %edi
callq 0x1250
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl -0x1c(%rbp), %eax
leaq 0x19cf(%rip), %rsi      # 0x4b72
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1220
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/error.c
// Function: f_chk
void f_chk(void* ret, const char* func, const char* file, int line,
           const char* fopen_f) {
    if (ret != NULL)
        return;
    fprintf(
        stderr,
        "[%s::ERROR]\033[1;31m Failed to open %s : "
        "%s.\033[0m\n[%s::DEBUG]\033[1;35m Error occured at %s:%d.\033[0m\n\n",
        func, fopen_f, strerror(errno), func, file, line);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x31e8
addq $0x50, %rsp
popq %rbp
retq
movq 0x3e09(%rip), %rax      # 0x6ff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1070
movl (%rax), %edi
callq 0x1250
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rax, %r8
movq -0x10(%rbp), %r9
movq -0x18(%rbp), %r10
movl -0x1c(%rbp), %eax
leaq 0x19a7(%rip), %rsi      # 0x4bda
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1220
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/error.c
// Function: null_chk
void null_chk(void* ret, const char* func, const char* file, int line) {
    if (ret != NULL)
        return;
    fprintf(stderr,
            "[%s::ERROR]\033[1;31m %s.\033[0m\n[%s::DEBUG]\033[1;35m Error "
            "occured at %s:%d.\033[0m\n\n",
            func, strerror(errno), func, file, line);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3274
addq $0x40, %rsp
popq %rbp
retq
movq 0x3d7d(%rip), %rax      # 0x6ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1070
movl (%rax), %edi
callq 0x1250
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl -0x1c(%rbp), %eax
leaq 0x1987(%rip), %rsi      # 0x4c3a
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1220
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/error.c
// Function: neg_chk
void neg_chk(int ret, const char* func, const char* file, int line) {
    if (ret >= 0)
        return;
    fprintf(stderr,
            "[%s::ERROR]\033[1;31m %s.\033[0m\n[%s::DEBUG]\033[1;35m Error "
            "occured at %s:%d.\033[0m\n\n",
            func, strerror(errno), func, file, line);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x32f2
addq $0x40, %rsp
popq %rbp
retq
movq 0x3cff(%rip), %rax      # 0x6ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1070
movl (%rax), %edi
callq 0x1250
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl -0x1c(%rbp), %eax
leaq 0x1909(%rip), %rsi      # 0x4c3a
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x1220
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stack.c
// Function: inits
void inits(istack *s){
    
    s->p = calloc(1,sizeof(node));
    s->p->next = NULL;
    s->p->prev = NULL;
    s->width = 0;
    s->store = s->p;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stack.c
// Function: ipushs
void ipushs(istack *s, int a){
	s->p->val = a;
    pntr temp;
    temp = s->p;
    s->p = calloc(1,sizeof(node));
    s->p->prev = temp;
    s->p->next = NULL;
    temp->next = s->p;
    s->width++;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stack.c
// Function: inserts
void inserts(istack *s, int a,int loc){
	node* newnode = (node *)malloc(sizeof(node));
	newnode->val = a;
	node *temp = s->store;
	if( loc > s->width + 1)
		return;
	else if(loc == 0){

		newnode->next = s->store;
        s->store->prev = newnode;
        newnode->prev = NULL;
		s->store = newnode;
		s->width++;
		return;
	}
	else if(loc == s->width + 1){
        newnode->next = NULL;
        s->p->next = newnode;
        newnode->prev = s->p;
		s->p = newnode;
		s->width++;
		return;
	}
	else if(loc > 0){
		while(loc > 1){
			temp = temp->next;
			loc--;
		}
		newnode->next = temp->next;
        newnode->next->prev = newnode;
        newnode->prev = temp;
		temp->next = newnode;
		s->width++;
		return;
	}
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0x253d
jmp 0x264f
cmpl $0x0, -0x10(%rbp)
jne 0x2588
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%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 0x264f
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x25df
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x264f
cmpl $0x0, -0x10(%rbp)
jle 0x2649
jmp 0x25e7
cmpl $0x1, -0x10(%rbp)
jle 0x2604
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25e7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x264f
jmp 0x264b
jmp 0x264d
jmp 0x264f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stack.c
// Function: ipops
int ipops(istack *s){
      //head pointer is ahead of the last element in the stack
    //printw("%d\t",s->width);
    pntr temp;
    temp = s->p;
    s->width--;
    s->p = s->p->prev;
    //printw("%d\t",s->width);
    s->p->next = NULL;
    int num = s->p->val;
    free(temp);
    return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movsbl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stack.c
// Function: ipoploc
int ipoploc(istack *s,int x){
      //head pointer is ahead of the last element in the stack
    //printw("%d\t",s->width);
    pntr temp = s->store;
    int num;
    int i;
    if(x == 0){
        s->store = s->store->next;
        s->store->prev = NULL;
        num = temp->val;
        free(temp);
        s->width--;
        return num;
    }
    for(i = 0; i < x; i++)
        temp = temp->next;
    
    temp->prev->next = temp->next;
    temp->next->prev = temp->prev;
    s->width--;
    num = temp->val;
    free(temp);
    return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2739
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movsbl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x27ab
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x275f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2740
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movsbl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2030
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stack.c
// Function: isEmptys
int isEmptys(istack *s){
    if(s->p->prev == NULL)
        return 1;
    else
        return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
jne 0x27df
movl $0x1, -0x4(%rbp)
jmp 0x27e6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/line.c
// Function: initq
void initq(line *s){
    s->link = (point *)calloc(1,sizeof(point));
    //s->link->element = (istack *)calloc(1,sizeof(istack));
    inits(&(s->link->element));
    s->link->head = NULL;
    s->link->tail = NULL;
    //printw("%p\n",s->link->tail);
    //refresh();
    s->front = s->link;
    s->lines = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x8, %rdi
callq 0x23f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/line.c
// Function: enqueue
void enqueue(line *s){
    point *temp =  (point *)calloc(1,sizeof(point));
    temp->head = s->link;
    temp->tail = NULL;
    //printw("1\n");
    //refresh();
    inits(&(temp->element));
    s->link->tail = temp;
    s->link = temp;
    s->lines++;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x23f0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/line.c
// Function: enqueue_pos
void enqueue_pos(line *l, int a){
    point *newnode =  (point *)calloc(1,sizeof(point));
    inits(&(newnode->element));
    point* temp = l->front;
    int i = 0;
    for(; i < a; i++)
        temp = temp->tail;
    temp->head->tail = newnode;
    newnode->tail = temp;
    newnode->head = temp->head;
    temp->head = newnode;
    l->lines++;
    return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x23f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x299f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2981
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/line.c
// Function: dequeue
void dequeue(line *s){
    s->link->head->tail = NULL;
    point *temp = s->link;
    s->link = s->link->head;
    free(temp);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/line.c
// Function: dequeueloc
void dequeueloc(line *s,int x){
    point* temp = s->front;
    int num;
    int i;
    for(i = 0; i < x; i++)
        temp = temp->tail;
    
    if(temp->tail == NULL){
        dequeue(s);
        return;
    }
    temp->head->tail = temp->tail;
    temp->tail->head = temp->head;

    s->lines--;
    free(temp);
    return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2a7f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2a61
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2a94
movq -0x8(%rbp), %rdi
callq 0x29f0
jmp 0x2acf
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/line.c
// Function: isEmptyq
int isEmptyq(line *s){
    if(s->link->head == s->link->tail)
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x2b0a
movl $0x1, -0x4(%rbp)
jmp 0x2b11
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: create_newwin
WINDOW *create_newwin(int height, int width, int starty, int startx){       
    WINDOW *local_win;
    local_win = newwin(height, width, starty, startx);
    box(local_win, 0 , 0);
    wrefresh(local_win);
    keypad(local_win, TRUE);
    return local_win; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x2040
movq %rax, -0x18(%rbp)
movq -0x18(%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
movq -0x18(%rbp), %rdi
callq 0x20f0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2150
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: line_num
void line_num(){
    int i,j;
    for(i = stline,j = 0; j < (by - 4) ;i++,j++){
        move(j,bx-1);
        printw("%d",(i+1)%10);
    }
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa585(%rip), %rax      # 0xd1a4
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0xa55f(%rip), %rcx      # 0xd194
movl (%rcx), %ecx
subl $0x4, %ecx
cmpl %ecx, %eax
jge 0x2c8e
movq 0xa39b(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0x8(%rbp), %esi
leaq 0xa54a(%rip), %rax      # 0xd19c
movl (%rax), %edx
subl $0x1, %edx
callq 0x2240
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %esi
leaq 0x77aa(%rip), %rdi      # 0xa41d
movb $0x0, %al
callq 0x2280
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2c2b
movq 0xa34b(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x20f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vasusharma7[P]Text-Editor/stdedit.c
// Function: display
void display(int stline){
    //clear();
    move(0,0);
    int a,y,x;
    point *temp = data.front;
    for(a = 0; (a < stline) && (stline >=0); a++){
        temp = temp->tail;
    }
    int count = 1;
    while(temp){
        if(count >= (by - 3))
            break;
        clrtoeol();
        node *row = temp->element.store;
        while(row->next){
                printw("%c",row->val);
            row = row->next;    
        }
        count++;
        temp = temp->tail;
    }
    getyx(stdscr,y,x);
    refresh();
    line_num();
    move(y,x);
    refresh();
    return;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq 0xa31e(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2240
leaq 0xa50b(%rip), %rax      # 0xd1e0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x2cfa
cmpl $0x0, -0x4(%rbp)
setge %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2d03
jmp 0x2d19
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2ce3
movl $0x1, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d9c
movl -0x1c(%rbp), %eax
leaq 0xa463(%rip), %rcx      # 0xd194
movl (%rcx), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jl 0x2d3c
jmp 0x2d9c
movq 0xa29d(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x2250
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2d86
movq -0x28(%rbp), %rax
movsbl 0x8(%rax), %esi
leaq 0x7293(%rip), %rdi      # 0xa004
movb $0x0, %al
callq 0x2280
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2d57
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2d20
xorl %eax, %eax
movq 0xa23b(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x2dbc
movq 0xa22f(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x2dc6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x30(%rbp)
jmp 0x2dc6
movl -0x30(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0xa20b(%rip), %rcx      # 0xcfe0
cmpq (%rcx), %rax
je 0x2ded
movq 0xa1ff(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x2df7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x2df7
movl -0x34(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0xa1dc(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x20f0
callq 0x2c10
movq 0xa1c8(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2240
movq 0xa1b3(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x20f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)