LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x22b0(%rip), %rdi      # 0x9ed3
xorl %eax, %eax
callq 0x2030
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x71a2
leaq 0xc(%rsp), %rdx
leaq 0x7(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x73f2
callq 0x7377
cmpb $0x20, (%r15)
jne 0x7c87
movl $0x52, %edi
callq 0x7b04
movl $0x56, %edi
callq 0x7b04
movl $0x57, %edi
callq 0x7b04
jmp 0x7cbd
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x7(%rsp), %r12
movsbl 0x7(%rsp), %edi
callq 0x7b04
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x73f2
cmpb $0x20, 0x7(%rsp)
jne 0x7c9b
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x2097(%rip), %rdi      # 0x9f05
xorl %eax, %eax
callq 0x2030
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x7187
callq 0x7377
movsbq (%rbx), %rax
leal -0x5b(%rax), %ecx
addq $-0x40, %rax
movl %eax, 0x10(%rsp)
cmpb $-0x1a, %cl
setb %cl
jb 0x7ec6
movl %eax, %ecx
imulq $0x34, %rcx, %rcx
leaq 0x6af5(%rip), %rdx      # 0xe9a0
cmpl $0x0, 0x5a0(%rdx,%rcx)
jne 0x7eca
addq %rdx, %rcx
addq $0x57c, %rcx            # imm = 0x57C
cmpl $0x0, 0x20(%rcx)
sete %cl
testb %cl, %cl
je 0x7ed8
callq 0x73e3
leaq 0x1abe(%rip), %rdi      # 0x9994
jmp 0x7ef9
imulq $0x34, %rax, %rax
leaq 0x6abd(%rip), %rcx      # 0xe9a0
cmpl $0x0, 0x5a8(%rcx,%rax)
je 0x7f08
callq 0x73e3
leaq 0x201c(%rip), %rdi      # 0x9f15
xorl %eax, %eax
callq 0x2030
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
movl $0x13, %esi
callq 0x4f69
leaq 0x10(%rsp), %rbx
leaq 0x14(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7f5b
movl $0x1, %edi
movl $0x14, %esi
callq 0x4f69
movl (%r14), %edi
callq 0x7683
movl $0x1, %edi
movl $0x15, %esi
callq 0x4f69
movl (%rbx), %edi
callq 0x7683
jmp 0x7f00
// File: /workspace/github_c_makefile_star2_O1/beejjorgensen[P]conquest/conqve.c
// Function: invest
void invest(void)
{
    int newborn, starnum;
    struct stplanet *pplan;
    production_year = 0;
    point(33, 20);
    printw("* investment *  ");
    for (starnum = 1; starnum <= nstars; starnum++) {
        pplan = stars[starnum].first_planet;
        while (pplan != nil) {
            if (((pplan->esee_team) == player)
                && ((pplan->capacity) > 10)
                && ((pplan->esee_def) < 12))
                pplan->esee_def = (pplan->esee_def) + 1;
            if ((pplan->team) != none) {
                newborn = conq_round((pplan->inhabitants)
                                     * growth_rate[pplan->team] *
                                     (1 -
                                      ((pplan->inhabitants) /
                                       (pplan->capacity))));
                if (pplan->conquered)
                    newborn = newborn / 2;
                pplan->inhabitants = (pplan->inhabitants)
                    + newborn;
                pplan->iu = (pplan->iu) + newborn;
                if (pplan->team == ENEMY)
                    inv_enemy(pplan);
                else
                    inv_player(stars[starnum].x, stars[starnum].y, pplan);
            };
            pplan = pplan->next;
        };
    };
    battle();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x6a1d(%rip), %rax      # 0xf798
movl $0x0, (%rax)
movl $0x21, %edi
movl $0x14, %esi
callq 0x4f69
leaq 0x13dc(%rip), %rdi      # 0xa173
xorl %eax, %eax
callq 0x2030
movl $0x1, %r14d
leaq 0x66f5(%rip), %r15      # 0xf4a0
leaq 0x68fe(%rip), %r12      # 0xf6b0
leaq (%r14,%r14,2), %rax
movq 0x8(%r15,%rax,8), %rbx
testq %rbx, %rbx
je 0x8e59
leaq (%r15,%rax,8), %r13
cmpl $0x1, 0x28(%rbx)
jne 0x8de1
cmpl $0xb, 0x4(%rbx)
jl 0x8de1
movl 0x2c(%rbx), %eax
cmpl $0xb, %eax
jg 0x8de1
incl %eax
movl %eax, 0x2c(%rbx)
movslq 0xc(%rbx), %rcx
cmpq $0x2, %rcx
je 0x8e4c
movl 0x10(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss (%r12,%rcx,4), %xmm1
cltd
idivl 0x4(%rbx)
movl $0x1, %ecx
subl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
mulss %xmm1, %xmm0
callq 0x4fe2
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl $0x0, 0x20(%rbx)
cmovel %eax, %ecx
addl %ecx, 0x10(%rbx)
addl %ecx, 0x14(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x8e44
movl (%r13), %edi
movl 0x4(%r13), %esi
movq %rbx, %rdx
callq 0x86de
jmp 0x8e4c
movq %rbx, %rdi
callq 0x8404
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x8dc8
incq %r14
cmpq $0x16, %r14
jne 0x8db2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x37cc
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdx, %rdx
jle 0x19dd
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10d0
movq %rax, %r15
testq %rax, %rax
jg 0x19c2
cmpl $0x0, 0x4792(%rip)      # 0x6148
jg 0x19cc
movl $0x1, %edi
callq 0x1240
addq %r15, %r14
subq %r15, %rbx
jg 0x1998
jmp 0x19d3
callq 0x1280
jmp 0x19b8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movl $0x8, %edx
callq 0x1a61
cmpl $0x4, 0x473d(%rip)      # 0x6148
jge 0x1a34
movq 0x8(%rsp), %rcx
cmpq %r14, %rcx
jg 0x1a40
movq 0x8(%rsp), %rdx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1a61
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8(%rsp), %rdi
callq 0x12a6
jmp 0x1a0d
movq 0x45b1(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x15ee(%rip), %rsi      # 0x303f
leaq 0x15d9(%rip), %rdx      # 0x3031
xorl %eax, %eax
callq 0x1130
jmp 0x1a17
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdx, %rdx
jle 0x1aba
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x1050
movq %rax, %r15
testq %rax, %rax
jg 0x1a9f
cmpl $0x0, 0x46b5(%rip)      # 0x6148
jg 0x1aa9
movl $0x1, %edi
callq 0x1240
addq %r15, %r14
subq %r15, %rbx
jg 0x1a75
jmp 0x1ab0
callq 0x12d1
jmp 0x1a95
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
movq %rsp, %rsi
movq $0x0, (%rsi)
movl $0x8, %edx
callq 0x1b5f
testl %eax, %eax
js 0x1b22
cmpl $0x4, 0x465d(%rip)      # 0x6148
jge 0x1b55
movq (%rsp), %rcx
cmpq %r15, %rcx
jle 0x1aff
cmpl $0x0, 0x464b(%rip)      # 0x6148
jg 0x1b34
movq (%rsp), %rdx
movl %ebp, %edi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x1b5f
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
js 0x1b29
movq (%rsp), %rax
jmp 0x1b29
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x44bd(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x14fa(%rip), %rsi      # 0x303f
leaq 0x1543(%rip), %rdx      # 0x308f
xorl %eax, %eax
callq 0x1130
jmp 0x1aff
movq %rsp, %rdi
callq 0x12f7
jmp 0x1aed
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0x1bbf
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %r13d, %r13d
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1050
movq %rax, %r12
testq %rax, %rax
jg 0x1bae
cmpl $0x3, 0x45ae(%rip)      # 0x6148
jge 0x1bb8
movl $0x1, %edi
callq 0x1240
incl %r13d
cmpl %ebx, %r13d
jge 0x1bd2
addq %r12, %r15
subq %r12, %r14
jg 0x1b7c
jmp 0x1bbf
callq 0x1322
jmp 0x1b9c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2, 0x456a(%rip)      # 0x6148
jl 0x1bc1
callq 0x1348
jmp 0x1bc1
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $-0x1, %edi
je 0x1d4b
retq
pushq %rax
cmpl $0x0, 0x43f5(%rip)      # 0x6148
jle 0x1d5d
movq %rsi, %rdi
callq 0x11b0
movl $0x1, %edi
callq 0x11f0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x38, %rsp
leaq 0xc(%rsp), %r14
movl $0x10, (%r14)
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x11c0
movl %eax, %ebx
leaq 0x1417(%rip), %rsi      # 0x31a7
movl %eax, %edi
callq 0x1d45
leaq 0x14(%rsp), %rsi
movl (%r14), %ecx
leaq 0x20(%rsp), %rdx
movl $0x2, %edi
callq 0x1030
cmpl $0x4, 0x4393(%rip)      # 0x6148
jge 0x1dc1
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x4230(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movzwl 0x12(%rsp), %r8d
leaq 0x13dd(%rip), %rsi      # 0x31b5
leaq 0x13fa(%rip), %rdx      # 0x31d9
leaq 0x20(%rsp), %rcx
xorl %eax, %eax
callq 0x1130
jmp 0x1db7
// File: /workspace/github_c_makefile_star2_O1/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 %rax
callq 0x1100
leaq 0x13f8(%rip), %rsi      # 0x31f2
movl %eax, %edi
callq 0x1d45
cmpl $0x4, 0x4340(%rip)      # 0x6148
jge 0x1e0c
popq %rax
retq
callq 0x13c6
jmp 0x1e0a
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
movl $0x2, %esi
callq 0x10a0
leaq 0x11c7(%rip), %rsi      # 0x3384
movl %eax, %edi
callq 0x1d45
movl %ebx, %edi
callq 0x1100
leaq 0x1020(%rip), %rsi      # 0x31f2
movl %eax, %edi
popq %rbx
jmp 0x1d45
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x320, %rsp            # imm = 0x320
movq %rsp, %rdi
movl $0x64, %esi
callq 0x10c0
movl %eax, %ebx
movq 0x3883(%rip), %r15      # 0x5ff8
movq (%r15), %rdi
leaq 0xfdd(%rip), %rsi       # 0x375c
leaq 0x1055(%rip), %r14      # 0x37db
leaq 0xf0e(%rip), %rcx       # 0x369b
movq %r14, %rdx
xorl %eax, %eax
callq 0x1130
movq (%r15), %rdi
leaq 0x1046(%rip), %rsi      # 0x37e7
movq %r14, %rdx
xorl %eax, %eax
callq 0x1130
leaq 0x10(%rsp), %rdi
decl %ebx
movl %ebx, %esi
movl $0x2, %edx
callq 0x1060
movq (%r15), %rcx
leaq 0x10ab(%rip), %rdi      # 0x3873
movl $0x5, %esi
movl $0x1, %edx
callq 0x1210
movl $0x1, %edi
callq 0x11f0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x2180
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rcx, (%rax)
movl $0x0, 0x8(%rbx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movb %sil, 0x8(%r14)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2180
movq %rax, 0x10(%rbx)
movq %r14, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x10(%r14)
incl 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21f0
movb %r15b, 0x8(%rax)
movl 0x8(%rbx), %ecx
incl %ecx
cmpl %r14d, %ecx
jl 0x24dd
movq (%rbx), %rdx
testl %r14d, %r14d
je 0x249c
cmpl %r14d, %ecx
jne 0x24a7
movq $0x0, 0x10(%rax)
leaq 0x10(%rbx), %rdi
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rdx
jmp 0x24d1
movq %rdx, 0x10(%rax)
xorl %esi, %esi
movq %rbx, %rdi
jmp 0x24d1
testl %r14d, %r14d
jle 0x24dd
cmpl $0x1, %r14d
je 0x24c2
incl %r14d
movq 0x10(%rdx), %rdx
decl %r14d
cmpl $0x2, %r14d
jg 0x24b5
movq %rdx, %rsi
leaq 0x10(%rdx), %rdi
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rax)
movq %rax, (%rdx)
movq %rsi, (%rax)
movq %rax, (%rdi)
movl %ecx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
decl 0x8(%rdi)
movq (%rax), %rcx
movq %rcx, 0x10(%rdi)
movq $0x0, 0x10(%rcx)
movsbl 0x8(%rcx), %ebx
movq %rax, %rdi
callq 0x2030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testl %esi, %esi
je 0x2554
jle 0x2534
movq 0x10(%rdi), %rdi
decl %esi
jne 0x252c
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rdi), %rcx
movq %rax, (%rcx)
decl 0x8(%rbx)
movb 0x8(%rdi), %r14b
callq 0x2030
jmp 0x256e
movq 0x10(%rdi), %rax
movq %rax, (%rbx)
movq $0x0, (%rax)
movb 0x8(%rdi), %r14b
callq 0x2030
decl 0x8(%rbx)
movsbl %r14b, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, 0x10(%rbx)
leaq 0x8(%rax), %rdi
callq 0x23dc
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, (%rax)
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %rax, 0x20(%r14)
movq $0x0, (%r14)
leaq 0x8(%r14), %rdi
callq 0x23dc
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movq %r14, 0x10(%rbx)
incl 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, %r14
leaq 0x8(%rax), %rdi
callq 0x23dc
xorl %eax, %eax
testl %r15d, %r15d
cmovgl %r15d, %eax
incl %eax
movq %rbx, %rcx
movq (%rcx), %rcx
decl %eax
jne 0x266f
movq 0x20(%rcx), %rax
movq %r14, (%rax)
movq %rcx, (%r14)
movq %rax, 0x20(%r14)
movq %r14, 0x20(%rcx)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rcx
movq $0x0, (%rcx)
movq %rcx, 0x10(%rdi)
movq %rax, %rdi
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
incl %ecx
movq %rdi, %rax
movq (%rax), %rax
decl %ecx
jne 0x26c6
movq (%rax), %rcx
testq %rcx, %rcx
je 0x26e8
movq 0x20(%rax), %rdx
movq %rcx, (%rdx)
movq (%rax), %rcx
movq %rdx, 0x20(%rcx)
decl 0x8(%rdi)
jmp 0x26fb
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rcx
movq $0x0, (%rcx)
movq %rcx, 0x10(%rdi)
movq %rax, %rdi
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
callq 0x2040
movq %rax, %rbx
subq $0x8, %rsp
xorl %eax, %eax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2070
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x2100
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2150
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x79ba(%rip), %r13      # 0xa18c
cmpl $0x5, (%r13)
jl 0x2849
leaq 0x79bc(%rip), %rax      # 0xa19c
movl (%rax), %r12d
incl %r12d
leaq 0x79a7(%rip), %r15      # 0xa194
leaq 0x4c39(%rip), %rbx      # 0x742d
xorl %r14d, %r14d
movq 0x77e2(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
movl (%r15), %edx
decl %edx
movl %r14d, %esi
callq 0x2230
leal (%r12,%r14), %eax
movslq %eax, %rsi
imulq $0x66666667, %rsi, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rax
addl %ecx, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2270
incl %r14d
movl (%r13), %eax
addl $-0x4, %eax
cmpl %eax, %r14d
jl 0x27f7
movq 0x7790(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x7763(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2230
leaq 0x7945(%rip), %r14      # 0xa1d8
movq (%r14), %r14
testl %ebx, %ebx
js 0x28a7
leal 0x1(%r12), %eax
cmpl %ebx, %r12d
movl %eax, %r12d
jl 0x2893
testq %r14, %r14
je 0x2906
movl $0x1, %r12d
leaq 0x78d3(%rip), %r13      # 0xa18c
leaq 0x4754(%rip), %rbx      # 0x7014
movl (%r13), %eax
addl $-0x3, %eax
cmpl %eax, %r12d
jge 0x2906
movq 0x770d(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
callq 0x2240
movq 0x8(%r14), %r15
cmpq $0x0, 0x10(%r15)
je 0x28fb
movsbl 0x8(%r15), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2270
movq 0x10(%r15), %r15
jmp 0x28df
incl %r12d
movq (%r14), %r14
testq %r14, %r14
jne 0x28c0
movq 0x76d3(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x2924
movswl (%rdi), %r14d
testq %rdi, %rdi
je 0x292d
movswl 0x2(%rdi), %ebx
callq 0x2100
callq 0x27bd
movq 0x76a2(%rip), %r15      # 0x9fe0
movq (%r15), %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x2230
movq (%r15), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x786c(%rip), %rdi      # 0xa1d8
callq 0x25ac
leaq 0x7840(%rip), %rdi      # 0xa1b8
callq 0x57ec
leaq 0x7844(%rip), %rdi      # 0xa1c8
callq 0x57ec
movq 0x7650(%rip), %rax      # 0x9fe0
movq (%rax), %rax
testq %rax, %rax
je 0x29af
movswl 0x4(%rax), %ecx
incl %ecx
leaq 0x77e7(%rip), %rdx      # 0xa18c
movl %ecx, (%rdx)
movswl 0x6(%rax), %eax
incl %eax
jmp 0x29c1
leaq 0x77d6(%rip), %rax      # 0xa18c
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0x77cc(%rip), %rcx      # 0xa194
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/stdedit.c
// Function: add_line
int add_line(int line){
    int i = 0;
    point *temp = data.front;
    if(line < lines){
        enqueue_pos(&data,line);
    }
    else if( lines == line){
        enqueue(&data);
    }
    for(i = 0; i < line - 1; i++){
        temp = temp->tail;
    }
    char *str = (char *)calloc(2,1);
    str[0] = '\0';
    int x,y;
    char ch[2] = {'\0'};
    i = 0;
    ch[0] = ipops(&(temp->element));

    getyx(stdscr,y,x);
    
    while(ch[0] != '\n'){
       
        i++;
        strcat(str,ch);
         str = realloc(str,strlen(str) +2);
        ch[0] = ipops(&(temp->element));
    }
    ipushs(&(temp->element),'\n');
    if(strlen(str)){
        while(i--){
            ipushs(&(temp->tail->element),str[i]);
        }
    }
    if(line < lines)
        ipushs(&(temp->tail->element),'\n');
    return temp->tail->element.width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x77f2(%rip), %rax      # 0xa1d8
movq (%rax), %r13
leaq 0x7798(%rip), %rax      # 0xa188
cmpl %edi, (%rax)
jle 0x2a04
leaq 0x77dd(%rip), %rdi      # 0xa1d8
movl %ebx, %esi
callq 0x2636
jmp 0x2a12
jne 0x2a12
leaq 0x77cb(%rip), %rdi      # 0xa1d8
callq 0x25ef
cmpl $0x2, %ebx
movq %rbx, -0x38(%rbp)
jl 0x2a26
leal -0x1(%rbx), %eax
movq (%r13), %r13
decl %eax
jne 0x2a1e
movl $0x2, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
movb $0x0, (%rax)
movw $0x0, -0x2a(%rbp)
leaq 0x8(%r13), %r15
movq %r15, %rdi
callq 0x24e8
movb %al, -0x2a(%rbp)
xorl %ebx, %ebx
cmpb $0xa, %al
je 0x2a8f
xorl %ebx, %ebx
leaq -0x2a(%rbp), %r12
incl %ebx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2260
movq %r14, %rdi
callq 0x20c0
leaq 0x2(%rax), %rsi
movq %r14, %rdi
callq 0x2200
movq %rax, %r14
movq %r15, %rdi
callq 0x24e8
movb %al, -0x2a(%rbp)
cmpb $0xa, %al
jne 0x2a5c
movq %r15, %rdi
movl $0xa, %esi
callq 0x2412
cmpb $0x0, (%r14)
sete %al
testl %ebx, %ebx
sete %cl
orb %al, %cl
jne 0x2ac7
movslq %ebx, %rbx
movq (%r13), %rdi
addq $0x8, %rdi
movsbl -0x1(%r14,%rbx), %esi
callq 0x2412
decq %rbx
jne 0x2aaf
movq -0x38(%rbp), %rax
leaq 0x76b6(%rip), %rcx      # 0xa188
cmpl %eax, (%rcx)
jle 0x2ae8
movq (%r13), %rdi
addq $0x8, %rdi
movl $0xa, %esi
callq 0x2412
movq (%r13), %rax
movl 0x10(%rax), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
testl %esi, %esi
je 0x2b3d
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
incl %eax
leaq 0x76c2(%rip), %rcx      # 0xa1d8
movq (%rcx), %rcx
decl %eax
jne 0x2b16
movq 0x8(%rcx), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x2b33
cmpb %dil, 0x8(%rax)
movq %rcx, %rax
jne 0x2b21
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x2b5f
leaq 0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x2b5d
cmpb %dil, 0x8(%rax)
movq %rcx, %rax
jne 0x2b44
movl $0x1, %eax
jmp 0x2b5f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
leaq 0x7119(%rip), %rax      # 0xa1d8
movq (%rax), %rax
testl %edi, %edi
jle 0x30da
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
je 0x30dd
movq %rax, %rbx
decl %edi
jne 0x30c6
jmp 0x30dd
movq %rax, %rbx
leaq 0x8(%rbx), %rdi
callq 0x2592
xorl %ecx, %ecx
cmpl $0xa, %eax
sete %cl
movl 0x10(%rbx), %eax
subl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x2210
movl %eax, %ebx
leaq 0x6e73(%rip), %rax      # 0xa1d8
movq (%rax), %r15
testq %r15, %r15
je 0x33bc
movl $0x1, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
movq 0x8(%r15), %r12
movq %rax, %rdi
callq 0x20c0
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x2200
cmpq $0x0, 0x10(%r12)
je 0x33b7
leaq 0x8(%r12), %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x2080
movq 0x10(%r12), %r12
jmp 0x3397
movq (%r15), %r15
jmp 0x3368
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_c_makefile_star2_O1/vasusharma7[P]Text-Editor/stdedit.c
// Function: read_chunck
int read_chunck(){
    char buffer[2] = {'\0'};
    int x,y,mk;
    point *temp = data.front;
    int count = 0;
    int t = ftrack;
    int k = 0;
    while(k = read(fdr,buffer,1)){
        if(k == 0)  
            return 0;
        if(buffer[0] == '\t' || buffer[0] == '\r')
            continue;
        if(buffer[0] == '\n'){
            x = getwidth(t);
            add_char(buffer[0],t,x);
            t++;
            lines++;
            add_line(t);
            count++;
            move(t,0);
        }
        else{
            x = getwidth(t);
            mk = add_char(buffer[0],t,x);
                if( (x >= (bx - 3))){
                    count++;
                    t++;
                    move(t,0);
                }
                else{
                    move(t,++x);
                }
        }
        if(count >= thresh){
                break;
        }
    }
    clear();
    display(stline);
    refresh();
    ftrack += thresh;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x2e(%rbp), %rbx
movw $0x0, (%rbx)
leaq 0x6bc3(%rip), %r15      # 0xa1a4
movl (%r15), %ecx
movl $0x0, -0x2c(%rbp)
leaq 0x6ba6(%rip), %r12      # 0xa198
movl (%r12), %edi
movl $0x1, %edx
movl %ecx, %r14d
movq %rbx, %rsi
callq 0x2170
testl %eax, %eax
je 0x36ce
movl %r14d, %ecx
movb -0x2e(%rbp), %r13b
movl %r13d, %eax
andb $-0x5, %al
cmpb $0x9, %al
je 0x35f2
movl %ecx, %edi
movl %ecx, %r15d
callq 0x30b2
movsbl %r13b, %edi
movl %r15d, %esi
movl %eax, -0x34(%rbp)
movl %eax, %edx
callq 0x2b61
cmpb $0xa, %r13b
jne 0x366c
incl %r15d
leaq 0x6b3f(%rip), %rax      # 0xa188
incl (%rax)
movl %r15d, %edi
callq 0x29cc
movl -0x2c(%rbp), %r13d
incl %r13d
movq 0x697f(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
movl %r15d, %r14d
movl %r15d, %esi
jmp 0x36a9
leaq 0x6b21(%rip), %rax      # 0xa194
movl (%rax), %eax
addl $-0x3, %eax
movl -0x34(%rbp), %edx
cmpl %eax, %edx
movl -0x2c(%rbp), %r13d
jge 0x3694
movq 0x6956(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
incl %edx
movl %r14d, %esi
jmp 0x36ab
incl %r13d
movl %r14d, %esi
incl %esi
movq 0x693d(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
movl %esi, %r14d
xorl %edx, %edx
callq 0x2230
leaq 0x6aed(%rip), %r15      # 0xa1a4
leaq 0x6ad2(%rip), %rax      # 0xa190
movl %r13d, -0x2c(%rbp)
cmpl (%rax), %r13d
movl %r14d, %ecx
jl 0x35f2
movq 0x690b(%rip), %rbx      # 0x9fe0
movq (%rbx), %rdi
callq 0x20a0
leaq 0x6ab8(%rip), %rax      # 0xa19c
movl (%rax), %edi
callq 0x2866
movq (%rbx), %rdi
callq 0x2100
leaq 0x6a96(%rip), %rax      # 0xa190
movl (%rax), %eax
addl %eax, (%r15)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x32, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2130
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xcffffff, %ecx        # imm = 0xCFFFFFF
jg 0x375c
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x3779
cmpl $0xa000000, %ecx        # imm = 0xA000000
jne 0x376c
jmp 0x3779
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x3779
cmpl $0xd000000, %ecx        # imm = 0xD000000
je 0x3779
movb %al, (%rbx,%r15)
incq %r15
cmpb $-0x1, %al
jne 0x3735
jmp 0x378c
xorl %eax, %eax
cmpl $0xff000000, %ecx       # imm = 0xFF000000
movl %r15d, %ecx
movb $0x0, (%rbx,%rcx)
cmoveq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2070
addq $0x20, %rsp
testl %r12d, %r12d
jle 0x3869
decl %r12d
cmpq $0x3, %r12
movl $0x3, %r13d
cmovbq %r12, %r13
movl %r15d, %r12d
negq %r13
movl $0x1, %r15d
cmpq %r15, %r12
jne 0x383b
movq %rbx, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x2160
movq -0x8(%r14,%r15,8), %r8
movq %rbx, %rdi
movl %r15d, %esi
movl $0x1, %edx
leaq 0x38eb(%rip), %rcx      # 0x710e
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x22c0
jmp 0x3859
movq -0x8(%r14,%r15,8), %r8
movq %rbx, %rdi
movl %r15d, %esi
movl $0x1, %edx
leaq 0x38bc(%rip), %rcx      # 0x710e
xorl %eax, %eax
callq 0x2110
leaq (%r15,%r13), %rax
incq %rax
incq %r15
cmpq $0x2, %rax
jne 0x37f8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x629f(%rip), %r12      # 0x9fe0
movq (%r12), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x3d59
movswl (%rax), %r14d
testq %rax, %rax
je 0x3d62
movswl 0x2(%rax), %ebx
leaq 0x642b(%rip), %rax      # 0xa194
movl (%rax), %esi
leaq 0x641a(%rip), %rax      # 0xa18c
movl (%rax), %edx
addl $-0x3, %edx
movl $0x3, %edi
xorl %ecx, %ecx
callq 0x2720
movq %rax, %r15
movq %rax, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x2160
leaq 0x6400(%rip), %rax      # 0xa19c
movl (%rax), %eax
leal (%rax,%r14), %r8d
incl %r8d
addl %r14d, %eax
cltq
imulq $0x66666667, %rax, %r10 # imm = 0x66666667
movq %r10, %rax
shrq $0x3f, %rax
sarq $0x22, %r10
addl %eax, %r10d
leaq 0x326e(%rip), %rcx      # 0x7034
movq %r15, %rdi
movl $0x1, %esi
movl $0x1, %edx
movl %ebx, %r9d
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x2110
addq $0x10, %rsp
movq %r15, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x22c0
movq %r15, %rdi
callq 0x2100
movq (%r12), %rdi
movl %r14d, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2230
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
incl %edi
leaq 0x63b6(%rip), %rbx      # 0xa1d8
movq (%rbx), %rbx
decl %edi
jne 0x3e22
movslq 0x10(%rbx), %r14
leaq 0x1(%r14), %rdi
movl $0x1, %esi
callq 0x2180
testq %r14, %r14
jle 0x3e60
addq $0x8, %rbx
xorl %ecx, %ecx
movq (%rbx), %rbx
movb 0x8(%rbx), %dl
cmpb $0xa, %dl
je 0x3e60
movb %dl, (%rax,%rcx)
addq $0x10, %rbx
incq %rcx
cmpq %rcx, %r14
jne 0x3e46
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
incl %edi
leaq 0x6360(%rip), %rbx      # 0xa1d8
movq (%rbx), %rbx
decl %edi
jne 0x3e78
movslq 0x10(%rbx), %rdi
addq $0x8, %rbx
addq $0x2, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
movq %rbx, %rdi
callq 0x2577
testl %eax, %eax
jne 0x3ef0
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2519
cmpb $0xa, %al
je 0x3ee1
movb %al, (%r14,%r15)
incq %r15
movq %r14, %rdi
callq 0x20c0
leaq 0x2(%rax), %rsi
movq %r14, %rdi
callq 0x2200
movq %rax, %r14
movq %rbx, %rdi
callq 0x2577
testl %eax, %eax
je 0x3ea7
jmp 0x3ef0
movq %rbx, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x244e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
incl %esi
leaq 0x62c4(%rip), %r14      # 0xa1d8
movq (%r14), %r14
decl %esi
jne 0x3f14
movl $0x2, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, %r15
addq $0x8, %r14
movq %r14, %rdi
callq 0x2577
testl %eax, %eax
jne 0x3f98
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x2519
movl %eax, %esi
shll $0x18, %esi
cmpl $0x20000000, %esi       # imm = 0x20000000
je 0x3f8b
cmpl $0xa000000, %esi        # imm = 0xA000000
je 0x3f8b
movb %al, (%r15,%r12)
incq %r12
movq %r15, %rdi
callq 0x20c0
leaq 0x2(%rax), %rsi
movq %r15, %rdi
callq 0x2200
movq %rax, %r15
movq %r14, %rdi
callq 0x2577
testl %eax, %eax
je 0x3f40
jmp 0x3f98
sarl $0x18, %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x244e
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
incl %esi
leaq 0x6220(%rip), %rax      # 0xa1d8
movq (%rax), %rax
decl %esi
jne 0x3fb8
movq 0x8(%rax), %r14
testl %edi, %edi
je 0x3fcf
movq 0x10(%r14), %r14
decl %edi
jne 0x3fc7
movl $0x2, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, %rbx
cmpq $0x0, 0x10(%r14)
je 0x402b
leaq 0x10(%r14), %r12
xorl %r15d, %r15d
movzbl 0x8(%r14), %eax
cmpl $0xa, %eax
je 0x402b
cmpl $0x20, %eax
je 0x402b
movb %al, (%rbx,%r15)
incq %r15
movq %rbx, %rdi
callq 0x20c0
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x2200
movq %rax, %rbx
movq (%r12), %r14
leaq 0x10(%r14), %r12
cmpq $0x0, 0x10(%r14)
jne 0x3fef
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq