LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: dthread_kill
int dthread_kill(dthread_t thread, int sig) {
    //no signal
    if(sig == 0) {
        return 0;
    }
    //invalid signal
    if(sig < 0 || sig > 64) {
        return EINVAL;
    }

    // check if current thread id is same as the thread passed

    int status = -1;
    if(thread == td_cur->tid) {
        status = raise(sig);
    }

    //otherwise store it into the thread structure to raise it later
    else {
        dthread *temp = get_node_by_tid(threads, thread);
        if(temp != NULL) {
            temp->signal = sig;
            status = 0;
        }
        else {
            status = ESRCH;
        }
    }
   
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x18fe
movl $0x0, -0x4(%rbp)
jmp 0x1977
cmpl $0x0, -0x14(%rbp)
jl 0x190a
cmpl $0x40, -0x14(%rbp)
jle 0x1913
movl $0x16, -0x4(%rbp)
jmp 0x1977
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x379b(%rip), %rcx      # 0x50c0
cmpq (%rcx), %rax
jne 0x1937
movl -0x14(%rbp), %edi
callq 0x1030
movl %eax, -0x18(%rbp)
jmp 0x1971
movq 0x377a(%rip), %rdi      # 0x50b8
movq -0x10(%rbp), %rsi
callq 0x1c00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1968
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xf8(%rax)
movl $0x0, -0x18(%rbp)
jmp 0x196f
movl $0x3, -0x18(%rbp)
jmp 0x1971
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: dthread_spin_trylock
int dthread_spin_trylock(dthread_spinlock_t *lock) {
    if(__sync_lock_test_and_set(lock,1)) {
        return EBUSY;
    }
    else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0x1, %eax
xchgl %eax, (%rcx)
cmpl $0x0, %eax
je 0x19e1
movl $0x10, -0x4(%rbp)
jmp 0x19e8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: dthread_spin_unlock
int dthread_spin_unlock(dthread_spinlock_t *lock) {
    if(*lock == 1) {
        __sync_lock_release(lock,0);
        return 0;
    }
    return EINVAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1a14
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1a1b
movl $0x16, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/queue.c
// Function: enqueue
void enqueue(queue *t, dthread *td) {
    node *ptr = (node *)malloc(sizeof(node));
    //assigning the new node details
    ptr->td = td;
    ptr->next = NULL;
    //checking if the queue is empty, if empty head and tail points to ptr
    if(t->count == 0) {
        t->head = t->tail = ptr;
    }

    //otherwise append the node to last changing the tail pointer to ptr
    else {
        t->tail->next = ptr;
        t->tail = ptr;
    }
    //increment the count
    t->count = t->count+ 1;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1ac4
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1ae0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/queue.c
// Function: dequeue
dthread* dequeue(queue *t) {
    //check if the queue is empty
     if(t->count == 0 ) {
        return NULL;
     }
    dthread *td = t->head->td;
    t->head = t->head->next;
    t->count = t->count - 1;
    //check if the new head is null or not , if yes then change the tail
    if(t->head == NULL) {
        t->tail = NULL;
    }
    return(td);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1b1c
movq $0x0, -0x8(%rbp)
jmp 0x1b6b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1b63
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/queue.c
// Function: show
void show(queue *t) {
    node *ptr;
    if(t->head == NULL) {
        printf("\nEmpty");
        return;
    }
    ptr = t->head;
    while(ptr != NULL) {
        printf("\nTID: %ld", ptr->td->tid);
        ptr = ptr->next;
    }
    printf("\nTOTAL: %d",t->count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1ba6
leaq 0x1478(%rip), %rdi      # 0x3015
movb $0x0, %al
callq 0x1070
jmp 0x1bf3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bde
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x1453(%rip), %rdi      # 0x301c
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1bb1
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x143a(%rip), %rdi      # 0x3026
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/queue.c
// Function: get_node_by_tid
dthread* get_node_by_tid(queue *t, dthread_t tid) {
    node *temp;
    dthread *td;
    if(t->head == NULL) {
        return NULL;
    }
    temp = t->head;
    while(temp != NULL) {
        if(tid == temp->td->tid) {
            return temp->td;
        }
        else {
            temp = temp->next;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1c20
movq $0x0, -0x8(%rbp)
jmp 0x1c65
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c5d
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jne 0x1c4f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c65
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1c2b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/methods.c
// Function: add
void* add(void *args) {
    // addition of two numbers
    int a = 89;
    int b = 11;
    return (void *)(intptr_t)(a+b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x59, -0xc(%rbp)
movl $0xb, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cltq
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/methods.c
// Function: deadlock
void* deadlock(void *args) {
    
    int d  = dthread_join(t1[2], NULL);

    check = testing(d,EDEADLK);
    if(check == 0) {
        printf(RED "**FAILED**: Deadlock Join test\n" NONE);
    }
    else {
        printf(GREEN "**PASSED**: Deadlock join test\n" NONE);
    }
    return (void *)(intptr_t)(d);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x340d(%rip), %rdi      # 0x5100
xorl %eax, %eax
movl %eax, %esi
callq 0x1800
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0x23, %esi
callq 0x1c70
movl %eax, 0x342e(%rip)      # 0x5140
cmpl $0x0, 0x3427(%rip)      # 0x5140
jne 0x1d2b
leaq 0x130f(%rip), %rdi      # 0x3031
movb $0x0, %al
callq 0x1070
jmp 0x1d39
leaq 0x132c(%rip), %rdi      # 0x305e
movb $0x0, %al
callq 0x1070
movslq -0xc(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/methods.c
// Function: exit_control
void* exit_control(void *args) {
    counter++;
    dthread_exit(NULL);
    counter++;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x33c2(%rip), %eax      # 0x5144
addl $0x1, %eax
movl %eax, 0x33b9(%rip)      # 0x5144
xorl %eax, %eax
movl %eax, %edi
callq 0x18a0
movl 0x33aa(%rip), %eax      # 0x5144
addl $0x1, %eax
movl %eax, 0x33a1(%rip)      # 0x5144
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_23/c_remove_comments.c
// Function: main
int main(void)
{
  /**
   * This is multiline
   * block
   * comment.
  */

  char str[MAXSTR];
  char no_com_str[MAXSTR];

  get_str(str, MAXSTR);

  remove_comments(str, no_com_str);

  printf("%s", no_com_str);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e30, %rsp           # imm = 0x4E30
movl $0x0, -0x4(%rbp)
leaq -0x2720(%rbp), %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11b0
leaq -0x2720(%rbp), %rdi
leaq -0x4e30(%rbp), %rsi
callq 0x1230
leaq -0x4e30(%rbp), %rsi
leaq 0xe70(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x4e30, %rsp           # imm = 0x4E30
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_23/c_remove_comments.c
// Function: get_str
int get_str(char str[], int limit)
{
  int c, i = 0;

  while (i < limit - 1 && (c = getchar()) != EOF)
  {
    str[i++] = c;
  }
  str[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jge 0x11e9
callq 0x1040
movl %eax, -0x10(%rbp)
cmpl $-0x1, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x11f2
jmp 0x120e
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x11c6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: Setup
int Setup(const uint8 *skey)
{
	uint8 cst[16] = {0};

	KeySchedule(KeyLen, ENC, skey);
	Encryption(KeyLen, cst, Q); // Q = E(0)
	return SUCCESS;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movq 0x10(%rsp), %rdx
movl $0x100, %edi            # imm = 0x100
xorl %esi, %esi
callq 0x1090
movq %rsp, %rsi
movl $0x100, %edi            # imm = 0x100
movq 0x4d88(%rip), %rdx      # 0x5fc0
callq 0x10f0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: nEnc
int nEnc(const uint8 *nonce, uint32 nonce_len, uint32 t_len){
	uint8 tmp[BLOCK]={0};

	memcpy(&tmp[BLOCK-nonce_len],nonce,nonce_len);
	tmp[0]=(uint8)((t_len*8)%(BLOCK*8)<<1);
	tmp[BLOCK-nonce_len-1] |= 0x01;
	Encryption(KeyLen, tmp, L);
	if(ADP==Seri){
		xor(L, TA, L); 
		mul2(L,L); /* L <- 2(E(Format(tau,N)) + TA)*/
	}
	mul3(L, Ls); 
	return SUCCESS;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movl $0x10, %eax
subl 0x1c(%rsp), %eax
movl %eax, %eax
movq %rsp, %rdi
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x1110
movl 0x18(%rsp), %eax
shll $0x3, %eax
andl $0x7f, %eax
shll %eax
movb %al, (%rsp)
movl $0x10, %eax
subl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movzbl (%rsp,%rax), %ecx
orl $0x1, %ecx
movb %cl, (%rsp,%rax)
movq %rsp, %rsi
movl $0x100, %edi            # imm = 0x100
movq 0x4cd9(%rip), %rdx      # 0x5fa0
callq 0x10f0
movq 0x4ccd(%rip), %rdx      # 0x5fa0
movq 0x4d0e(%rip), %rsi      # 0x5fe8
movq %rdx, %rdi
callq 0x1310
movq 0x4cb7(%rip), %rsi      # 0x5fa0
movq %rsi, %rdi
callq 0x1370
movq 0x4ca8(%rip), %rdi      # 0x5fa0
movq 0x4cf9(%rip), %rsi      # 0x5ff8
callq 0x1410
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: mul2
static void mul2(uint8 *in, uint8 *out)
{
	int i, t = in[0] >> 7;
    for(i = 0; i < 15; i++)
        out[i] = (in[i] << 1) | (in[i + 1] >> 7);
    out[15] = (in[15] << 1) ^ cst_mul[t];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
sarl $0x7, %eax
movl %eax, -0x18(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0xf, -0x14(%rsp)
jge 0x13dc
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
shll %eax
movq -0x8(%rsp), %rcx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1391
movq -0x8(%rsp), %rax
movzbl 0xf(%rax), %eax
shll %eax
movslq -0x18(%rsp), %rdx
leaq 0x2c0d(%rip), %rcx      # 0x4000
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0xf(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: ozp
static void ozp(uint32 length, const uint8 *in, uint8 *out){
	memset(out,0,BLOCK);
	memcpy(out,in,length);
	if(length<BLOCK){
		out[length] = 0x80;
	}
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x1110
cmpl $0x10, 0x14(%rsp)
jae 0x1898
movq (%rsp), %rax
movl 0x14(%rsp), %ecx
movb $-0x80, (%rax,%rcx)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: mul7
static void mul7(uint8 *in, uint8 *out) /*7X = 2(2X) + 2X + X */
{
	uint8	tmp[BLOCK];
	mul2(in, tmp);
	xor(in, tmp, out); 
	mul2(tmp, tmp); 
	xor(out, tmp, out);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1370
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq 0x18(%rsp), %rdx
callq 0x1310
movq %rsp, %rdi
movq %rsp, %rsi
callq 0x1370
movq 0x18(%rsp), %rdi
movq %rsp, %rsi
movq 0x18(%rsp), %rdx
callq 0x1310
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: AFunc
int AFunc(
		  const uint8 *header,
		  uint32 h_len)
{
	uint32 i,j = 0;
	uint32 m, last;
	uint8 ASum[BLOCK]={0}, tmp[BLOCK], Qt[BLOCK];

	last = h_len % BLOCK;
	if(last == 0) last = BLOCK;
	m = (h_len-last) / BLOCK; /*header = m blocks + last bytes*/

	memcpy(Qt,Q,BLOCK);
	/* XE */
	for(i = 0; i < m; i++, j=j+BLOCK){
		xor(Qt,header+j,tmp);
		Encryption(KeyLen,tmp,tmp);
		xor(ASum,tmp,ASum);
		mul2(Qt,Qt);
	}
	/* last block */
	ozp(last,header+j,tmp);
	xor(ASum,tmp,ASum);

	if(last != BLOCK ){/*partial block*/
		mul3(Qt,Qt);
	}
	else{/*integral block*/
		mul3twice(Qt,Qt);
	}
	xor(ASum,Qt,ASum);
	Encryption(KeyLen,ASum,TA);
    return SUCCESS;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movl 0x4c(%rsp), %eax
andl $0xf, %eax
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x1d10
movl $0x10, 0x3c(%rsp)
movl 0x4c(%rsp), %eax
subl 0x3c(%rsp), %eax
shrl $0x4, %eax
movl %eax, 0x40(%rsp)
movq 0x429a(%rip), %rax      # 0x5fc0
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x1dac
movq %rsp, %rdi
movq 0x50(%rsp), %rsi
movl 0x44(%rsp), %eax
addq %rax, %rsi
leaq 0x10(%rsp), %rdx
callq 0x1310
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x100, %edi            # imm = 0x100
callq 0x10f0
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1310
movq %rsp, %rdi
movq %rsp, %rsi
callq 0x1370
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
movl 0x44(%rsp), %eax
addl $0x10, %eax
movl %eax, 0x44(%rsp)
jmp 0x1d3e
movl 0x3c(%rsp), %edi
movq 0x50(%rsp), %rsi
movl 0x44(%rsp), %eax
addq %rax, %rsi
leaq 0x10(%rsp), %rdx
callq 0x1850
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1310
cmpl $0x10, 0x3c(%rsp)
je 0x1dee
movq %rsp, %rdi
movq %rsp, %rsi
callq 0x1410
jmp 0x1df9
movq %rsp, %rdi
movq %rsp, %rsi
callq 0x18f0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
callq 0x1310
leaq 0x20(%rsp), %rsi
movl $0x100, %edi            # imm = 0x100
movq 0x41cc(%rip), %rdx      # 0x5fe8
callq 0x10f0
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: AFuncS
int AFuncS(
		  const uint8 *header,
		  uint32 h_len)
{
	uint32 i,j = 0;
	uint32 m, last;
	uint8 tmp[BLOCK], chain[BLOCK]={0}, Qt[BLOCK];

	last = h_len % BLOCK;
	if(last == 0) last = BLOCK;
	m = (h_len-last) / BLOCK; /*header = m blocks + last bytes*/

	/* CBC */
	for(i = 0; i < m; i++, j=j+BLOCK){
		xor(chain,header+j,chain);
		Encryption(KeyLen,chain,chain);
	}
	/* last block */
	ozp(last,header+j,tmp);
	xor(tmp,chain,chain);
	if(last != BLOCK ){/*partial block*/
		mul2(Q,Qt);
	}
	else{/*integral block*/
		mul2twice(Q,Qt);
	}
	xor(chain,Qt,chain);
	Encryption(KeyLen,chain,TA);
    return SUCCESS;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movl 0x4c(%rsp), %eax
andl $0xf, %eax
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x1e70
movl $0x10, 0x3c(%rsp)
movl 0x4c(%rsp), %eax
subl 0x3c(%rsp), %eax
shrl $0x4, %eax
movl %eax, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x1ed8
leaq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x44(%rsp), %eax
addq %rax, %rsi
leaq 0x10(%rsp), %rdx
callq 0x1310
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x100, %edi            # imm = 0x100
callq 0x10f0
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
movl 0x44(%rsp), %eax
addl $0x10, %eax
movl %eax, 0x44(%rsp)
jmp 0x1e87
movl 0x3c(%rsp), %edi
movq 0x50(%rsp), %rsi
movl 0x44(%rsp), %eax
addq %rax, %rsi
leaq 0x20(%rsp), %rdx
callq 0x1850
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1310
cmpl $0x10, 0x3c(%rsp)
je 0x1f1e
movq %rsp, %rsi
movq 0x40a9(%rip), %rdi      # 0x5fc0
callq 0x1370
jmp 0x1f2d
movq %rsp, %rsi
movq 0x4098(%rip), %rdi      # 0x5fc0
callq 0x1f60
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
callq 0x1310
leaq 0x10(%rsp), %rsi
movl $0x100, %edi            # imm = 0x100
movq 0x4098(%rip), %rdx      # 0x5fe8
callq 0x10f0
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: AE_Encrypt
int AE_Encrypt(
	      const uint8 *nonce,
		  uint32 nonce_len,
		  const uint8 *plaintext,
		  uint32 pl_len,
		  const uint8 *header,
		  uint32 h_len,
		  uint32 t_len,
		  uint8 *ciphertext,
		  uint8 *tag)
{
	if(ADP==Para)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFunc(header,h_len);
		}
		EFunc(nonce,nonce_len,plaintext,pl_len,t_len,ciphertext);
		xorp(t_len,TE,TA,tag);
	}
	else if(ADP==Seri)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFuncS(header,h_len);
		}
			EFunc(nonce,nonce_len,plaintext,pl_len,t_len,ciphertext);
			memcpy(tag,TE,t_len);
	}
	return SUCCESS;
}

// Assembly:
subq $0x38, %rsp
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rax
movl 0x40(%rsp), %eax
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1fea
movq 0x400c(%rip), %rdi      # 0x5fe8
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
jmp 0x1ff8
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x10d0
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movl 0x40(%rsp), %r8d
movq 0x48(%rsp), %r9
callq 0x1070
movq 0x50(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, %edx
movq 0x3fb5(%rip), %rsi      # 0x5fe0
callq 0x1110
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: AE_Decrypt
int AE_Decrypt(
	      const uint8 *nonce,
		  uint32 nonce_len,
		  const uint8 *ciphertext,
		  uint32 ci_len,
		  const uint8 *header,
		  uint32 h_len,
		  uint32 t_len,
  		  const uint8 *tag,
		  uint8 *plaintext)
{
	uint32 i;
	uint8 loctag[BLOCK];

	if(ADP==Para)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFunc(header,h_len);
		}
			DFunc(nonce,nonce_len,ciphertext,ci_len,t_len,plaintext);
			xorp(t_len,TE,TA,loctag);
	}
	else if(ADP==Seri)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFuncS(header,h_len);
		}
			DFunc(nonce,nonce_len,ciphertext,ci_len,t_len,plaintext);
			memcpy(loctag,TE,t_len);
	}

	if(memcmp(loctag,tag,t_len)!=0){/*verfication failure*/
		for(i=0; i<ci_len; i++)plaintext[i] = 0;/* zeroing wrong plaintext*/
		return TAG_UNMATCH;
	}
	return TAG_MATCH;
}

// Assembly:
subq $0x48, %rsp
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movl 0x50(%rsp), %eax
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x208a
movq 0x3f6c(%rip), %rdi      # 0x5fe8
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
jmp 0x2098
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x10d0
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
movl 0x50(%rsp), %r8d
movq 0x60(%rsp), %r9
callq 0x1080
movq %rsp, %rdi
movl 0x50(%rsp), %eax
movl %eax, %edx
movq 0x3f17(%rip), %rsi      # 0x5fe0
callq 0x1110
movq %rsp, %rdi
movq 0x58(%rsp), %rsi
movl 0x50(%rsp), %eax
movl %eax, %edx
callq 0x1100
cmpl $0x0, %eax
je 0x211c
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x2112
movq 0x60(%rsp), %rax
movl 0x10(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x20ee
movl $0x1, 0x44(%rsp)
jmp 0x2124
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
	unsigned char *c,unsigned long long *clen,
	const unsigned char *m,unsigned long long mlen,
	const unsigned char *ad,unsigned long long adlen,
	const unsigned char *nsec,
	const unsigned char *npub,
	const unsigned char *k
	)
{
	Setup(k);
	AE_Encrypt(npub, CRYPTO_NPUBBYTES, m, (uint32)mlen, ad, (uint32)adlen, CRYPTO_ABYTES, c, c+mlen);

	*clen = mlen + CRYPTO_ABYTES;

	return 0;
}

// Assembly:
subq $0x48, %rsp
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1040
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rax
movl %eax, %ecx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %rax
movl %eax, %r9d
movq 0x40(%rsp), %r10
movq 0x40(%rsp), %rax
addq 0x28(%rsp), %rax
movl $0xc, %esi
movl $0x10, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x10c0
movq 0x28(%rsp), %rcx
addq $0x10, %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
	unsigned char *m,unsigned long long *mlen,
	unsigned char *nsec,
	const unsigned char *c,unsigned long long clen,
	const unsigned char *ad,unsigned long long adlen,
	const unsigned char *npub,
	const unsigned char *k
	)
{
	int		rc;

	*mlen = clen - CRYPTO_ABYTES;

	Setup(k);
	rc = AE_Decrypt(npub, CRYPTO_NPUBBYTES, c, (uint32)*mlen, ad, (uint32)adlen, CRYPTO_ABYTES, c+*mlen, m);

	if(rc == TAG_UNMATCH)
		return -1;
	else
		return 0;
}

// Assembly:
subq $0x58, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x28(%rsp), %rcx
subq $0x10, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x70(%rsp), %rdi
callq 0x1040
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x40(%rsp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq 0x20(%rsp), %r8
movq 0x60(%rsp), %rax
movl %eax, %r9d
movq 0x30(%rsp), %r10
movq 0x40(%rsp), %rax
addq (%rax), %r10
movq 0x48(%rsp), %rax
movl $0xc, %esi
movl $0x10, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1060
movl %eax, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x227f
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x2287
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: createList
List createList()
{
    List head;
    head=(List)malloc(sizeof(Node));
    if(head==NULL)
    {
        fatal("memory alloc failed!");
    }
    head->next=NULL;
    head->prev=NULL;
    return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1060
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11a9
leaq 0xe60(%rip), %rdi       # 0x2004
callq 0x11d0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: destroyList
void destroyList(List list)
{
    assert(list!=NULL);
    Node* tmp;
    Node* p=list->next;
    list->next=NULL;
    while(p!=NULL)
    {
        tmp=p->next;
        free(p);
        p=tmp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1215
jmp 0x1234
leaq 0xdfd(%rip), %rdi       # 0x2019
leaq 0xe01(%rip), %rsi       # 0x2024
movl $0x17, %edx
leaq 0xdfd(%rip), %rcx       # 0x202c
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x1272
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x124c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: last
Node* last(List list)
{
    assert(list!=NULL);
    Node* p=list->next;
    while(p!=NULL)
    {
        p=p->next;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12e5
jmp 0x1304
leaq 0xd2d(%rip), %rdi       # 0x2019
leaq 0xd31(%rip), %rsi       # 0x2024
movl $0x29, %edx
leaq 0xd56(%rip), %rcx       # 0x2055
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1325
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1310
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: find
Node* find(int value, List list)
{
    Node* node=list->next;
    while(node!=NULL && node->value!=value)
    {
        node=node->next;
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x13a2
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x13ab
jmp 0x13b9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1387
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: delete
void delete(int value, List list)
{
    assert(list!=NULL);
    Node* prev=list;
    while(prev!=NULL && prev->next->value != value)
    {
        prev=prev->next;
    }
    Node* current=prev->next;
    prev->next=current->next;
    free(current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13d8
jmp 0x13f7
leaq 0xc3a(%rip), %rdi       # 0x2019
leaq 0xc3e(%rip), %rsi       # 0x2024
movl $0x44, %edx
leaq 0xc74(%rip), %rcx       # 0x2066
callq 0x1050
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x141e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1427
jmp 0x1435
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13ff
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: delete2
void delete2(Node* node)
{
    assert(node!=NULL);
    if(node->next==NULL||node->prev==NULL)
    {
        free(node);
        node=NULL;
    }
    else
    {
        node->prev->next=node->next;
        free(node);
        node=NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1475
jmp 0x1494
leaq 0xc01(%rip), %rdi       # 0x207d
leaq 0xba1(%rip), %rsi       # 0x2024
movl $0x50, %edx
leaq 0xbf9(%rip), %rcx       # 0x2088
callq 0x1050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14aa
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x14bd
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x14e2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: insert
Node* insert(int value, Node* node, List list)
{
    Node* newNode=(Node*)malloc(sizeof(Node));
    if(newNode==NULL)
    {
        fatal("memory alloc failed!");
    }
    newNode->value=value;
    newNode->prev=node;
    newNode->next=node->next;
    node->next=newNode;
    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1524
leaq 0xae5(%rip), %rdi       # 0x2004
callq 0x11d0
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: insertBefore
void insertBefore(int value, Node* node, List list)
{
    Node* newNode=(Node*)malloc(sizeof(Node));
    if(newNode==NULL)
    {
        fatal("memory alloc failed!");
    }
    Node* prev=node->prev;
    prev->next=newNode;
    node->prev=newNode;
    newNode->prev=prev;
    newNode->next=node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1594
leaq 0xa75(%rip), %rdi       # 0x2004
callq 0x11d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: sort
List sort(List list)
{
    //TODO
    Node* cur=list->next;
    Node* prev;
    Node* next;
    Node* tmp;
    Node* tail=NULL;
    if(cur!=NULL && cur->next!=NULL){
        prev=cur->prev;
        next=cur->next;
        tmp=next->next;
    }
    
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1672
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1672
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: reverse
List reverse(List list)
{
    assert(list!=NULL);
    Node* cur;
    Node* next;
    Node* tmp;
    cur=list->next;
    if(cur!=NULL && cur->next!=NULL)
    {
        next=cur->next;
        cur->next=NULL;
        while(next!=NULL)
        {
            cur->prev=next;
            tmp=next->next;
            next->next=cur;
            cur=next;
            next=tmp;
        }
        cur->prev=list;
        list->next=cur;

    }
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1695
jmp 0x16b4
leaq 0x97d(%rip), %rdi       # 0x2019
leaq 0x981(%rip), %rsi       # 0x2024
movl $0x91, %edx
leaq 0x9ee(%rip), %rcx       # 0x209d
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x173f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x173f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x1727
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x16ea
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: print
void print(List list)
{
    assert(list!=NULL);
    Node* node=list->next;
    while(node!=NULL)
    {
        printf("%d -> ", node->value);
        node=node->next;
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1765
jmp 0x1784
leaq 0x8ad(%rip), %rdi       # 0x2019
leaq 0x8b1(%rip), %rsi       # 0x2024
movl $0xaa, %edx
leaq 0x931(%rip), %rcx       # 0x20b0
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17b9
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x91d(%rip), %rdi       # 0x20c1
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1790
leaq 0x908(%rip), %rdi       # 0x20c8
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: clear
void clear(List list)
{
    Node* node=list->next;
    Node* tmp;
    while(node!=NULL)
    {
        tmp=node->next;
        free(node);
        node=tmp;
    }
    list->next=NULL;
}

// 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)
cmpq $0x0, -0x10(%rbp)
je 0x180e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x17e8
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: length
int length(List list)
{
    assert(list!=NULL);
    int len=0;
    Node* node=list->next;
    while(node!=NULL)
    {
        len++;
        node=node->next;
    }
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1835
jmp 0x1854
leaq 0x7dd(%rip), %rdi       # 0x2019
leaq 0x7e1(%rip), %rsi       # 0x2024
movl $0xc1, %edx
leaq 0x87b(%rip), %rcx       # 0x20ca
callq 0x1050
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1885
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1867
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/list_double/dlist.c
// Function: main
int main(int argc, char **argv)
{
    List list=createList();
    int i;
    Node* lastNode=list;
    for(i=0; i<10; i++)
    {
        Node* node=(Node*)malloc(sizeof(Node));
        if(node==NULL)
        {
            fatal("memory allocate failed.");
        }
        //Node* current=insert(rand()%100, lastNode, list);
        Node* current=insert(i, lastNode, list);
        lastNode=current;
    }
    print(list);
    print(reverse(list));
    print(sort(list));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x193c
movl $0x18, %edi
callq 0x1060
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1915
leaq 0x7db(%rip), %rdi       # 0x20eb
callq 0x11d0
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18ee
movq -0x18(%rbp), %rdi
callq 0x1750
movq -0x18(%rbp), %rdi
callq 0x1680
movq %rax, %rdi
callq 0x1750
movq -0x18(%rbp), %rdi
callq 0x1620
movq %rax, %rdi
callq 0x1750
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/reap.c
// Function: main
int main(void) {
  signal(SIGCHLD, SIG_IGN);
  while (1)
    pause();
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x11, %edi
movl $0x1, %esi
callq 0x1030
callq 0x1040
jmp 0x116e
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/glove.c
// Function: load_init_file
int load_init_file(char *file_name, real *array, long long array_size) {
    FILE *fin;
    long long a;
    fin = fopen(file_name, "rb");
    if (fin == NULL) {
        log_file_loading_error("init file", file_name);
        return -1;
    }
    for (a = 0; a < array_size; a++) {
        if (feof(fin)) {
            fprintf(stderr, "EOF reached before data fully loaded in %s.\n", file_name);
            fclose(fin);
            return -1;
        }
        fread(&array[a], sizeof(real), 1, fin);
    }
    fclose(fin);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3cb1(%rip), %rsi      # 0x5040
callq 0x11d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x13bb
movq -0x10(%rbp), %rsi
leaq 0x3c99(%rip), %rdi      # 0x5043
callq 0x4120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1449
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1439
movq -0x28(%rbp), %rdi
callq 0x1150
cmpl $0x0, %eax
je 0x1409
movq 0x6c16(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3c5d(%rip), %rsi      # 0x504d
movb $0x0, %al
callq 0x1140
movq -0x28(%rbp), %rdi
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1449
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x1090
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x13c3
movq -0x28(%rbp), %rdi
callq 0x10d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/glove.c
// Function: check_nan
static inline real check_nan(real update) {
    if (isnan(update) || isinf(update)) {
        fprintf(stderr,"\ncaught NaN in update");
        return 0.;
    } else {
        return update;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x1fd6
movsd -0x10(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x3094(%rip), %xmm2     # 0x5030
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x3062(%rip), %xmm1     # 0x5020
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x1ff8
movq 0x601b(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3fd1(%rip), %rsi      # 0x5fb8
movb $0x0, %al
callq 0x1140
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2002
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/common.c
// Function: bitwisehash
unsigned int bitwisehash(char *word, int tsize, unsigned int seed) {
    char c;
    unsigned int h;
    h = seed;
    for ( ; (c = *word) != '\0'; word++) h ^= ((h << 5) + c + (h >> 2));
    return (unsigned int)((h & 0x7fffffff) % tsize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x3d9d
movl -0x18(%rbp), %eax
shll $0x5, %eax
movsbl -0x11(%rbp), %ecx
addl %ecx, %eax
movl -0x18(%rbp), %ecx
shrl $0x2, %ecx
addl %ecx, %eax
xorl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3d64
movl -0x18(%rbp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/common.c
// Function: inithashtable
HASHREC ** inithashtable(void) {
    int i;
    HASHREC **ht;
    ht = (HASHREC **) malloc( sizeof(HASHREC *) * TSIZE );
    for (i = 0; i < TSIZE; i++) ht[i] = (HASHREC *) NULL;
    return ht;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x800000, %edi         # imm = 0x800000
callq 0x1180
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x100000, -0x4(%rbp)   # imm = 0x100000
jge 0x3df1
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3dcd
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/common.c
// Function: find_arg
int find_arg(char *str, int argc, char **argv) {
    int i;
    for (i = 1; i < argc; i++) {
        if (!scmp(str, argv[i])) {
            if (i == argc - 1) {
                printf("No argument given for %s\n", str);
                exit(1);
            }
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x402a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3ce0
cmpl $0x0, %eax
jne 0x401d
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4015
movq -0x10(%rbp), %rsi
leaq 0x1fca(%rip), %rdi      # 0x5fce
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1200
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4031
jmp 0x401f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3fca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/common.c
// Function: free_table
void free_table(HASHREC **ht) {
    int i;
    HASHREC* current;
    HASHREC* tmp;
    for (i = 0; i < TSIZE; i++) {
        current = ht[i];
        while (current != NULL) {
            tmp = current;
            current = current->next;
            free(tmp->word);
            free(tmp);
        }
    }
    free(ht);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100000, -0xc(%rbp)   # imm = 0x100000
jge 0x40ab
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x409e
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x406c
jmp 0x40a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4053
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/common.c
// Function: free_fid
void free_fid(FILE **fid, const int num) {
    int i;
    for(i = 0; i < num; i++) {
        if(fid[i] != NULL)
            fclose(fid[i]);
    }
    free(fid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x410b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x40fe
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10d0
jmp 0x4100
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x40d6
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)