LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_memtable.c
// Function: main
int main(int argc, char **argv){
	if (argc < 2){
		printf("Usage:\n");
		printf("\t%s filename [key to find]\n", argv[0]);
		exit(1);
	}

	const char *filename = argv[1];


	hm_memtable_t *v = hm_memtable_createa();


	printf("Load file\n");
	_loadfile(v, filename, 0);
	printf("Done...\n");


	if (argc > 2){
		// Find the key
		const char *findkey = argv[2];
		_findkey(v, findkey);
	}


	//getchar();


	// Free list

	printf("Free file\n");
	hm_memtable_removeall(v);
	printf("Done...\n");

	printf("Destroy file\n");
	hm_memtable_destroy(v);
	free(v);
	printf("Done...\n");


	//getchar();


	printf("main() end...\n");

	return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x2, 0x20(%rsp)
jge 0x126a
leaq 0x1dc1(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1060
movq 0x18(%rsp), %rax
movq (%rax), %rsi
leaq 0x1db3(%rip), %rdi      # 0x300c
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x10e0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x2520
movq %rax, 0x8(%rsp)
leaq 0x1d9d(%rip), %rdi      # 0x3028
movb $0x0, %al
callq 0x1060
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x1340
leaq 0x1d89(%rip), %rdi      # 0x3033
movb $0x0, %al
callq 0x1060
cmpl $0x2, 0x20(%rsp)
jle 0x12d3
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1470
leaq 0x1d62(%rip), %rdi      # 0x303c
movb $0x0, %al
callq 0x1060
movq 0x8(%rsp), %rdi
callq 0x2560
leaq 0x1d41(%rip), %rdi      # 0x3033
movb $0x0, %al
callq 0x1060
leaq 0x1d47(%rip), %rdi      # 0x3047
movb $0x0, %al
callq 0x1060
movq 0x8(%rsp), %rdi
callq 0x2550
movq 0x8(%rsp), %rdi
callq 0x1030
leaq 0x1d11(%rip), %rdi      # 0x3033
movb $0x0, %al
callq 0x1060
leaq 0x1d25(%rip), %rdi      # 0x3055
movb $0x0, %al
callq 0x1060
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_memtable.c
// Function: loadfile
static void _loadfile(hm_memtable_t *v, const char *filename, int op){
	char buffer[BUFFER_SIZE];

	FILE *f = fopen(filename, "r");

	unsigned int i = 0;
	char *key;
	while( (key = fgets(buffer, BUFFER_SIZE, f)) ){
		trim(key);

		switch(op){
		case 0:
			hm_memtable_put(v, hm_pair_create(key, key));
			break;
		case 1:
			hm_memtable_remove(v, key);
			break;
		}

		i++;

		if (i % ( PROCESS_STEP ) == 0){
			printf("Processed %10u records, %10zu bytes...\n", i, hm_memtable_sizeof(v) );
		}
	}

	fclose(f);
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x440(%rsp)
movq %rsi, 0x438(%rsp)
movl %edx, 0x434(%rsp)
movq 0x438(%rsp), %rdi
leaq 0x1cf7(%rip), %rsi      # 0x3064
callq 0x10b0
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1080
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1451
movq 0x18(%rsp), %rdi
callq 0x14f0
movl 0x434(%rsp), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x13c8
jmp 0x13bd
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x13f3
jmp 0x1405
movq 0x440(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1590
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2570
jmp 0x1405
movq 0x440(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x25d0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0x144c
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x440(%rsp), %rdi
callq 0x2610
movl 0x4(%rsp), %esi
movq %rax, %rdx
leaq 0x1c21(%rip), %rdi      # 0x3066
movb $0x0, %al
callq 0x1060
jmp 0x137f
movq 0x28(%rsp), %rdi
callq 0x1040
addq $0x448, %rsp            # imm = 0x448
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_memtable.c
// Function: findkey
static void _findkey(hm_memtable_t *v, const char *findkey){
	const hm_pair_t *pair = hm_memtable_get(v, findkey);

	if (pair == NULL){
		printf("Key %s not found\n", findkey);
	}else{
		printf("Key %s found\n", findkey);

		printf("---begin---\n");
		hm_pair_printf(pair);
		printf("----end----\n");
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x25a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x14ad
movq 0x8(%rsp), %rsi
leaq 0x1bea(%rip), %rdi      # 0x308e
movb $0x0, %al
callq 0x1060
jmp 0x14e5
movq 0x8(%rsp), %rsi
leaq 0x1be7(%rip), %rdi      # 0x30a0
movb $0x0, %al
callq 0x1060
leaq 0x1be7(%rip), %rdi      # 0x30ae
movb $0x0, %al
callq 0x1060
movq (%rsp), %rdi
callq 0x1a50
leaq 0x1bdd(%rip), %rdi      # 0x30bb
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_memtable.c
// Function: trim
static char *trim(char *s){
	char *end = s + strlen(s) - 1;
	while(end > s && isspace((unsigned char) *end))
		end--;

	*(end + 1) = 0;

	return s;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1050
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0xf(%rsp)
jbe 0x1559
callq 0x1110
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1563
jmp 0x1573
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1521
movq 0x18(%rsp), %rax
movb $0x0, 0x1(%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: place
void place(pool_t *pool, int fd) {

    pthread_mutex_lock(&mtx);

    while (pool->count >= POOL_SIZE){
        pthread_cond_wait(&cond_nonfull, &mtx);
    }

    pool->end = (pool->end + 1) % POOL_SIZE;
    pool->fd[pool->end] = fd;
    pool->count++;

    pthread_mutex_unlock(&mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x3a82(%rip), %rdi      # 0x51a8
callq 0x12a0
movq -0x8(%rbp), %rax
cmpl $0x6, 0x20(%rax)
jl 0x174a
leaq 0x3aec(%rip), %rdi      # 0x5228
leaq 0x3a65(%rip), %rsi      # 0x51a8
callq 0x1080
jmp 0x172b
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x1, %eax
movl $0x6, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movl %edx, 0x1c(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
leaq 0x3a1f(%rip), %rdi      # 0x51a8
callq 0x1180
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: obtain
int obtain(pool_t *pool) {
    int fd = 0;

    pthread_mutex_lock(&mtx);

    while (pool->count <= 0){
        pthread_cond_wait(&cond_nonempty, &mtx);
    }
    fd = pool->fd[pool->start];
    pool->start = (pool->start + 1) % POOL_SIZE;
    pool->count--;
    pthread_mutex_unlock(&mtx);

    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x39ee(%rip), %rdi      # 0x51a8
callq 0x12a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jg 0x17de
leaq 0x3a28(%rip), %rdi      # 0x51f8
leaq 0x39d1(%rip), %rsi      # 0x51a8
callq 0x1080
jmp 0x17bf
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
movl $0x6, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movl %edx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
leaq 0x398b(%rip), %rdi      # 0x51a8
callq 0x1180
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: producer
void *producer(void *ptr) {
    struct sockaddr_in myaddr;
    int lsock, csock, serving_port;

    serving_port = *((int *) ptr);
    time (&start);

    if((lsock = socket( AF_INET, SOCK_STREAM, 0)) < 0)
        perror_exit("socket");

    myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    myaddr.sin_port = htons(serving_port);
    myaddr.sin_family = AF_INET;

    // Resolve address already in use
    if (setsockopt(lsock, SOL_SOCKET, SO_REUSEADDR, &myaddr, sizeof(myaddr)) == -1) {
        perror("setsockopt");
        exit(1);
    }

    if(bind(lsock, (struct sockaddr *)&myaddr, sizeof(myaddr)))
        perror_exit("bind");

    if(listen(lsock, 5) != 0)
        perror_exit("listen");

    printf("Server is ready. Awaiting client connections on port %d\n", serving_port);
    while(1){
        if((csock = accept(lsock, NULL, NULL)) < 0)
            perror_exit("accept");

        place(&pool, csock);
        pthread_cond_signal(&cond_nonempty);
    }
    close(csock);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq 0x3a14(%rip), %rdi      # 0x5260
callq 0x1160
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x12b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x1876
leaq 0x18ef(%rip), %rdi      # 0x3160
callq 0x1960
xorl %edi, %edi
callq 0x10e0
movl %eax, -0x14(%rbp)
movl -0x24(%rbp), %eax
movzwl %ax, %edi
callq 0x10a0
movw %ax, -0x16(%rbp)
movw $0x2, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x18(%rbp), %rcx
movl $0x10, %r8d
callq 0x1060
cmpl $-0x1, %eax
jne 0x18cc
leaq 0x18aa(%rip), %rdi      # 0x3167
callq 0x1200
movl $0x1, %edi
callq 0x1270
movl -0x1c(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x11b0
cmpl $0x0, %eax
je 0x18ee
leaq 0x1889(%rip), %rdi      # 0x3172
callq 0x1960
movl -0x1c(%rbp), %edi
movl $0x5, %esi
callq 0x11a0
cmpl $0x0, %eax
je 0x190c
leaq 0x1870(%rip), %rdi      # 0x3177
callq 0x1960
movl -0x24(%rbp), %esi
leaq 0x1868(%rip), %rdi      # 0x317e
movb $0x0, %al
callq 0x10b0
movl -0x1c(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1220
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0x1940
leaq 0x187c(%rip), %rdi      # 0x31b7
callq 0x1960
movl -0x20(%rbp), %esi
leaq 0x3836(%rip), %rdi      # 0x5180
callq 0x1710
leaq 0x38a2(%rip), %rdi      # 0x51f8
callq 0x1120
jmp 0x191d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: fileExists
int fileExists(char *filename) {
    struct stat buffer;
//    printf("Searching for file\n");

    if(stat(filename, &buffer) != 0)
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1150
cmpl $0x0, %eax
je 0x1dad
movl $0x1, -0x4(%rbp)
jmp 0x1db4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: getFormattedTime
char *getFormattedTime(void) {
    time_t rawtime;
    struct tm* timeinfo;

    time(&rawtime);
    timeinfo = localtime(&rawtime);

    static char timeStamp[200];
    strftime(timeStamp, sizeof(timeStamp), "%a, %d %b %Y %H:%M:%S GMT", timeinfo);

    return timeStamp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
callq 0x1160
leaq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x3487(%rip), %rdi      # 0x5270
movl $0xc8, %esi
leaq 0x1703(%rip), %rdx      # 0x34f8
callq 0x11d0
leaq 0x346f(%rip), %rax      # 0x5270
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: hasPermissions
int hasPermissions(char *filename) {
    struct stat buffer;
//    printf("Checking file permissions\n");

    if(stat(filename, &buffer) != 0)
        perror_exit("stat");

    mode_t bits = buffer.st_mode;
    if(bits & S_IRUSR){
        // User doesn't have read privileges
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1150
cmpl $0x0, %eax
je 0x1e40
leaq 0x16b8(%rip), %rdi      # 0x34f3
callq 0x1960
movl -0x88(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x1e63
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: getFilesize
int getFilesize(char *filename) {
    struct stat buffer;

    if(stat(filename, &buffer) != 0) {
        return 0;
    }
    return (int) buffer.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1150
cmpl $0x0, %eax
je 0x1e9d
movl $0x0, -0x4(%rbp)
jmp 0x1ea4
movq -0x70(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: customRead
int customRead(int fd, char *payload, int remaining){
    int received = 0, b = 0;

    while (remaining > 0){
        b = read(fd, payload + received, remaining);    // Advance pointer by bytes read
        if(b < 0)
            perror_exit("customRead");
        received += b;
        remaining -= b;
    }

    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1f18
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x1110
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1f02
leaq 0x1615(%rip), %rdi      # 0x3512
callq 0x1960
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ed0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: customWrite
int customWrite(int fd, char *payload, int remaining) {
    int sent = 0, b = 0;

    while (remaining > 0){
        b = write(fd, payload + sent, remaining);       // Advance pointer by sent bytes
        if(b < 0)
            perror_exit("customWrite");
        sent += b;
        remaining -= b;
    }

    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1f98
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x1070
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1f82
leaq 0x15a0(%rip), %rdi      # 0x351d
callq 0x1960
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f50
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/functions.c
// Function: getRunTime
char *getRunTime(char *runTime, time_t start){
    int min, sec, hr, n, ms;
    time_t end;
    double dif;
    time (&end);
    dif = difftime (end,start);
    n = floor(dif);

    if(dif>3600){                               // If the server has been running for over an hour
        min = n/60;
        sec = n%60;
        hr = min/60;
        min = min%60;
        ms = sec%60;
        sprintf(runTime, "%.2d:%.2d:%.2d.%.2d", hr, min, sec, ms);
        return runTime;
    }
    else{                                       // If the server has been running for under an hour
        min = n/60;
        sec = n%60;
        ms = sec%60;
        sprintf(runTime, "%.2d:%.2d.%.2d", min, sec, ms);
        return runTime;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1160
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x1230
cvttsd2si %xmm0, %eax
movl %eax, -0x28(%rbp)
movsd -0x40(%rbp), %xmm0
movsd 0xe3f(%rip), %xmm1      # 0x3158
ucomisd %xmm1, %xmm0
jbe 0x238f
movl -0x28(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
movl -0x20(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x2c(%rbp), %r9d
leaq 0x11ab(%rip), %rsi      # 0x3529
movb $0x0, %al
callq 0x1260
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23dd
movl -0x28(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x2c(%rbp), %r8d
leaq 0x1160(%rip), %rsi      # 0x352e
movb $0x0, %al
callq 0x1260
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: MaterialDraw
int MaterialDraw(const S_BOARD *pos) {
        if (!pos->pceNum[wR] && !pos->pceNum[bR] && !pos->pceNum[wQ] && !pos->pceNum[bQ]) {
      if (!pos->pceNum[bB] && !pos->pceNum[wB]) {
          if (pos->pceNum[wN] < 3 && pos->pceNum[bN] < 3) {  return TRUE; }
      } else if (!pos->pceNum[wN] && !pos->pceNum[bN]) {
         if (abs(pos->pceNum[wB] - pos->pceNum[bB]) < 2) { return TRUE; }
      } else if ((pos->pceNum[wN] < 3 && !pos->pceNum[wB]) || (pos->pceNum[wB] == 1 && !pos->pceNum[wN])) {
        if ((pos->pceNum[bN] < 3 && !pos->pceNum[bB]) || (pos->pceNum[bB] == 1 && !pos->pceNum[bN]))  { return TRUE; }
      }
    }
    return FALSE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x238(%rax)
jne 0x1446
movq -0x10(%rsp), %rax
cmpl $0x0, 0x250(%rax)
jne 0x1446
movq -0x10(%rsp), %rax
cmpl $0x0, 0x23c(%rax)
jne 0x1446
movq -0x10(%rsp), %rax
cmpl $0x0, 0x254(%rax)
jne 0x1446
movq -0x10(%rsp), %rax
cmpl $0x0, 0x24c(%rax)
jne 0x1377
movq -0x10(%rsp), %rax
cmpl $0x0, 0x234(%rax)
jne 0x1377
movq -0x10(%rsp), %rax
cmpl $0x3, 0x230(%rax)
jge 0x1372
movq -0x10(%rsp), %rax
cmpl $0x3, 0x248(%rax)
jge 0x1372
movl $0x1, -0x4(%rsp)
jmp 0x144e
jmp 0x1444
movq -0x10(%rsp), %rax
cmpl $0x0, 0x230(%rax)
jne 0x13c4
movq -0x10(%rsp), %rax
cmpl $0x0, 0x248(%rax)
jne 0x13c4
movq -0x10(%rsp), %rax
movl 0x234(%rax), %eax
movq -0x10(%rsp), %rcx
subl 0x24c(%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x2, %eax
jge 0x13c2
movl $0x1, -0x4(%rsp)
jmp 0x144e
jmp 0x1442
movq -0x10(%rsp), %rax
cmpl $0x3, 0x230(%rax)
jge 0x13e0
movq -0x10(%rsp), %rax
cmpl $0x0, 0x234(%rax)
je 0x13fc
movq -0x10(%rsp), %rax
cmpl $0x1, 0x234(%rax)
jne 0x1440
movq -0x10(%rsp), %rax
cmpl $0x0, 0x230(%rax)
jne 0x1440
movq -0x10(%rsp), %rax
cmpl $0x3, 0x248(%rax)
jge 0x1418
movq -0x10(%rsp), %rax
cmpl $0x0, 0x24c(%rax)
je 0x1434
movq -0x10(%rsp), %rax
cmpl $0x1, 0x24c(%rax)
jne 0x143e
movq -0x10(%rsp), %rax
cmpl $0x0, 0x248(%rax)
jne 0x143e
movl $0x1, -0x4(%rsp)
jmp 0x144e
jmp 0x1440
jmp 0x1442
jmp 0x1444
jmp 0x1446
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: PrintBitBoard
void PrintBitBoard(U64 bb) {

    U64 shiftMe = 1ULL;
    
    int rank = 0;
    int file = 0;
    int sq = 0;
    int sq64 = 0;
    
    printf("\n");
    for(rank = RANK_1; rank <= RANK_8; ++rank) {
        for(file = FILE_A; file <= FILE_H; ++file) {
            sq = FR2SQ(file,rank);    // 120 based        
            sq64 = SQ64(sq); // 64 based
            
            if((shiftMe << sq64) & bb)
                printf("X");
            else
                printf("-");
                
        }
        printf("\n");
    }  
    printf("\n\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
leaq 0xa740(%rip), %rdi      # 0xbbd9
movb $0x0, %al
callq 0x1060
movl $0x0, 0x14(%rsp)
cmpl $0x7, 0x14(%rsp)
jg 0x1549
movl $0x0, 0x10(%rsp)
cmpl $0x7, 0x10(%rsp)
jg 0x152b
movl 0x10(%rsp), %eax
addl $0x15, %eax
imull $0xa, 0x14(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0xe3e0(%rip), %rax      # 0xf8c0
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
shlq %cl, %rax
andq 0x20(%rsp), %rax
cmpq $0x0, %rax
je 0x150e
leaq 0xa6c3(%rip), %rdi      # 0xbbc8
movb $0x0, %al
callq 0x1060
jmp 0x151c
leaq 0xa6b5(%rip), %rdi      # 0xbbca
movb $0x0, %al
callq 0x1060
jmp 0x151e
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x14bb
leaq 0xa6a7(%rip), %rdi      # 0xbbd9
movb $0x0, %al
callq 0x1060
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14a8
leaq 0xa688(%rip), %rdi      # 0xbbd8
movb $0x0, %al
callq 0x1060
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: main
int main()
{
    Init();    
    setbuf(stdin, NULL);
        setbuf(stdout, NULL);
    line=calloc(INPUTBUFFER, sizeof(char));    
        InitHashTable(pos->HashTable);

//loops
    while(1)
    {
        fgets(line, INPUTBUFFER, stdin);
        if(strncmp(line, "uci", 3)==0){
            printf("id name %s\n",NAME);
            printf("id author Kong\n");
            printf("uciok\n");
            Uci_Loop();
            continue;

        }
        if(strncmp(line, "console",7)==0)
        {
            Console_Loop();
            continue;
        }
        if(strncmp(line, "q", 1)==0)
        {    
            break;

        }
    }
    return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
callq 0x1c00
movq 0xd54b(%rip), %rax      # 0xefe0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0xd530(%rip), %rax      # 0xefd8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movl $0xa00, %edi            # imm = 0xA00
movl $0x1, %esi
callq 0x10a0
movq %rax, 0xe1b6(%rip)      # 0xfc80
leaq 0xe1bf(%rip), %rdi      # 0xfc90
addq $0xc478, %rdi           # imm = 0xC478
callq 0x1ba0
movq 0xe19c(%rip), %rdi      # 0xfc80
movq 0xd4f5(%rip), %rax      # 0xefe0
movq (%rax), %rdx
movl $0xa00, %esi            # imm = 0xA00
callq 0x1090
movq 0xe181(%rip), %rdi      # 0xfc80
leaq 0xa114(%rip), %rsi      # 0xbc1a
movl $0x3, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x1b4d
leaq 0xa102(%rip), %rdi      # 0xbc1e
leaq 0xa107(%rip), %rsi      # 0xbc2a
movb $0x0, %al
callq 0x1060
leaq 0xa105(%rip), %rdi      # 0xbc36
movb $0x0, %al
callq 0x1060
leaq 0xa107(%rip), %rdi      # 0xbc46
movb $0x0, %al
callq 0x1060
callq 0x2ff0
jmp 0x1add
movq 0xe12c(%rip), %rdi      # 0xfc80
leaq 0xa0f2(%rip), %rsi      # 0xbc4d
movl $0x7, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x1b74
callq 0x8de0
jmp 0x1add
movq 0xe105(%rip), %rdi      # 0xfc80
leaq 0xa0d3(%rip), %rsi      # 0xbc55
movl $0x1, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x1b93
jmp 0x1b98
jmp 0x1add
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: InitHashTable
static
void InitHashTable(S_HASHTABLE *table) {  
 
    table->numEntries = HashSize / sizeof(S_HASHENTRY);
    table->numEntries -= 2;
    if(table->pTable != NULL) free(table->pTable);
    table->pTable = (S_HASHENTRY *) malloc(table->numEntries * sizeof(S_HASHENTRY));
    ClearHashTable(table);
    
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x6aaaaa, 0x8(%rax)    # imm = 0x6AAAAA
movq (%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x1bd3
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movslq 0x8(%rax), %rax
imulq $0x18, %rax, %rdi
callq 0x10d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rdi
callq 0x2f60
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: Init
static
void Init() {
    InitSq120To64();    
    InitBitMasks();
    InitHashKeys();
    InitFilesRanksBrd();
    InitMvvLva();
    InitEvalMasks();
}

// Assembly:
pushq %rax
callq 0x1c30
callq 0x1d40
callq 0x1e00
callq 0x2020
callq 0x2100
callq 0x2190
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: InitSq120To64
static void InitSq120To64() {

    int index = 0;
    int file = FILE_A;
    int rank = RANK_1;
    int sq = A1;
    int sq64 = 0;
    for(index = 0; index < BRD_SQ_NUM; ++index) {
        Sq120ToSq64[index] = 65;
    }
    
    for(index = 0; index < 64; ++index) {
        Sq64ToSq120[index] = 120;
    }
    
    for(rank = RANK_1; rank <= RANK_8; ++rank) {
        for(file = FILE_A; file <= FILE_H; ++file) {
            sq = FR2SQ(file,rank);
            Sq64ToSq120[sq64] = sq;
            Sq120ToSq64[sq] = sq64;
            sq64++;
        }
    }
}

// Assembly:
movl $0x0, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x15, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x4(%rsp)
cmpl $0x78, -0x4(%rsp)
jge 0x1c87
movslq -0x4(%rsp), %rcx
leaq 0xdc4d(%rip), %rax      # 0xf8c0
movl $0x41, (%rax,%rcx,4)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c60
movl $0x0, -0x4(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x1cb6
movslq -0x4(%rsp), %rcx
leaq 0x2608e(%rip), %rax     # 0x27d30
movl $0x78, (%rax,%rcx,4)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c8f
movl $0x0, -0xc(%rsp)
cmpl $0x7, -0xc(%rsp)
jg 0x1d33
movl $0x0, -0x8(%rsp)
cmpl $0x7, -0x8(%rsp)
jg 0x1d24
movl -0x8(%rsp), %eax
addl $0x15, %eax
imull $0xa, -0xc(%rsp), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %edx
movslq -0x14(%rsp), %rcx
leaq 0x2603a(%rip), %rax     # 0x27d30
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %edx
movslq -0x10(%rsp), %rcx
leaq 0xdbb7(%rip), %rax      # 0xf8c0
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x1ccd
jmp 0x1d26
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1cbe
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: InitBitMasks
static
void InitBitMasks() {
    int index = 0;
    
    for(index = 0; index < 64; index++) {
        SetMask[index] = 0ULL;
        ClearMask[index] = 0ULL;
    }
    
    for(index = 0; index < 64; index++) {
        SetMask[index] |= (1ULL << index);
        ClearMask[index] = ~SetMask[index];
    }
}

// Assembly:
movl $0x0, -0x4(%rsp)
movl $0x0, -0x4(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x1d8c
movslq -0x4(%rsp), %rcx
leaq 0x25dcd(%rip), %rax     # 0x27b30
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rsp), %rcx
leaq 0x25bb9(%rip), %rax     # 0x27930
movq $0x0, (%rax,%rcx,8)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1d50
movl $0x0, -0x4(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x1df5
movl -0x4(%rsp), %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movslq -0x4(%rsp), %rcx
leaq 0x25d7b(%rip), %rax     # 0x27b30
orq (%rax,%rcx,8), %rdx
leaq 0x25d70(%rip), %rax     # 0x27b30
movq %rdx, (%rax,%rcx,8)
movslq -0x4(%rsp), %rcx
leaq 0x25d60(%rip), %rax     # 0x27b30
movq (%rax,%rcx,8), %rdx
xorq $-0x1, %rdx
movslq -0x4(%rsp), %rcx
leaq 0x25b4c(%rip), %rax     # 0x27930
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1d94
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: InitHashKeys
static
void InitHashKeys() {
    
    int index = 0;
    int index2 = 0;
    for(index = 0; index < 13; ++index) {
        for(index2 = 0; index2 < 120; ++index2) {
            PieceKeys[index][index2] = RAND_64;
        }
    }
    SideKey = RAND_64;
    for(index = 0; index < 16; ++index) {
        CastleKeys[index] = RAND_64;
    }

}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movl $0x0, 0x60(%rsp)
movl $0x0, 0x64(%rsp)
cmpl $0xd, 0x64(%rsp)
jge 0x1eef
movl $0x0, 0x60(%rsp)
cmpl $0x78, 0x60(%rsp)
jge 0x1edd
callq 0x1110
cltq
movq %rax, 0x40(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x40(%rsp), %rax
movslq %ecx, %rcx
shlq $0xf, %rcx
orq %rcx, %rax
movq %rax, 0x48(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x48(%rsp), %rax
movslq %ecx, %rcx
shlq $0x1e, %rcx
orq %rcx, %rax
movq %rax, 0x50(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x50(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2d, %rcx
orq %rcx, %rax
movq %rax, 0x58(%rsp)
callq 0x1110
movq 0x58(%rsp), %rdx
cltq
andq $0xf, %rax
shlq $0x3c, %rax
orq %rax, %rdx
movslq 0x64(%rsp), %rcx
leaq 0x261d6(%rip), %rax     # 0x28090
imulq $0x3c0, %rcx, %rcx      # imm = 0x3C0
addq %rcx, %rax
movslq 0x60(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x1e2f
jmp 0x1edf
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x1e1c
callq 0x1110
cltq
movq %rax, 0x20(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x20(%rsp), %rax
movslq %ecx, %rcx
shlq $0xf, %rcx
orq %rcx, %rax
movq %rax, 0x28(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x28(%rsp), %rax
movslq %ecx, %rcx
shlq $0x1e, %rcx
orq %rcx, %rax
movq %rax, 0x30(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x30(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2d, %rcx
orq %rcx, %rax
movq %rax, 0x38(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x38(%rsp), %rax
movslq %ecx, %rcx
andq $0xf, %rcx
shlq $0x3c, %rcx
orq %rcx, %rax
movq %rax, 0x291e3(%rip)     # 0x2b150
movl $0x0, 0x64(%rsp)
cmpl $0x10, 0x64(%rsp)
jge 0x2012
callq 0x1110
cltq
movq %rax, (%rsp)
callq 0x1110
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0xf, %rcx
orq %rcx, %rax
movq %rax, 0x8(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x1e, %rcx
orq %rcx, %rax
movq %rax, 0x10(%rsp)
callq 0x1110
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2d, %rcx
orq %rcx, %rax
movq %rax, 0x18(%rsp)
callq 0x1110
movq 0x18(%rsp), %rdx
cltq
andq $0xf, %rax
shlq $0x3c, %rax
orq %rax, %rdx
movslq 0x64(%rsp), %rcx
leaq 0x26012(%rip), %rax     # 0x28010
movq %rdx, (%rax,%rcx,8)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x1f75
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: InitFilesRanksBrd
static
void InitFilesRanksBrd() {
    
    int index = 0;
    int file = FILE_A;
    int rank = RANK_1;
    int sq = A1;
    int sq64 = 0;
    
    for(index = 0; index < BRD_SQ_NUM; ++index){
        FilesBrd[index] = OFFBOARD;
        RanksBrd[index] = OFFBOARD;
    }
    
    for(rank = RANK_1; rank <= RANK_8; ++rank) {
        for(file = FILE_A; file <= FILE_H; ++file) {
            sq = FR2SQ(file,rank);
            FilesBrd[sq] = file;
            RanksBrd[sq] = rank;
        }
    }
}

// Assembly:
movl $0x0, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x15, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x4(%rsp)
cmpl $0x78, -0x4(%rsp)
jge 0x208a
movslq -0x4(%rsp), %rcx
leaq 0xda3d(%rip), %rax      # 0xfaa0
movl $0x64, (%rax,%rcx,4)
movslq -0x4(%rsp), %rcx
leaq 0x25dba(%rip), %rax     # 0x27e30
movl $0x64, (%rax,%rcx,4)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2050
movl $0x0, -0xc(%rsp)
cmpl $0x7, -0xc(%rsp)
jg 0x20fc
movl $0x0, -0x8(%rsp)
cmpl $0x7, -0x8(%rsp)
jg 0x20ed
movl -0x8(%rsp), %eax
addl $0x15, %eax
imull $0xa, -0xc(%rsp), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rsp)
movl -0x8(%rsp), %edx
movslq -0x10(%rsp), %rcx
leaq 0xd9d6(%rip), %rax      # 0xfaa0
movl %edx, (%rax,%rcx,4)
movl -0xc(%rsp), %edx
movslq -0x10(%rsp), %rcx
leaq 0x25d53(%rip), %rax     # 0x27e30
movl %edx, (%rax,%rcx,4)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x20a1
jmp 0x20ef
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x2092
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: InitMvvLva
static
int InitMvvLva() {
    int Attacker;
    int Victim;
    for(Attacker = wP; Attacker <= bK; ++Attacker) {
        for(Victim = wP; Victim <= bK; ++Victim) {
            MvvLvaScores[Victim][Attacker] = VictimScore[Victim] + 6 - ( VictimScore[Attacker] / 100);
        }
    }        
}

// Assembly:
movl $0x1, -0x8(%rsp)
cmpl $0xc, -0x8(%rsp)
jg 0x2188
movl $0x1, -0xc(%rsp)
cmpl $0xc, -0xc(%rsp)
jg 0x2179
movslq -0xc(%rsp), %rcx
leaq 0x97c6(%rip), %rax      # 0xb8f0
movl (%rax,%rcx,4), %eax
addl $0x6, %eax
movl %eax, -0x10(%rsp)
movslq -0x8(%rsp), %rcx
leaq 0x97b0(%rip), %rax      # 0xb8f0
movl (%rax,%rcx,4), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl -0x10(%rsp), %edx
subl %eax, %edx
movslq -0xc(%rsp), %rcx
leaq 0x29043(%rip), %rax     # 0x2b1a0
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x2117
jmp 0x217b
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x2108
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: ClearHashTable
static void ClearHashTable(S_HASHTABLE *table) {
    S_HASHENTRY *tableEntry;
 
    for (tableEntry = table->pTable; tableEntry < table->pTable + table->numEntries; tableEntry++)
    {
        tableEntry->posKey = 0ULL;
        tableEntry->move = NOMOVE;
        tableEntry->depth = 0;
        tableEntry->score = 0;
        tableEntry->flags = 0;
     }
     table->newWrite=0;
 }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
movq -0x8(%rsp), %rdx
movslq 0x8(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x2fe0
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rsp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rsp)
jmp 0x2f72
movq -0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: Uci_Loop
static
void Uci_Loop() {
    
    while (TRUE) {
        memset(&line[0], 0, sizeof(line));
        if (!fgets(line, INPUTBUFFER, stdin))
        continue;

        if (line[0] == '\n')
        continue;

        if (!strncmp(line, "isready", 7)) {
            printf("readyok\n");
            continue;
        } else if (!strncmp(line, "position", 8)) {
            ParsePosition(line, pos);
        } else if (!strncmp(line, "ucinewgame", 10)) {
            ParsePosition("position startpos\n", pos);
        } else if (!strncmp(line, "go", 2)) {
            ParseGo(line, info, pos);
        } else if (!strncmp(line, "quit", 4)) {
            break;
        }
    }
    free(pos->HashTable->pTable);
}

// Assembly:
pushq %rax
jmp 0x2ff3
movq 0xcc86(%rip), %rdi      # 0xfc80
xorl %esi, %esi
movl $0x8, %edx
callq 0x1080
movq 0xcc73(%rip), %rdi      # 0xfc80
movq 0xbfcc(%rip), %rax      # 0xefe0
movq (%rax), %rdx
movl $0xa00, %esi            # imm = 0xA00
callq 0x1090
cmpq $0x0, %rax
jne 0x3029
jmp 0x2ff3
movq 0xcc50(%rip), %rax      # 0xfc80
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x303a
jmp 0x2ff3
movq 0xcc3f(%rip), %rdi      # 0xfc80
leaq 0x8c0f(%rip), %rsi      # 0xbc57
movl $0x7, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x3067
leaq 0x8c01(%rip), %rdi      # 0xbc5f
movb $0x0, %al
callq 0x1060
jmp 0x2ff3
movq 0xcc12(%rip), %rdi      # 0xfc80
leaq 0x8bf3(%rip), %rsi      # 0xbc68
movl $0x8, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x309c
movq 0xcbf5(%rip), %rdi      # 0xfc80
leaq 0xcbfe(%rip), %rsi      # 0xfc90
callq 0x3150
jmp 0x312c
movq 0xcbdd(%rip), %rdi      # 0xfc80
leaq 0x8bc7(%rip), %rsi      # 0xbc71
movl $0xa, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x30ce
leaq 0x8bbc(%rip), %rdi      # 0xbc7c
leaq 0xcbc9(%rip), %rsi      # 0xfc90
callq 0x3150
jmp 0x312a
movq 0xcbab(%rip), %rdi      # 0xfc80
leaq 0x8c35(%rip), %rsi      # 0xbd11
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x3107
movq 0xcb8e(%rip), %rdi      # 0xfc80
leaq 0x28067(%rip), %rsi     # 0x2b160
leaq 0xcb90(%rip), %rdx      # 0xfc90
callq 0x32d0
jmp 0x3128
movq 0xcb72(%rip), %rdi      # 0xfc80
leaq 0x8b7a(%rip), %rsi      # 0xbc8f
movl $0x4, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x3126
jmp 0x3133
jmp 0x3128
jmp 0x312a
jmp 0x312c
jmp 0x312e
jmp 0x2ff3
movq 0x18fce(%rip), %rdi     # 0x1c108
callq 0x1030
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: ParsePosition
static
void ParsePosition(char* lineIn, S_BOARD *pos) {
    
    lineIn += 9;
    char *ptrChar = lineIn;
    
    if(strncmp(lineIn, "startpos", 8) == 0){
        ParseFen(START_FEN, pos);
    } else {
        ptrChar = strstr(lineIn, "fen");
        if(ptrChar == NULL) {
            ParseFen(START_FEN, pos);
        } else {
            ptrChar+=4;
            ParseFen(ptrChar, pos);
        }
    }
    
    ptrChar = strstr(lineIn, "moves");
    int move;
    
    if(ptrChar != NULL) {
        ptrChar += 6;
        while(*ptrChar) {
              move = ParseMove(ptrChar,pos);
              if(move == NOMOVE) break;
              MakeMove(pos, move);
              pos->ply=0;
              while(*ptrChar && *ptrChar!= ' ') ptrChar++;
              ptrChar++;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x9, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8b12(%rip), %rsi      # 0xbc94
movl $0x8, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x31a4
movq 0x18(%rsp), %rsi
leaq 0x8b00(%rip), %rdi      # 0xbc9d
callq 0x3580
jmp 0x31f4
movq 0x20(%rsp), %rdi
leaq 0x8b26(%rip), %rsi      # 0xbcd6
callq 0x1100
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x31d5
movq 0x18(%rsp), %rsi
leaq 0x8acf(%rip), %rdi      # 0xbc9d
callq 0x3580
jmp 0x31f2
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3580
jmp 0x31f4
movq 0x20(%rsp), %rdi
leaq 0x8cdc(%rip), %rsi      # 0xbedc
callq 0x1100
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x32bf
movq 0x10(%rsp), %rax
addq $0x6, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x32bd
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3900
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x324e
jmp 0x32bd
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x3c20
movq 0x18(%rsp), %rax
movl $0x0, 0x20c(%rax)
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xb(%rsp)
je 0x3290
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x329a
jmp 0x32aa
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x326b
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3224
jmp 0x32bf
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: ResetBoard
static
void ResetBoard(S_BOARD *pos) {

    int index = 0;
    
    for(index = 0; index < BRD_SQ_NUM; ++index) {
        pos->pieces[index] = OFFBOARD;
    }
    
    for(index = 0; index < 64; ++index) {
        pos->pieces[SQ120(index)] = EMPTY;
    }
    
    for(index = 0; index < 2; ++index) {
        pos->bigPce[index] = 0;
        pos->material[index] = 0;        
    }
    
    for(index = 0; index < 3; ++index) {
        pos->pawns[index] = 0ULL;
    }
    
    for(index = 0; index < 13; ++index) {
        pos->pceNum[index] = 0;
    }
    
    pos->KingSq[WHITE] = pos->KingSq[BLACK] = NO_SQ;
    
    pos->side = BOTH;
    pos->enPas = NO_SQ;
    pos->fiftyMove = 0;
    
    pos->ply = 0;
    pos->hisPly = 0;
    
    pos->castlePerm = 0;
    
    pos->posKey = 0ULL;
    
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x78, -0xc(%rsp)
jge 0x415a
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl $0x64, (%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x4135
movl $0x0, -0xc(%rsp)
cmpl $0x40, -0xc(%rsp)
jge 0x4192
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rdx
leaq 0x23bb6(%rip), %rcx     # 0x27d30
movslq (%rcx,%rdx,4), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x4162
movl $0x0, -0xc(%rsp)
cmpl $0x2, -0xc(%rsp)
jge 0x41d8
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl $0x0, 0x25c(%rax,%rcx,4)
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl $0x0, 0x264(%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x419a
movl $0x0, -0xc(%rsp)
cmpl $0x3, -0xc(%rsp)
jge 0x420a
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movq $0x0, 0x1e0(%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x41e0
movl $0x0, -0xc(%rsp)
cmpl $0xd, -0xc(%rsp)
jge 0x423b
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl $0x0, 0x228(%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x4212
movq -0x8(%rsp), %rax
movl $0x63, 0x1fc(%rax)
movq -0x8(%rsp), %rax
movl $0x63, 0x1f8(%rax)
movq -0x8(%rsp), %rax
movl $0x2, 0x200(%rax)
movq -0x8(%rsp), %rax
movl $0x63, 0x204(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x208(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x20c(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x210(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x214(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x220(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: GeneratePosKey
static U64 GeneratePosKey(const S_BOARD *pos) {

    int sq = 0;
    U64 finalKey = 0;
    int piece = EMPTY;
    
    // pieces
    for(sq = 0; sq < BRD_SQ_NUM; ++sq) {
        piece = pos->pieces[sq];
        if(piece!=NO_SQ && piece!=EMPTY && piece != OFFBOARD) {
            finalKey ^= PieceKeys[piece][sq];
        }        
    }
    
    if(pos->side == WHITE) {
        finalKey ^= SideKey;
    }
        
    if(pos->enPas != NO_SQ) {
        finalKey ^= PieceKeys[EMPTY][pos->enPas];
    }
    
    finalKey ^= CastleKeys[pos->castlePerm];
    
    return finalKey;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq $0x0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x78, -0xc(%rsp)
jge 0x435b
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rsp)
cmpl $0x63, -0x1c(%rsp)
je 0x434c
cmpl $0x0, -0x1c(%rsp)
je 0x434c
cmpl $0x64, -0x1c(%rsp)
je 0x434c
movslq -0x1c(%rsp), %rcx
leaq 0x23d61(%rip), %rax     # 0x28090
imulq $0x3c0, %rcx, %rcx      # imm = 0x3C0
addq %rcx, %rax
movslq -0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0x434e
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x42f6
movq -0x8(%rsp), %rax
cmpl $0x0, 0x200(%rax)
jne 0x437a
movq 0x26de0(%rip), %rax     # 0x2b150
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x63, 0x204(%rax)
je 0x43a9
movq -0x8(%rsp), %rax
movslq 0x204(%rax), %rcx
leaq 0x23cf5(%rip), %rax     # 0x28090
movq (%rax,%rcx,8), %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movslq 0x214(%rax), %rcx
leaq 0x23c54(%rip), %rax     # 0x28010
movq (%rax,%rcx,8), %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: AddPawnMove
static void AddPawnMove( const S_BOARD *pos, const int from, const int to, S_MOVELIST *list ) {
    int side=pos->side;
    if(RanksBrd[from] == (side?RANK_2:RANK_7)) {
        AddQuietMove(pos, MOVE(from,to,EMPTY,(side?bQ:wQ),0), list);
        AddQuietMove(pos, MOVE(from,to,EMPTY,(side?bR:wR),0), list);
        AddQuietMove(pos, MOVE(from,to,EMPTY,(side?bB:wB),0), list);
        AddQuietMove(pos, MOVE(from,to,EMPTY,(side?bN:wN),0), list);
    } else {
        AddQuietMove(pos, MOVE(from,to,EMPTY,EMPTY,0), list);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x200(%rax), %eax
movl %eax, 0xc(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x22daf(%rip), %rax     # 0x27e30
movl (%rax,%rcx,4), %eax
movl 0xc(%rsp), %esi
movl $0x6, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jne 0x518e
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
orl $0x0, %esi
movl 0xc(%rsp), %edx
movl $0x5, %eax
movl $0xb, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x10(%rsp), %rdx
callq 0x51c0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
orl $0x0, %esi
movl 0xc(%rsp), %edx
movl $0x4, %eax
movl $0xa, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x10(%rsp), %rdx
callq 0x51c0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
orl $0x0, %esi
movl 0xc(%rsp), %edx
movl $0x3, %eax
movl $0x9, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x10(%rsp), %rdx
callq 0x51c0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
orl $0x0, %esi
movl 0xc(%rsp), %edx
movl $0x2, %eax
movl $0x8, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x10(%rsp), %rdx
callq 0x51c0
jmp 0x51b3
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
orl $0x0, %esi
orl $0x0, %esi
orl $0x0, %esi
movq 0x10(%rsp), %rdx
callq 0x51c0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: AddQuietMove
static void AddQuietMove( const S_BOARD *pos, int move, S_MOVELIST *list ) {

    list->moves[list->count].move = move;
    
    if(pos->searchKillers[0][pos->ply] == move) {    
        list->moves[list->count].score = 900000;
    } else if(pos->searchKillers[1][pos->ply] == move) {    
        list->moves[list->count].score = 800000;
    } else {    
        list->moves[list->count].score = pos->searchHistory[pos->pieces[FROMSQ(move)]][TOSQ(move)];
    }
    list->count++;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl -0xc(%rsp), %edx
movq -0x18(%rsp), %rax
movq -0x18(%rsp), %rcx
movslq 0x800(%rcx), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movslq 0x20c(%rcx), %rcx
movl 0xde18(%rax,%rcx,4), %eax
cmpl -0xc(%rsp), %eax
jne 0x5222
movq -0x18(%rsp), %rax
movq -0x18(%rsp), %rcx
movslq 0x800(%rcx), %rcx
movl $0xdbba0, 0x4(%rax,%rcx,8) # imm = 0xDBBA0
jmp 0x52aa
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movslq 0x20c(%rcx), %rcx
movl 0xdf18(%rax,%rcx,4), %eax
cmpl -0xc(%rsp), %eax
jne 0x525b
movq -0x18(%rsp), %rax
movq -0x18(%rsp), %rcx
movslq 0x800(%rcx), %rcx
movl $0xc3500, 0x4(%rax,%rcx,8) # imm = 0xC3500
jmp 0x52a8
movq -0x8(%rsp), %rax
addq $0xc5b8, %rax           # imm = 0xC5B8
movq -0x8(%rsp), %rcx
movl -0xc(%rsp), %edx
andl $0x7f, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x1e0, %rcx, %rcx      # imm = 0x1E0
addq %rcx, %rax
movl -0xc(%rsp), %ecx
sarl $0x7, %ecx
andl $0x7f, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rsp), %rax
movq -0x18(%rsp), %rcx
movslq 0x800(%rcx), %rcx
movl %edx, 0x4(%rax,%rcx,8)
jmp 0x52aa
movq -0x18(%rsp), %rax
movl 0x800(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x800(%rax)
retq
nop