LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/thread/thread.c
// Function: tp_unlock
void tp_unlock(thread_pool *tp, int idx) {
    int ret = pthread_mutex_unlock(tp->mutex[idx]);
    if (ret != 0) {
        perror("pthread_mutex_unlock error: " + ret);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1130
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x485a
movslq -0x10(%rbp), %rax
leaq 0xab4(%rip), %rdi       # 0x52fc
addq %rax, %rdi
callq 0x1180
movl $0x1, %edi
callq 0x11b0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/pattern_match/strstr/strstr.c
// Function: rollback
void rollback(int index) {
    // pos[index] = 0;
    // return;
    int     temp = 2;
    boolean end = F;
    while (!end) {
        for (int i = pos[index] - temp, p = 0;; --i, ++p) {
            if (i <= 0) {
                // match
                pos[index] = compare_char(string[i], patterns[index][p]) == 0
                                 ? p + 1
                                 : 0;
                end = T;
                break;
            }
            if (compare_char(string[i], patterns[index][p]) != 0) {
                ++temp;
                break;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x2, -0x8(%rbp)
leaq 0x827(%rip), %rax       # 0x50a0
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4890
jmp 0x496f
movq 0x3919(%rip), %rax      # 0x81b0
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jg 0x4914
movq 0x3900(%rip), %rax      # 0x81b8
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq 0x38fa(%rip), %rax      # 0x81c0
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsbl %dl, %edi
movsbl (%rax,%rcx), %esi
callq 0x2d80
cmpl $0x0, %eax
jne 0x48ee
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x48f5
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x48f5
movl -0x18(%rbp), %edx
movq 0x38b1(%rip), %rax      # 0x81b0
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
leaq 0x78f(%rip), %rax       # 0x509c
movl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x496a
movq 0x389d(%rip), %rax      # 0x81b8
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq 0x3897(%rip), %rax      # 0x81c0
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsbl %dl, %edi
movsbl (%rax,%rcx), %esi
callq 0x2d80
cmpl $0x0, %eax
je 0x4951
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x496a
jmp 0x4953
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x48ab
jmp 0x487e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/pattern_match/strstr/strstr.c
// Function: match
void match(char c, int index) {
    if (compare_char(c, patterns[index][pos[index]++]) == 0) {
        if (compare_char('\0', patterns[index][pos[index]]) == 0) {
            ++count[index];
            rollback(index);
        }
    } else {
        rollback(index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movb -0x1(%rbp), %dl
movq 0x3825(%rip), %rax      # 0x81c0
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x3806(%rip), %rsi      # 0x81b0
movslq -0x8(%rbp), %rdi
movl (%rsi,%rdi,4), %ecx
movl %ecx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
movslq %ecx, %rcx
movsbl %dl, %edi
movsbl (%rax,%rcx), %esi
callq 0x2d80
cmpl $0x0, %eax
jne 0x4a1c
movq 0x37e9(%rip), %rax      # 0x81c0
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x37ca(%rip), %rcx      # 0x81b0
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
xorl %edi, %edi
movsbl (%rax,%rcx), %esi
callq 0x2d80
cmpl $0x0, %eax
jne 0x4a1a
movq 0x37c3(%rip), %rax      # 0x81c8
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %edi
callq 0x4860
jmp 0x4a24
movl -0x8(%rbp), %edi
callq 0x4860
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/pattern_match/strstr/strstr.c
// Function: compare
int compare(void *args, int i, int j) {
    char **args_patterns = (char **)(((void **)args)[0]);
    int *  args_count = (int *)(((void **)args)[1]);

    int res = args_count[j] - args_count[i];
    if (res == 0) {
        res = compare_string(args_patterns[i], args_patterns[j]);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
movslq -0xc(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x4a98
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2db0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/pattern_match/strstr/strstr.c
// Function: swap
void swap(void *args, int i, int j) {
    char **args_patterns = (char **)(((void **)args)[0]);
    int *  args_count = (int *)(((void **)args)[1]);

    char *temp_parrtern = args_patterns[i];
    args_patterns[i] = args_patterns[j];
    args_patterns[j] = temp_parrtern;

    int temp_count = args_count[i];
    args_count[i] = args_count[j];
    args_count[j] = temp_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/sysoff.c
// Function: main
int main(int argc, char *argv[])
{
	int memfd;
	void *mapped_base;

	memfd = open("/dev/mem", O_RDWR | O_SYNC);
	if (memfd == -1) {
		printf("Can't open /dev/mem.\n");
		exit(0);
	}

	// Map memory
	mapped_base = mmap( (void *) MEM0_BASE_ADDRESS, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, memfd, SPI_BASE_ADDRESS);
	if (mapped_base == (void *) -1) {
		printf("Can't map the memory to user space.\n");
		exit(0);
	}

	/* ----------- INSERT CODE BELOW THIS LINE ------------ */

	sys_off_tx(mapped_base);

	/* ----------- INSERT CODE ABOVE THIS LINE ------------ */

	if (munmap(mapped_base, MAP_SIZE) == -1) {
		printf("Can't unmap memory from user space.\n");
		exit(0);
	}
	close(memfd);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1db7(%rip), %rdi      # 0x3004
movl $0x101002, %esi         # imm = 0x101002
movb $0x0, %al
callq 0x10e0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1277
leaq 0x1da4(%rip), %rdi      # 0x300d
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1110
movl -0x14(%rbp), %r8d
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x3, %edx
movl $0x11, %ecx
movl $0x64000000, %r9d       # imm = 0x64000000
callq 0x1070
movq %rax, -0x20(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x20(%rbp)
jne 0x12c0
leaq 0x1d71(%rip), %rdi      # 0x3023
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1110
movq -0x20(%rbp), %rdi
callq 0x1780
movq -0x20(%rbp), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x10d0
cmpl $-0x1, %eax
jne 0x12f1
leaq 0x1d65(%rip), %rdi      # 0x3048
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1110
movl -0x14(%rbp), %edi
callq 0x10b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: spi_header_tx
void spi_header_tx(int rw, int xfr_size, int target, int addr, void *mapped_base, int verbose)
{
	/*          ----------------------------------
	 *          |  31 |   30:19  | 18:16  | 15:0 |
	 *          | r/w | xfr_size | target | addr |
	 *          ----------------------------------
	 * bits  parameter
	 *  1    r/w         0 = read, 1 = write
	 *  12   xfr_size    The number of spi_data_frames following the spi_ctrl_frame =  xfr_size + 1
	 *  3    target      0 = system register map
	 *  16   addr        addr = { bank[3:0], addr[11:0] }
	 */

	int headerval;

	headerval = 0x00000000;
	// [31]: read/write
	rw = (rw & 0x1) << 31;
	// [30:19]: number of spi data frames
	xfr_size = (xfr_size & 0xfff) << 19;
	// [18:16]: target structure
	target = (target & 0x7) << 16;
	// [15:0]: addr of register or table
	addr = addr & 0xffff;
	// combine into headerval
	headerval = headerval | rw | xfr_size | target | addr;

	if (verbose) printf("headerval: %x\n", headerval);

	// write header
	*((unsigned int *) (mapped_base)) = headerval;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
shll $0x1f, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
shll $0x13, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
andl $0x7, %eax
shll $0x10, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0x20(%rbp), %eax
orl -0x4(%rbp), %eax
orl -0x8(%rbp), %eax
orl -0xc(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x138d
movl -0x20(%rbp), %esi
leaq 0x1d3a(%rip), %rdi      # 0x30c0
movb $0x0, %al
callq 0x1090
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: set_sample_rate_tx
void set_sample_rate_tx(double rate, void *mapped_base)
{

	uint64_t val;
	unsigned int val_msb;
	unsigned int val_lsb;

	val = (uint64_t) round(ldexp(rate/160e6,40)); // do rate calc
	val_msb = (val >> 32) & 0xFF; // upper 8 bits
	val_lsb = val & 0xFFFFFFFF; // lower 32 bits
	/*
	   printf("rate: %f\n",rate);
	   printf("val=0x%" PRIX64 "\n", val);
	   printf("MSB: 0x%X\n",val_msb);
	   printf("LSB: 0x%X\n",val_lsb);
	   */

	*((unsigned int *) (mapped_base + (MAP_SIZE - (2<<2)))) = val_lsb; // write rate val LSB to maxaddr - 2
	*((unsigned int *) (mapped_base + (MAP_SIZE - (3<<2)))) = val_msb; // write rate val MSB to maxaddr - 3
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x1cb2(%rip), %xmm1     # 0x3070
divsd %xmm1, %xmm0
movl $0x28, %edi
callq 0x1030
callq 0x1040
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x1c90(%rip), %xmm1     # 0x3078
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movl %eax, -0x1c(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x18(%rbp), %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3ffff8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3ffff4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: set_sig_tx
void set_sig_tx(char *filename, void *mapped_base)
{
	int wave[WAVE_SIZE];
	int N, counter;

	
	read_bin_file(filename, wave, &N);	

	// write array to FIFO memory
	for (counter = 0; counter <= N; counter = counter +1)
	{
		*((unsigned int *) (mapped_base+(counter << 2))) = wave[counter];
	}

	*((unsigned int *) (mapped_base+ (MAP_SIZE - (1<<2)))) = N; // write to maxaddr


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x258020, %rsp         # imm = 0x258020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x258010(%rbp), %rsi
leaq -0x258014(%rbp), %rdx
callq 0x1500
movl $0x0, -0x258018(%rbp)
movl -0x258018(%rbp), %eax
cmpl -0x258014(%rbp), %eax
jg 0x14e4
movslq -0x258018(%rbp), %rax
movl -0x258010(%rbp,%rax,4), %edx
movq -0x10(%rbp), %rax
movl -0x258018(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx)
movl -0x258018(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x258018(%rbp)
jmp 0x14a4
movl -0x258014(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3ffffc(%rax)
addq $0x258020, %rsp         # imm = 0x258020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: read_bin_file
void read_bin_file(char *filename, int *array, int *N)
{
	FILE *fp;
	int c, c1, c2, counter;
	unsigned int c3, c4;
	int Continue;

	system("mount /dev/mmcblk0p1 /mnt");        

	counter = 0;
	fp = fopen(filename, "r");
	if (fp == NULL)
	{
		printf("FILE NOT FOUND\n");
		exit(0);
	}

	Continue = 1;
	while(Continue)
	{

		c1 = fgetc(fp);
		c2 = fgetc(fp);
		c2 = c2 << 8;
		c = c1 + c2;
		c3 = c & (0x0fff);  // bitwise AND 
		c3 = c3 << 16;    // I channel
		c1 = fgetc(fp);
		c2 = fgetc(fp);
		c2 = c2 << 8;
		c  = c1 + c2;
		c4 = c & (0x0fff);  // Q channel
		c4 = c3 + c4;
		array[counter] = c4;
		counter++;

		if (feof(fp))
		{
			//printf("\n\rfeof found\n\r");
			*N = counter-2;
			Continue = 0;
		}
	}
	fclose(fp);
	system("umount /mnt");
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1bb4(%rip), %rdi      # 0x30cf
callq 0x1080
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1da7(%rip), %rsi      # 0x32d9
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1557
leaq 0x1df4(%rip), %rdi      # 0x333d
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1110
movl $0x1, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1621
movq -0x20(%rbp), %rdi
callq 0x10a0
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10a0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10a0
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10a0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
cmpl $0x0, %eax
je 0x161c
movl -0x30(%rbp), %ecx
subl $0x2, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x3c(%rbp)
jmp 0x155e
movq -0x20(%rbp), %rdi
callq 0x1060
leaq 0x1ae4(%rip), %rdi      # 0x3115
callq 0x1080
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: safe_off_tx
void safe_off_tx(void *mapped_base)
{
	int pwr_supp_reg;

	pwr_supp_reg = read_reg_tx(36, mapped_base); // Get supply state
	write_reg_tx(66,0,mapped_base); // Turn off signal

	pwr_supp_reg = pwr_supp_reg | 0x1; // Turn on filter
	write_reg_tx(36,pwr_supp_reg,mapped_base);
	usleep(100000); // 100ms
	//printf("pwr_supp_reg = %d\n", pwr_supp_reg);

	pwr_supp_reg = pwr_supp_reg & 0x7; // Turn off comparator
	write_reg_tx(36,pwr_supp_reg,mapped_base);
	usleep(100000); // 100ms
	//printf("pwr_supp_reg = %d\n", pwr_supp_reg);

	pwr_supp_reg = pwr_supp_reg & 0x5; // Turn off 20V
	write_reg_tx(36,pwr_supp_reg,mapped_base);
	usleep(100000); // 100ms
	//printf("pwr_supp_reg = %d\n", pwr_supp_reg);

	pwr_supp_reg = pwr_supp_reg & 0x1; // Turn off 5V
	write_reg_tx(36,pwr_supp_reg,mapped_base);
	//printf("pwr_supp_reg = %d\n", pwr_supp_reg);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x24, %edi
callq 0x1680
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdx
movl $0x42, %edi
xorl %esi, %esi
callq 0x1640
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
movl $0x24, %edi
callq 0x1640
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x1120
movl -0xc(%rbp), %eax
andl $0x7, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
movl $0x24, %edi
callq 0x1640
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x1120
movl -0xc(%rbp), %eax
andl $0x5, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
movl $0x24, %edi
callq 0x1640
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x1120
movl -0xc(%rbp), %eax
andl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
movl $0x24, %edi
callq 0x1640
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: sys_off_tx
void sys_off_tx(void *mapped_base)
{
	int pwr_supp_reg;
	// Get current state of power supplies (pwr_supp_reg)
	pwr_supp_reg = read_reg_tx(36, mapped_base);
	//printf("pwr_supp_reg = %d\n", pwr_supp_reg);
	if (pwr_supp_reg >= 14)
	{
		printf("Turning OFF system...");
		safe_off_tx(mapped_base);
		write_reg_tx(32,0x1,mapped_base); // CS select bit
		write_reg_tx(33,0x000840,mapped_base); // Page DAC0 for TXEN control update.
		write_reg_tx(33,0x059604,mapped_base); // SPI turn on TXENx feature, but turn DAC0 off.
	
		printf("done.\n");
	}
	else if (pwr_supp_reg == 1)
	{
		printf("System is already off.\n");
	}
	else if (pwr_supp_reg == 0)
	{
		printf("CANNOT CONNECT TO MIRACLE. CHECK FMC CONNECTION,\n");
		printf("MAKE SURE MIRACLE POWER IS ON, AND TRY AGAIN.\n");
	}
	else
	{
		printf("SYSTEM IN UNDEFINED STATE\n");
		printf("SAFELY TURNING OFF...");
		safe_off_tx(mapped_base);
		printf("done.\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x24, %edi
callq 0x1680
movl %eax, -0xc(%rbp)
cmpl $0xe, -0xc(%rbp)
jl 0x1803
leaq 0x1977(%rip), %rdi      # 0x3121
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x16c0
movq -0x8(%rbp), %rdx
movl $0x20, %edi
movl $0x1, %esi
callq 0x1640
movq -0x8(%rbp), %rdx
movl $0x21, %edi
movl $0x840, %esi            # imm = 0x840
callq 0x1640
movq -0x8(%rbp), %rdx
movl $0x21, %edi
movl $0x59604, %esi          # imm = 0x59604
callq 0x1640
leaq 0x193d(%rip), %rdi      # 0x3137
movb $0x0, %al
callq 0x1090
jmp 0x1874
cmpl $0x1, -0xc(%rbp)
jne 0x1819
leaq 0x192e(%rip), %rdi      # 0x313e
movb $0x0, %al
callq 0x1090
jmp 0x1872
cmpl $0x0, -0xc(%rbp)
jne 0x183d
leaq 0x1930(%rip), %rdi      # 0x3156
movb $0x0, %al
callq 0x1090
leaq 0x1954(%rip), %rdi      # 0x3188
movb $0x0, %al
callq 0x1090
jmp 0x1870
leaq 0x1973(%rip), %rdi      # 0x31b7
movb $0x0, %al
callq 0x1090
leaq 0x1980(%rip), %rdi      # 0x31d2
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x16c0
leaq 0x18ce(%rip), %rdi      # 0x3137
movb $0x0, %al
callq 0x1090
jmp 0x1872
jmp 0x1874
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: stat_tx
void stat_tx(void *mapped_base)
{
	int pwr_supp_val, pwr_ctrl_val;
	double f;
	pwr_supp_val = read_reg_tx(36,mapped_base); // get system power state
	pwr_ctrl_val = read_reg_tx(66,mapped_base); // get power level
	f = get_freq_tx();
	if (pwr_supp_val == 1)
	{
		printf("System is OFF.\n");
	}
	else if (pwr_supp_val == 14)
	{
		printf("System is ON.\n"); 
		printf("Power level (0-32767): %d\n", pwr_ctrl_val);
		printf("TX frequency: %.0lf\n", f);
	}
	else if (pwr_supp_val == 0) // cannot connect to interposer
	{
		printf("CANNOT CONNECT TO MIRACLE. CHECK FMC CONNECTION,\n");
		printf("MAKE SURE MIRACLE POWER IS ON, AND TRY AGAIN.\n");
	}
	else // should never get to this, but just in case turn off safely
	{
		printf("SYSTEM IN UNDEFINED STATE\n");
		printf("SAFELY TURNING OFF...");
		safe_off_tx(mapped_base);
		printf("done.\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x24, %edi
callq 0x1680
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movl $0x42, %edi
callq 0x1680
movl %eax, -0x10(%rbp)
callq 0x20d0
movsd %xmm0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x1a51
leaq 0x17e2(%rip), %rdi      # 0x3227
movb $0x0, %al
callq 0x1090
jmp 0x1ae6
cmpl $0xe, -0xc(%rbp)
jne 0x1a8b
leaq 0x17d9(%rip), %rdi      # 0x3237
movb $0x0, %al
callq 0x1090
movl -0x10(%rbp), %esi
leaq 0x17d7(%rip), %rdi      # 0x3246
movb $0x0, %al
callq 0x1090
movsd -0x18(%rbp), %xmm0
leaq 0x17df(%rip), %rdi      # 0x3261
movb $0x1, %al
callq 0x1090
jmp 0x1ae4
cmpl $0x0, -0xc(%rbp)
jne 0x1aaf
leaq 0x16be(%rip), %rdi      # 0x3156
movb $0x0, %al
callq 0x1090
leaq 0x16e2(%rip), %rdi      # 0x3188
movb $0x0, %al
callq 0x1090
jmp 0x1ae2
leaq 0x1701(%rip), %rdi      # 0x31b7
movb $0x0, %al
callq 0x1090
leaq 0x170e(%rip), %rdi      # 0x31d2
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x16c0
leaq 0x165c(%rip), %rdi      # 0x3137
movb $0x0, %al
callq 0x1090
jmp 0x1ae4
jmp 0x1ae6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: ad9173_freq_calc
void ad9173_freq_calc(uint64_t fLO, uint64_t *A, uint64_t *B, uint64_t *X)
{
	uint64_t fDAC, c1, c2, M, N, Y; // need 64-bit computation

	fDAC = (uint64_t) 9.6e9; // needs to match AD9173 DAC frequency
	c1 = gcd(fLO,fDAC); // compute GCD of fLO and fDAC

	/* DDS modulus works using following equation:
	 * fLO/fDAC = M/N
	 *          = (X + A/B)/(2^48)
	 */

	M =  fLO/c1; // compute rational fraction M/N
	N = fDAC/c1;

	*X = (M << 48)/N; // Computer integer X
	Y = (M << 48) - (*X)*N; // Compute remainder y
	c2 = gcd(Y,N);
	*A = Y/c2; // Compute A/B modulus
	*B = N/c2;

	//printf("X=0x%" PRIX64 "\n", *X);
	//printf("A=0x%" PRIX64 "\n", *A);
	//printf("B=0x%" PRIX64 "\n", *B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movabsq $0x23c346000, %rax      # imm = 0x23C346000
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1af0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x30(%rbp)
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x30(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
shlq $0x30, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x48(%rbp)
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
shlq $0x30, %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
imulq -0x48(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1af0
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: ad9173_resync
void ad9173_resync(void *mapped_base)
{
	// Send sysref pulses from HMC7044
	int i;

	unsigned int spi_words_0[] = {
		0x003BF1, // Enable sync logic
		0x003A00, // Set up sync for monitor mode
		0x003A02, // Set up sync for one-shot sync mode
		// Send SYSREF pulse edges here for alignment
	};
	unsigned int spi_words_1[]  = {
		// -------------- Channel Parameters -----------------
		// Channel 3: AD9173 SYSREF
		0x00E65D, // channel enable, SYNC enable, dynamic startup.
		0x00EA11, // Coarse digital delay [4:0], max val = 0x11
		// Channel 13: FPGA SYSREF
		0x014A5D, // channel enable, SYNC enable, dynamic startup. default'014A71'
		0x0001E0, // reseed request
		0x000160, // stop reseed request
	};

	int n_spi_0 = NELEMS(spi_words_0);
	int n_spi_1 = NELEMS(spi_words_1);
	//int n_spi_2 = NELEMS(spi_words_2);

	write_reg_tx(32,0x1,mapped_base); // CS select bit
	// write to register 33
	for (i = 0; i<n_spi_0; i++)
	{
		write_reg_tx(33,spi_words_0[i],mapped_base);
		usleep(2000); // 1000 usec pause
	}

	usleep(10000); // 10 msec pause
	write_reg_tx(32,0x8,mapped_base); // CS select bit
	// write to register 33
	for (i = 0; i<n_spi_1; i++)
	{
		write_reg_tx(33,spi_words_1[i],mapped_base);
		usleep(2000); // 2000 usec pause
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x14dd(%rip), %rax      # 0x3350
movq %rax, -0x18(%rbp)
movl 0x14db(%rip), %eax      # 0x3358
movl %eax, -0x10(%rbp)
movq 0x14d9(%rip), %rax      # 0x3360
movq %rax, -0x30(%rbp)
movq 0x14d6(%rip), %rax      # 0x3368
movq %rax, -0x28(%rbp)
movl 0x14d4(%rip), %eax      # 0x3370
movl %eax, -0x20(%rbp)
movl $0x3, -0x34(%rbp)
movl $0x5, -0x38(%rbp)
movq -0x8(%rbp), %rdx
movl $0x20, %edi
movl $0x1, %esi
callq 0x1640
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x1efa
movslq -0xc(%rbp), %rax
movl -0x18(%rbp,%rax,4), %esi
movq -0x8(%rbp), %rdx
movl $0x21, %edi
callq 0x1640
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x1120
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ec7
movl $0x2710, %edi           # imm = 0x2710
callq 0x1120
movq -0x8(%rbp), %rdx
movl $0x20, %edi
movl $0x8, %esi
callq 0x1640
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x1f51
movslq -0xc(%rbp), %rax
movl -0x30(%rbp,%rax,4), %esi
movq -0x8(%rbp), %rdx
movl $0x21, %edi
callq 0x1640
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x1120
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f1e
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: init_tx
int init_tx(void *mapped_base)
{
	int jesd_phase; // jesd phase readback value
	int done = 0; // done flag
	ad9173_resync(mapped_base); // Sync AD9173 subclass 1
	usleep(100000); //100 msec pause
	write_reg_tx(32,1,mapped_base); // CS to AD9173
	write_reg_tx(33,0x830200,mapped_base); // readback LMFC delay
	jesd_phase = read_reg_tx(34, mapped_base);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e60
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x1120
movq -0x10(%rbp), %rdx
movl $0x20, %edi
movl $0x1, %esi
callq 0x1640
movq -0x10(%rbp), %rdx
movl $0x21, %edi
movl $0x830200, %esi         # imm = 0x830200
callq 0x1640
movq -0x10(%rbp), %rsi
movl $0x22, %edi
callq 0x1680
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: set_pwr_tx
void set_pwr_tx(int pwr_ctrl_reg, void *mapped_base)
{
	// Handle boundaries
	if (pwr_ctrl_reg > 32767) 
	{
		printf("Input is too large.\n\r");
		pwr_ctrl_reg = 32767;
	}
	else if(pwr_ctrl_reg < 0)
	{
		printf("Input is too small.\n\r");
		pwr_ctrl_reg = 0;
	}

	write_reg_tx(66, pwr_ctrl_reg, mapped_base); // set power level
	printf("Power is set to: %d\n", pwr_ctrl_reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x7fff, -0x4(%rbp)     # imm = 0x7FFF
jle 0x1fff
leaq 0x1287(%rip), %rdi      # 0x3276
movb $0x0, %al
callq 0x1090
movl $0x7fff, -0x4(%rbp)     # imm = 0x7FFF
jmp 0x201c
cmpl $0x0, -0x4(%rbp)
jge 0x201a
leaq 0x1280(%rip), %rdi      # 0x328c
movb $0x0, %al
callq 0x1090
movl $0x0, -0x4(%rbp)
jmp 0x201c
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movl $0x42, %edi
callq 0x1640
movl -0x4(%rbp), %esi
leaq 0x126b(%rip), %rdi      # 0x32a2
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: on_tx
void on_tx(void *mapped_base)
{
	int pwr_supp_reg;
	// Check state of power supplies
	pwr_supp_reg = read_reg_tx(36,mapped_base);
	if (pwr_supp_reg == 14)
	{
		write_reg_tx(66,32767,mapped_base); // signal gain max
	}
	else
	{
		printf("Supplies not in proper condition\n");
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x24, %edi
callq 0x1680
movl %eax, -0xc(%rbp)
cmpl $0xe, -0xc(%rbp)
jne 0x2088
movq -0x8(%rbp), %rdx
movl $0x42, %edi
movl $0x7fff, %esi           # imm = 0x7FFF
callq 0x1640
jmp 0x2096
leaq 0x1228(%rip), %rdi      # 0x32b7
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/miraclelib.c
// Function: set_freq_tx
void set_freq_tx(double fLO_in, void *mapped_base)
{
	int tab_line, fLO_mhz;
	char cmd_buff[50];
	uint64_t fLO;

	fLO = (uint64_t) fLO_in;

	if (fLO > 3700e6) // if input freq is too high, set to 3000
	{
		printf("Freq is too large, calibrating to 3700\n");
		fLO = 3700e6;
	}
	else if (fLO < 600e6) // if input freq is too low, set to 200
	{
		printf("Freq is too small, calibrating to 600\n");
		fLO = 600e6;
	}
	fLO_mhz = (int) (fLO/1e6);
	tab_line = (fLO_mhz+12)/25-24; // calculate line in air param matrix 

	//printf("fLO_mhz: %d\n", fLO_mhz);
	//printf("tab_line: %d\n", tab_line);

	write_reg_tx(64, tab_line, mapped_base); // calibrate
	ad9173_freq(fLO, mapped_base);

	//printf("A=0x%" PRIx64 "\n", A);
	sprintf(cmd_buff, "echo %lf > FLO", fLO_in);
	system(cmd_buff);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xf4a(%rip), %xmm2      # 0x3078
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x58(%rbp)
movaps 0xf49(%rip), %xmm1      # 0x30a0
movq -0x58(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xf48(%rip), %xmm1      # 0x30b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xf01(%rip), %xmm1      # 0x3080
ucomisd %xmm1, %xmm0
jbe 0x219e
leaq 0x1153(%rip), %rdi      # 0x32df
movb $0x0, %al
callq 0x1090
movl $0xdc898500, %eax       # imm = 0xDC898500
movq %rax, -0x58(%rbp)
jmp 0x21eb
movaps 0xefb(%rip), %xmm0      # 0x30a0
movq -0x58(%rbp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0xefa(%rip), %xmm0      # 0x30b0
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0xebb(%rip), %xmm0      # 0x3088
ucomisd %xmm1, %xmm0
jbe 0x21e9
leaq 0x112d(%rip), %rdi      # 0x3307
movb $0x0, %al
callq 0x1090
movq $0x23c34600, -0x58(%rbp) # imm = 0x23C34600
jmp 0x21eb
movaps 0xeae(%rip), %xmm1      # 0x30a0
movq -0x58(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xead(%rip), %xmm1      # 0x30b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xe76(%rip), %xmm1      # 0x3090
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0xc, %eax
movl $0x19, %ecx
cltd
idivl %ecx
subl $0x18, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movl $0x40, %edi
callq 0x1640
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c10
leaq -0x50(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
leaq 0x10c7(%rip), %rsi      # 0x332e
movb $0x1, %al
callq 0x1100
leaq -0x50(%rbp), %rdi
callq 0x1080
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/caesar.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
    )
{
    size_t outlen = 0;
    norx_aead_encrypt(c, &outlen, ad, adlen, m, mlen, NULL, 0, npub, k);
    *clen = outlen;
    (void)nsec; /* avoid warning */
    return 0;
}

// Assembly:
subq $0x58, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x68(%rsp), %r10
movq 0x70(%rsp), %rax
leaq 0x20(%rsp), %rsi
xorl %r11d, %r11d
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x1040
movq 0x20(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/caesar.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
    )
{
    size_t outlen = 0;
    int result = norx_aead_decrypt(m, &outlen, ad, adlen, c, clen, NULL, 0, npub, k);
    *mlen = outlen;
    (void)nsec; /* avoid warning */
    return result;
}

// Assembly:
subq $0x68, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x70(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
movq 0x78(%rsp), %r10
movq 0x80(%rsp), %rax
leaq 0x30(%rsp), %rsi
xorl %r11d, %r11d
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x1060
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movl 0x2c(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_absorb_data
void norx_absorb_data(norx_state_t state, const unsigned char * in, size_t inlen, tag_t tag)
{
    if (inlen > 0)
    {
        while (inlen >= BYTES(NORX_R))
        {
            norx_absorb_block(state, in, tag);
            #if defined(NORX_DEBUG)
            printf("Absorb block\n");
            norx_debug(state, in, BYTES(NORX_R), NULL, 0);
            #endif
            inlen -= BYTES(NORX_R);
            in += BYTES(NORX_R);
        }
        norx_absorb_lastblock(state, in, inlen, tag);
        #if defined(NORX_DEBUG)
        printf("Absorb lastblock\n");
        norx_debug(state, in, inlen, NULL, 0);
        #endif
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x1382
jmp 0x1331
cmpq $0x60, 0x10(%rsp)
jb 0x136a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x1390
movq 0x10(%rsp), %rax
subq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x18(%rsp)
jmp 0x1331
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x1420
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_absorb_block
static NORX_INLINE void norx_absorb_block(norx_state_t state, const uint8_t * in, tag_t tag)
{
    size_t i;
    norx_word_t * S = state->S;

    S[15] ^= tag;
    norx_permute(state);

    for (i = 0; i < WORDS(NORX_R); ++i) {
        S[i] ^= LOAD(in + i * BYTES(NORX_W));
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
movl %eax, %ecx
movq (%rsp), %rax
xorq 0x78(%rax), %rcx
movq %rcx, 0x78(%rax)
movq 0x20(%rsp), %rdi
callq 0x1e50
movq $0x0, 0x8(%rsp)
cmpq $0xc, 0x8(%rsp)
jae 0x1412
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1ea0
movq %rax, %rdx
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x13d0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_encrypt_data
void norx_encrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
    if (inlen > 0)
    {
        while (inlen >= BYTES(NORX_R))
        {
            norx_encrypt_block(state, out, in);
            #if defined(NORX_DEBUG)
            printf("Encrypt block\n");
            norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
            #endif
            inlen -= BYTES(NORX_R);
            in    += BYTES(NORX_R);
            out   += BYTES(NORX_R);
        }
        norx_encrypt_lastblock(state, out, in, inlen);
        #if defined(NORX_DEBUG)
        printf("Encrypt lastblock\n");
        norx_debug(state, in, inlen, out, inlen);
        #endif
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jbe 0x14f3
jmp 0x1492
cmpq $0x60, 0x8(%rsp)
jb 0x14da
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1500
movq 0x8(%rsp), %rax
subq $0x60, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x18(%rsp)
jmp 0x1492
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x15b0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_encrypt_block
static NORX_INLINE void norx_encrypt_block(norx_state_t state, uint8_t *out, const uint8_t * in)
{
    size_t i;
    norx_word_t * S = state->S;

    S[15] ^= PAYLOAD_TAG;
    norx_permute(state);

    for (i = 0; i < WORDS(NORX_R); ++i) {
        S[i] ^= LOAD(in + i * BYTES(NORX_W));
        STORE(out + i * BYTES(NORX_W), S[i]);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x78(%rax), %rcx
xorq $0x2, %rcx
movq %rcx, 0x78(%rax)
movq 0x20(%rsp), %rdi
callq 0x1e50
movq $0x0, 0x8(%rsp)
cmpq $0xc, 0x8(%rsp)
jae 0x15a4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1ea0
movq %rax, %rdx
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2d00
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x153f
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_decrypt_data
void norx_decrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
    if (inlen > 0)
    {
        while (inlen >= BYTES(NORX_R))
        {
            norx_decrypt_block(state, out, in);
            #if defined(NORX_DEBUG)
            printf("Decrypt block\n");
            norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
            #endif
            inlen -= BYTES(NORX_R);
            in    += BYTES(NORX_R);
            out   += BYTES(NORX_R);
        }
        norx_decrypt_lastblock(state, out, in, inlen);
        #if defined(NORX_DEBUG)
        printf("Decrypt lastblock\n");
        norx_debug(state, in, inlen, out, inlen);
        #endif
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jbe 0x1693
jmp 0x1632
cmpq $0x60, 0x8(%rsp)
jb 0x167a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x16a0
movq 0x8(%rsp), %rax
subq $0x60, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x18(%rsp)
jmp 0x1632
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1760
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_decrypt_block
static NORX_INLINE void norx_decrypt_block(norx_state_t state, uint8_t *out, const uint8_t * in)
{
    size_t i;
    norx_word_t * S = state->S;

    S[15] ^= PAYLOAD_TAG;
    norx_permute(state);

    for (i = 0; i < WORDS(NORX_R); ++i) {
        const norx_word_t c = LOAD(in + i * BYTES(NORX_W));
        STORE(out + i * BYTES(NORX_W), S[i] ^ c);
        S[i] = c;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rcx
xorq $0x2, %rcx
movq %rcx, 0x78(%rax)
movq 0x30(%rsp), %rdi
callq 0x1e50
movq $0x0, 0x18(%rsp)
cmpq $0xc, 0x18(%rsp)
jae 0x1750
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1ea0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
xorq 0x8(%rsp), %rsi
callq 0x2d00
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x16e1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_decrypt_lastblock
static NORX_INLINE void norx_decrypt_lastblock(norx_state_t state, uint8_t *out, const uint8_t * in, size_t inlen)
{
    norx_word_t * S = state->S;
    uint8_t lastblock[BYTES(NORX_R)];
    size_t i;

    S[15] ^= PAYLOAD_TAG;
    norx_permute(state);

    for(i = 0; i < WORDS(NORX_R); ++i) {
        STORE(lastblock + i * BYTES(NORX_W), S[i]);
    }

    memcpy(lastblock, in, inlen);
    lastblock[inlen] ^= 0x01;
    lastblock[BYTES(NORX_R) - 1] ^= 0x80;

    for (i = 0; i < WORDS(NORX_R); ++i) {
        const norx_word_t c = LOAD(lastblock + i * BYTES(NORX_W));
        STORE(lastblock + i * BYTES(NORX_W), S[i] ^ c);
        S[i] = c;
    }

    memcpy(out, lastblock, inlen);
    burn(lastblock, 0, sizeof lastblock);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq 0x78(%rax), %rcx
xorq $0x2, %rcx
movq %rcx, 0x78(%rax)
movq 0x90(%rsp), %rdi
callq 0x1e50
movq $0x0, 0x8(%rsp)
cmpq $0xc, 0x8(%rsp)
jae 0x17f4
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x70(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2d00
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x17b8
leaq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x10d0
movq 0x78(%rsp), %rax
movzbl 0x10(%rsp,%rax), %ecx
xorl $0x1, %ecx
movb %cl, 0x10(%rsp,%rax)
movzbl 0x6f(%rsp), %eax
xorl $0x80, %eax
movb %al, 0x6f(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0xc, 0x8(%rsp)
jae 0x189f
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1ea0
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x70(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
xorq (%rsp), %rsi
callq 0x2d00
movq (%rsp), %rdx
movq 0x70(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1833
movq 0x88(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x10d0
movq 0x354b(%rip), %rax      # 0x4e08
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq *%rax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_verify_tag
int norx_verify_tag(const unsigned char * tag1, const unsigned char * tag2)
{
    size_t i;
    unsigned acc = 0;

    for (i = 0; i < BYTES(NORX_T); ++i) {
        acc |= tag1[i] ^ tag2[i];
    }

    return (((acc - 1) >> 8) & 1) - 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movq $0x0, -0x18(%rsp)
cmpq $0x20, -0x18(%rsp)
jae 0x1939
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
orl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x18fb
movl -0x1c(%rsp), %eax
subl $0x1, %eax
shrl $0x8, %eax
andl $0x1, %eax
subl $0x1, %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_aead_encrypt
void norx_aead_encrypt(
  unsigned char *c, size_t *clen,
  const unsigned char *a, size_t alen,
  const unsigned char *m, size_t mlen,
  const unsigned char *z, size_t zlen,
  const unsigned char *nonce,
  const unsigned char *key
)
{
    norx_state_t state;
    norx_init(state, key, nonce);
    norx_absorb_data(state, a, alen, HEADER_TAG);
    norx_encrypt_data(state, c, m, mlen);
    norx_absorb_data(state, z, zlen, TRAILER_TAG);
    norx_finalise(state, c + mlen);
    *clen = mlen + BYTES(NORX_T);
    burn(state, 0, sizeof(norx_state_t));
}

// Assembly:
subq $0xb8, %rsp
movq 0xd8(%rsp), %rax
movq 0xd0(%rsp), %rax
movq 0xc8(%rsp), %rax
movq 0xc0(%rsp), %rax
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq %r9, 0x88(%rsp)
movq %rsp, %rdi
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x1a70
movq %rsp, %rdi
movq 0xa0(%rsp), %rsi
movq 0x98(%rsp), %rdx
movl $0x1, %ecx
callq 0x1070
movq %rsp, %rdi
movq 0xb0(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x10a0
movq %rsp, %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movl $0x4, %ecx
callq 0x1070
movq %rsp, %rdi
movq 0xb0(%rsp), %rsi
addq 0x88(%rsp), %rsi
callq 0x1bc0
movq 0x88(%rsp), %rcx
addq $0x20, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, (%rax)
movq 0x33b9(%rip), %rax      # 0x4e08
movq %rsp, %rdi
xorl %esi, %esi
movl $0x80, %edx
callq *%rax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)