LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jech[P]shncpd/util.c
// Function: format_32
const char *
format_32(const unsigned char *data)
{
    static char buf[4][16];
    static int i = 0;
    i = (i + 1) % 4;
    snprintf(buf[i], 16, "%02x:%02x:%02x:%02x",
             data[0], data[1], data[2], data[3]);
    return buf[i];
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0xb8b0(%rip), %eax      # 0x174e0
incl %eax
andl $0x3, %eax
movl %eax, 0xb8a5(%rip)      # 0x174e0
shll $0x4, %eax
leaq 0xb85b(%rip), %rbx      # 0x174a0
addq %rbx, %rax
movzbl (%rdi), %ecx
movzbl 0x1(%rdi), %r8d
movzbl 0x2(%rdi), %r9d
movzbl 0x3(%rdi), %edx
movl %edx, (%rsp)
leaq 0x278f(%rip), %rdx      # 0xe3f2
movl $0x10, %esi
movq %rax, %rdi
xorl %eax, %eax
callq 0x2140
movl 0xb868(%rip), %eax      # 0x174e0
shlq $0x4, %rax
addq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jech[P]shncpd/util.c
// Function: format_64
const char *
format_64(const unsigned char *data)
{
    static char buf[4][28];
    static int i = 0;
    i = (i + 1) % 4;
    snprintf(buf[i], 28, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
             data[0], data[1], data[2], data[3],
             data[4], data[5], data[6], data[7]);
    return buf[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0xb8cd(%rip), %ecx      # 0x17560
incl %ecx
andl $0x3, %ecx
movl %ecx, 0xb8c2(%rip)      # 0x17560
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
leaq 0xb843(%rip), %rbx      # 0x174f0
addq %rbx, %rcx
addq %rcx, %rax
movzbl (%rdi), %ecx
movzbl 0x1(%rdi), %r8d
movzbl 0x2(%rdi), %r9d
movzbl 0x3(%rdi), %r10d
movzbl 0x4(%rdi), %r11d
movzbl 0x5(%rdi), %r14d
movzbl 0x6(%rdi), %r15d
movzbl 0x7(%rdi), %r12d
subq $0x8, %rsp
leaq 0x26fa(%rip), %rdx      # 0xe3de
movl $0x1c, %esi
movq %rax, %rdi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r14
pushq %r11
pushq %r10
callq 0x2140
addq $0x30, %rsp
movl 0xb859(%rip), %eax      # 0x17560
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rbx
addq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jech[P]shncpd/md5.c
// Function: md5_append
void
md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
    const md5_byte_t *p = data;
    int left = nbytes;
    int offset = (pms->count[0] >> 3) & 63;
    md5_word_t nbits = (md5_word_t)(nbytes << 3);

    if (nbytes <= 0)
	return;

    /* Update the message length. */
    pms->count[1] += nbytes >> 29;
    pms->count[0] += nbits;
    if (pms->count[0] < nbits)
	pms->count[1]++;

    /* Process an initial partial block. */
    if (offset) {
	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);

	memcpy(pms->buf + offset, p, copy);
	if (offset + copy < 64)
	    return;
	p += copy;
	left -= copy;
	md5_process(pms, pms->buf);
    }

    /* Process full blocks. */
    for (; left >= 64; p += 64, left -= 64)
	md5_process(pms, p);

    /* Process a final partial block. */
    if (left)
	memcpy(pms->buf, p, left);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xbe4a
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %r13d
shrl $0x3, %r13d
andl $0x3f, %r13d
movl %edx, %eax
shrl $0x1d, %eax
addl 0x4(%rdi), %eax
leal (,%r15,8), %edx
movl %eax, 0x4(%rdi)
addl %ecx, %edx
movl %edx, (%rdi)
jae 0xbdb1
incl %eax
movl %eax, 0x4(%r14)
testl %r13d, %r13d
je 0xbdff
leal (%r15,%r13), %eax
movl $0x40, %r12d
subl %r13d, %r12d
cmpl $0x41, %eax
cmovll %r15d, %r12d
leaq (%r14,%r13), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2210
movl %r12d, %ebp
addl %r13d, %ebp
cmpl $0x40, %ebp
jl 0xbdfa
leaq 0x18(%r14), %rsi
addq %r12, %rbx
subl %r12d, %r15d
movq %r14, %rdi
callq 0xbe59
cmpl $0x40, %ebp
jl 0xbe4a
cmpl $0x40, %r15d
jl 0xbe23
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbe59
addq $0x40, %rbx
leal -0x40(%r15), %eax
cmpl $0x7f, %r15d
movl %eax, %r15d
jg 0xbe05
jmp 0xbe26
movl %r15d, %eax
testl %eax, %eax
je 0xbe4a
addq $0x18, %r14
movslq %eax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jech[P]shncpd/md5.c
// Function: md5_finish
void
md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{
    static const md5_byte_t pad[64] = {
	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    md5_byte_t data[8];
    int i;

    /* Save the length before padding. */
    for (i = 0; i < 8; ++i)
	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
    /* Pad to 56 bytes mod 64. */
    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
    /* Append the length. */
    md5_append(pms, data, 8);
    for (i = 0; i < 16; ++i)
	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
xorl %edx, %edx
movl %edx, %ecx
andl $-0x4, %ecx
movl (%r14,%rcx), %esi
movl %eax, %ecx
andb $0x18, %cl
shrl %cl, %esi
movb %sil, (%rsp,%rdx)
incq %rdx
addl $0x8, %eax
cmpq $0x8, %rdx
jne 0xc7d5
movl (%r14), %eax
shrl $0x3, %eax
movl $0x37, %edx
subl %eax, %edx
andl $0x3f, %edx
incl %edx
leaq 0x1c12(%rip), %rsi      # 0xe420
movq %r14, %rdi
callq 0xbd69
movq %rsp, %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0xbd69
xorl %eax, %eax
xorl %edx, %edx
movl %edx, %ecx
andl $-0x4, %ecx
movl 0x8(%r14,%rcx), %esi
movl %eax, %ecx
andb $0x18, %cl
shrl %cl, %esi
movb %sil, (%rbx,%rdx)
incq %rdx
addl $0x8, %eax
cmpq $0x10, %rdx
jne 0xc82a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sadistech[P]nesromtool2/./src/nrt.c
// Function: nrt_chr_list_delete
nrt_chr_listitem* nrt_chr_listitem_at(nrt_chr_list* list, int index)
{
  nrt_chr_listitem *l = list->list;
  int counter = 0;

  while (l) {
    if (counter == index) {
      return l;
    }

    counter++;
    l = l->next;
  }

  return NULL;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x34eb
leal 0x1(%rsi), %edx
movq %rcx, %rax
decl %edx
je 0x34ed
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x34de
xorl %eax, %eax
testq %rax, %rax
je 0x350b
decl (%rdi)
testl %esi, %esi
je 0x350e
decl %esi
je 0x3502
movq 0x8(%rcx), %rcx
jmp 0x34f8
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
retq
xorl %eax, %eax
retq
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/sadistech[P]nesromtool2/./src/nrt_main.c
// Function: main
int main(int argc, char **argv, char **env) {
  if (argc == 1) {
    print_usage();
    exit(EXIT_SUCCESS);
  }

  char *appname = *(argv++); argc--;
  char *subcommand= *(argv++); argc--;

  if (subcommand[0] == '\0') {
    fprintf(stderr, "Please supply a subcommand.\n");
    print_usage();
    exit(EXIT_FAILURE);
  } else if (is_subcommand(subcommand, "help", "--help", "-h", NULL)) {
    print_usage();
  } else if (is_subcommand(subcommand, "info", NULL)) {
    subcommand_info(argc - 1, argv);
  } else if (is_subcommand(subcommand, "chr", NULL)) {
    subcommand_chr(argc - 1, argv);
  } else if (is_subcommand(subcommand, "prg", NULL)) {
    subcommand_prg(argc - 1, argv);
  } else if (is_subcommand(subcommand, "title", NULL)) {
    subcommand_title(argc - 1, argv);
  } else {
    fprintf(stderr, "Unknown subcommand: %s\n", subcommand);
    print_usage();
    exit(EXIT_FAILURE);
  }

  exit(EXIT_SUCCESS);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jne 0x5bd7
xorl %eax, %eax
callq 0x3b40
xorl %edi, %edi
callq 0x2300
movq %rsi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x0, (%r14)
jne 0x5c15
movq 0x540d(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x1c73(%rip), %rdi      # 0x7868
movl $0x1c, %esi
movl $0x1, %edx
callq 0x2310
xorl %eax, %eax
callq 0x3b40
movl $0x1, %edi
callq 0x2300
movl %edi, %ebp
leaq 0x8b8(%rip), %rsi       # 0x64d6
leaq 0x89d(%rip), %rdx       # 0x64c2
leaq 0x1c59(%rip), %rcx      # 0x7885
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4674
testb %al, %al
jne 0x5bc9
addq $0x10, %rbx
leaq 0x690(%rip), %rsi       # 0x62d8
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4674
testb %al, %al
je 0x5c6a
addl $-0x3, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x47eb
jmp 0x5bd0
leaq 0xad1(%rip), %rsi       # 0x6742
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4674
testb %al, %al
je 0x5c93
addl $-0x3, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x533e
jmp 0x5bd0
leaq 0x701(%rip), %rsi       # 0x639b
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4674
testb %al, %al
je 0x5cbc
addl $-0x3, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4ca3
jmp 0x5bd0
leaq 0x1278(%rip), %rsi      # 0x6f3b
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4674
testb %al, %al
je 0x5ce5
addl $-0x3, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x59ae
jmp 0x5bd0
movq 0x530c(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x1b92(%rip), %rsi      # 0x7888
movq %r14, %rdx
xorl %eax, %eax
callq 0x21e0
jmp 0x5c04
// File: /workspace/github_c_makefile_star2_O1/sushant8421[P]create_your_own_shell/run_searchstring.c
// Function: main
int main(int argc , char *argv[]){	
	int x , stat_loc;
	pid_t ch ;
	struct dirent *de;  // Pointer for directory entry 
  
    // opendir() returns a pointer of DIR type.  
    DIR *dr = opendir(argv[3]); 
  
    if (dr == NULL)  // opendir returns NULL if couldn't open directory 
    { 
        printf("Could not open current directory\n" ); 
        return 0; 
    }
    
    while ((de = readdir(dr)) != NULL) {
     	char *args[] = {"./searchstring" , argv[1] ,  de->d_name, argv[2], NULL};
    	if((ch = fork()) < 0){
    		printf("child is not created\n") ;
    	}
    	else if(ch > 0){
    		waitpid(ch, &stat_loc, WUNTRACED);
    	}
    	else{
    		if(x=execv("./searchstring", args)<0)
    			printf("execution error");
		}
	}
    		
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq 0x18(%rsi), %rdi
callq 0x1040
testq %rax, %rax
je 0x125f
movq %rax, %r14
movq %rax, %rdi
callq 0x1060
testq %rax, %rax
je 0x126b
leaq 0xe27(%rip), %r15       # 0x2004
leaq 0xe3f(%rip), %r12       # 0x2023
leaq -0x2c(%rbp), %r13
movq %r15, -0x60(%rbp)
movq 0x8(%rbx), %rcx
movq %rcx, -0x58(%rbp)
addq $0x13, %rax
movq %rax, -0x50(%rbp)
movq 0x10(%rbx), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x1090
testl %eax, %eax
js 0x1228
je 0x1232
movl %eax, %edi
movq %r13, %rsi
movl $0x2, %edx
callq 0x1070
jmp 0x1250
movq %r12, %rdi
callq 0x1030
jmp 0x1250
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
callq 0x1080
testl %eax, %eax
jns 0x1250
leaq 0xdca(%rip), %rdi       # 0x2013
xorl %eax, %eax
callq 0x1050
movq %r14, %rdi
callq 0x1060
testq %rax, %rax
jne 0x11e8
jmp 0x126b
leaq 0xdd2(%rip), %rdi       # 0x2038
callq 0x1030
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WereCatf[P]Gonzales/fast-gpio.c
// Function: muxToString
char *muxToString(uint8_t port, uint8_t pin, uint8_t mux)
{
	char *returnStr=strUnknownMux;
	if(port < 1 || port > 6 || pin > 31) return strUnknownMux;
	if(mux==0) return strInputMux;
	if(mux==1) return strOutputMux;
	if(mux==5) return strUnknownMux; //Manual gives no definition for such mux
	mux-=2;
	if(mux==4) mux=3; //Skip the "missing" mux above
	uint8_t i, _pins, _port, _row;
	_port=1;
	i=0;
	while(_port != port){
		_pins=pinsWithMux[i];
		i+=_pins*2+1;
		_port++;
	}
	_pins=pinsWithMux[i];
	//printf("Debug: %d, %d\n", i, _pins);
	i++;
	while(_pins){
		if(pinsWithMux[i]==pin){
			_row=pinsWithMux[i+1];
			returnStr=muxNames[_row][mux];
			if(returnStr==NULL) returnStr=strUnknownMux;
			break;
		}
		i+=2;
		_pins--;
	}
	return returnStr;
}

// Assembly:
movq 0x3eb1(%rip), %rax      # 0x7080
leal -0x7(%rdi), %ecx
cmpb $-0x6, %cl
setb %cl
cmpb $0x20, %sil
setae %r8b
orb %cl, %r8b
je 0x31e6
retq
cmpb $0x5, %dl
je 0x31e5
movzbl %dl, %ecx
cmpl $0x1, %ecx
je 0x31ff
testl %ecx, %ecx
jne 0x3207
movq 0x3e8a(%rip), %rax      # 0x7088
retq
movq 0x3e8a(%rip), %rax      # 0x7090
retq
addb $-0x2, %dl
cmpb $0x4, %dl
movzbl %dl, %edx
movl $0x3, %ecx
cmovnel %edx, %ecx
cmpb $0x1, %dil
jne 0x3222
xorl %edx, %edx
jmp 0x3242
decb %dil
xorl %edx, %edx
leaq 0x47f2(%rip), %r8       # 0x7a20
movzbl %dl, %edx
movb (%rdx,%r8), %r9b
addb %r9b, %r9b
addb %r9b, %dl
incb %dl
decb %dil
jne 0x322e
movzbl %dl, %r8d
leaq 0x47d3(%rip), %rdi      # 0x7a20
movb (%r8,%rdi), %r8b
testb %r8b, %r8b
je 0x31e5
incb %dl
movzbl %dl, %edx
cmpb %sil, (%rdx,%rdi)
je 0x326e
addb $0x2, %dl
decb %r8b
jne 0x3258
jmp 0x31e5
movzbl 0x1(%rdx,%rdi), %edx
shll $0x5, %edx
leaq 0x3e23(%rip), %rsi      # 0x70a0
addq %rdx, %rsi
movzbl %cl, %ecx
movq (%rsi,%rcx,8), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/WereCatf[P]Gonzales/fast-gpio.c
// Function: initGpio
int initGpio()
{
	int fd = open("/dev/mem", O_RDWR|O_SYNC);
	if(fd < 0) return 1;
	// uint32_t addr = 0x01c20800 & ~(getpagesize() - 1);
	//Requires memmap to be on pagesize-boundary
	memmap=(uint8_t *)mmap(NULL, getpagesize()*2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x01c20000);
	if(memmap == NULL) return 1;
	close(fd);

	//Set memmap to point to PIO-registers
	memmap=memmap+0x800;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x1c10(%rip), %rdi      # 0x4ea9
movl $0x101002, %esi         # imm = 0x101002
xorl %eax, %eax
callq 0x20a0
testl %eax, %eax
js 0x32f6
movl %eax, %ebx
callq 0x20c0
addl %eax, %eax
movslq %eax, %rsi
movl $0x1, %ebp
movl $0x1c20000, %r9d        # imm = 0x1C20000
xorl %edi, %edi
movl $0x3, %edx
movl $0x1, %ecx
movl %ebx, %r8d
callq 0x2060
movq %rax, 0x47f5(%rip)      # 0x7ad0
testq %rax, %rax
je 0x32fb
movl %ebx, %edi
callq 0x2080
addq $0x800, 0x47de(%rip) # imm = 0x800
xorl %ebp, %ebp
jmp 0x32fb
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WereCatf[P]Gonzales/fast-gpio.c
// Function: readMux
int readMux(int port, int pin)
{
	volatile uint32_t *pioMem32, *configRegister;
	pioMem32=(uint32_t *)(memmap+port*0x24);
	configRegister=pioMem32+(pin >> 3);
	return *configRegister >> ((pin & 7) * 4) & 7;
}

// Assembly:
movslq %edi, %rax
leaq (%rax,%rax,8), %rax
shlq $0x2, %rax
addq 0x47ba(%rip), %rax      # 0x7ad0
leal (,%rsi,4), %ecx
movl %esi, %edx
sarl $0x3, %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %eax
shrl %cl, %eax
andl $0x7, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/WereCatf[P]Gonzales/fast-gpio.c
// Function: writeMux
void writeMux(int port, int pin, uint8_t mux)
{
	volatile uint32_t *pioMem32, *configRegister;
	uint32_t mask;

	pioMem32=(uint32_t *)(memmap+port*0x24);
	mux &= 7;
	configRegister=pioMem32+(pin >> 3);
	mask = ~(7 << ((pin & 7) * 4));
	*configRegister &= mask;
	*configRegister |= mux << ((pin & 7) * 4);
}

// Assembly:
movslq %edi, %rax
leaq (%rax,%rax,8), %rax
shlq $0x2, %rax
addq 0x4790(%rip), %rax      # 0x7ad0
leal (,%rsi,4), %ecx
sarl $0x3, %esi
movslq %esi, %rsi
movl $0x7, %edi
shll %cl, %edi
notl %edi
andl %edi, (%rax,%rsi,4)
andl $0x7, %edx
shll %cl, %edx
orl %edx, (%rax,%rsi,4)
retq
// File: /workspace/github_c_makefile_star2_O1/WereCatf[P]Gonzales/fast-gpio.c
// Function: readPull
uint8_t readPull(int port, int pin)
{
	volatile uint32_t *pioMem32, *configRegister;
	pioMem32=(uint32_t *)(memmap+port*0x24+0x1c); //0x1c == pull-register
	configRegister=pioMem32+(pin >> 4);
	return *configRegister >> ((pin & 15) * 2) & 3;
}

// Assembly:
movslq %edi, %rax
leaq (%rax,%rax,8), %rax
shlq $0x2, %rax
addq 0x475c(%rip), %rax      # 0x7ad0
leal (%rsi,%rsi), %ecx
movl %esi, %edx
sarl $0x4, %edx
movslq %edx, %rdx
movl 0x1c(%rax,%rdx,4), %eax
shrl %cl, %eax
andb $0x3, %al
retq
// File: /workspace/github_c_makefile_star2_O1/WereCatf[P]Gonzales/fast-gpio.c
// Function: writePull
void writePull(int port, int pin, uint8_t value)
{
	value &= 3;
	volatile uint32_t *pioMem32, *configRegister;
	uint32_t mask;
	pioMem32=(uint32_t *)(memmap+port*0x24+0x1c); //0x1c == pull-register
	configRegister=pioMem32+(pin >> 4);
	mask = ~(3 << ((pin & 15) * 2));
	*configRegister &= mask;
	*configRegister |= value << ((pin & 15) * 2);
}

// Assembly:
movslq %edi, %rax
leaq (%rax,%rax,8), %rax
shlq $0x2, %rax
addq 0x4736(%rip), %rax      # 0x7ad0
leal (%rsi,%rsi), %ecx
sarl $0x4, %esi
movslq %esi, %rsi
movl $0x3, %edi
shll %cl, %edi
notl %edi
andl %edi, 0x1c(%rax,%rsi,4)
andl $0x3, %edx
shll %cl, %edx
orl %edx, 0x1c(%rax,%rsi,4)
retq
// File: /workspace/github_c_makefile_star2_O1/WereCatf[P]Gonzales/./include/fast-gpio.h
// Function: writePin
inline void writePin(int port, int pin, uint8_t value)
{
	value &= 1;
	volatile uint32_t *pioMem32;
	uint32_t mask;
	pioMem32=(uint32_t *)(memmap+portOffsetData[port]);
	mask = ~(1 << pin);
	*pioMem32 &= mask;
	if(value) *pioMem32 |= value << pin;
}

// Assembly:
movl %esi, %ecx
movq 0x466a(%rip), %rax      # 0x7ad0
movslq %edi, %rsi
leaq 0x464e(%rip), %rdi      # 0x7abe
movzbl (%rsi,%rdi), %esi
movl $0x1, %edi
shll %cl, %edi
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
roll %cl, %r8d
andl %r8d, (%rax,%rsi)
testb $0x1, %dl
je 0x3490
orl %edi, (%rax,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/Haswell/KeccakP-1600-AVX2.cpp
// Function: KeccakP1600_AddBytes
void KeccakP1600_AddBytes(void *state, const UINT8 *data, size_t offset, size_t length)
//*****************************************************************************
{
    keccak_state_t  &s = *(keccak_state_t *)state;
    UINT64      *d = (UINT64 *)data;
    UINT8       *t1, *d1;
    UINT64      t[25];
    UINT64      *t0;
    ptrdiff_t   lane_n = length / sizeof(UINT64);
    ptrdiff_t   byte_n = length % sizeof(UINT64);
    ptrdiff_t   i;

    KeccakP1600_ExtractBytes(state, (UINT8 *)t, 0, sizeof(t));

/*
    // "trailingBits + 256" is passed as offset to do "state ^ trailingBits".
    if (offset >= 256)
    {
        if (length < sizeof(t))
            ((UINT8 *)t)[length] ^= (UINT8)offset;
        offset = 0;
    }
*/

    t0 = (UINT64 *)((UINT8 *)t + offset);

    for (i = 0; i < lane_n; i++)
        t0[i] ^= d[i];

    if (byte_n)
    {
        t1 = (UINT8 *)(t0 + i);
        d1 = (UINT8 *)(d + i);

        for (i = 0; i < byte_n; i++)
            t1[i] ^= d1[i];
    }

    s.a0 = LOAD(t + 0*5);
    s.a1 = LOAD(t + 1*5);
    s.a2 = LOAD(t + 2*5);
    s.a3 = LOAD(t + 3*5);
    s.a4 = LOAD(t + 4*5);
    s.c4 = SET(t[0*5 + 4], t[1*5 + 4], t[2*5 + 4], t[3*5 + 4]);
    s.a44 = _mm256_set1_epi64x(t[4*5 + 4]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movl %r12d, %r14d
andl $0x7, %r14d
xorl %ebp, %ebp
movq %rsp, %rsi
movl $0xc8, %ecx
xorl %edx, %edx
callq 0x5060
leaq (%rsp,%r13), %rax
cmpq $0x8, %r12
jb 0x582d
shrq $0x3, %r12
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rcx
xorq %rcx, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r12
jne 0x581d
testq %r14, %r14
je 0x5898
decq %r14
vpbroadcastq %r14, %ymm0
vpcmpnltuq 0x1d7ba(%rip), %ymm0, %k0 # 0x23000
vpcmpnltuq 0x1d7cf(%rip), %ymm0, %k1 # 0x23020
kshiftlb $0x4, %k1, %k1
vpcmpnltuq 0x1d7de(%rip), %ymm0, %k2 # 0x23040
vpcmpnltuq 0x1d7f3(%rip), %ymm0, %k3 # 0x23060
korb %k1, %k0, %k0
kshiftlb $0x4, %k3, %k1
korb %k1, %k2, %k1
kunpckbw %k0, %k1, %k1
vmovdqu8 (%r15,%rbp,8), %xmm0 {%k1} {z}
vmovdqu8 (%rax,%rbp,8), %xmm1 {%k1} {z}
vpxor %xmm0, %xmm1, %xmm0
vmovdqu8 %xmm0, (%rax,%rbp,8) {%k1}
vmovups (%rsp), %ymm0
vmovaps %ymm0, (%rbx)
vmovups 0x28(%rsp), %ymm0
vmovaps %ymm0, 0x20(%rbx)
vmovups 0x50(%rsp), %ymm0
vmovaps %ymm0, 0x40(%rbx)
vmovups 0x78(%rsp), %ymm0
vmovaps %ymm0, 0x60(%rbx)
vmovups 0xa0(%rsp), %ymm0
vmovaps %ymm0, 0x80(%rbx)
kxnorw %k0, %k0, %k1
vpmovzxbd 0x1d930(%rip), %xmm0 # 0x23210
vpxor %xmm1, %xmm1, %xmm1
movq %rsp, %rax
vpgatherdq (%rax,%xmm0), %ymm1 {%k1}
vmovdqa %ymm1, 0xa0(%rbx)
vbroadcastsd 0xc0(%rsp), %ymm0
vmovaps %ymm0, 0xc0(%rbx)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/Haswell/KeccakP-1600-AVX2.cpp
// Function: KeccakP1600_ExtractBytes
void KeccakP1600_ExtractBytes(const void *state, UINT8 *data, size_t offset, size_t length)
//*********************************************************************************
{
    keccak_state_t  &s = *(keccak_state_t *)state;
    UINT64  t[25];
    UINT64  *d = (!offset && (length >= sizeof(t))) ? (UINT64 *)data : t;
    UINT64  *c4 = (UINT64 *)&s.c4;

    if ((d == t) && (length > sizeof(t)))
        length = sizeof(t);

    STORE(d + 0*5, s.a0);
    STORE(d + 1*5, s.a1);
    STORE(d + 2*5, s.a2);
    STORE(d + 3*5, s.a3);
    STORE(d + 4*5, s.a4);

    d[0*5 + 4] = c4[0];
    d[1*5 + 4] = c4[1];
    d[2*5 + 4] = c4[2];
    d[3*5 + 4] = c4[3];
    d[4*5 + 4] = c4[4]; //s.a44[0]

    if (d == t)
        memcpy(data, (UINT8 *)t + offset, length);
}

// Assembly:
subq $0xc8, %rsp
cmpq $0xc8, %rcx
movq %rsp, %rax
movq %rax, %r8
cmovaeq %rsi, %r8
testq %rdx, %rdx
cmovneq %rax, %r8
vmovaps (%rdi), %ymm0
vmovups %ymm0, (%r8)
vmovaps 0x20(%rdi), %ymm0
vmovups %ymm0, 0x28(%r8)
vmovaps 0x40(%rdi), %ymm0
vmovups %ymm0, 0x50(%r8)
vmovaps 0x60(%rdi), %ymm0
vmovups %ymm0, 0x78(%r8)
vmovaps 0x80(%rdi), %ymm0
vmovups %ymm0, 0xa0(%r8)
movq 0xa0(%rdi), %r9
movq %r9, 0x20(%r8)
movq 0xa8(%rdi), %r9
movq %r9, 0x48(%r8)
movq 0xb0(%rdi), %r9
movq %r9, 0x70(%r8)
movq 0xb8(%rdi), %r9
movq %r9, 0x98(%r8)
movq 0xc0(%rdi), %rdi
movq %rdi, 0xc0(%r8)
cmpq %rax, %r8
jne 0x59da
movl $0xc8, %eax
cmpq %rax, %rcx
cmovbq %rcx, %rax
leaq (%rsp,%rdx), %rcx
movq %rsi, %rdi
movq %rcx, %rsi
movq %rax, %rdx
vzeroupper
callq 0x5580
addq $0xc8, %rsp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/Haswell/KeccakP-1600-AVX2.cpp
// Function: KeccakP1600_OverwriteWithZeroes
void KeccakP1600_OverwriteWithZeroes(void *state, size_t byteCount)
//*********************************************************
{
    keccak_state_t  &s = *(keccak_state_t *)state;
    UINT64      t[25];

    KeccakP1600_ExtractBytes(state, (UINT8 *)t, 0, sizeof(t));
    memset(t, 0, byteCount);

    s.a0 = LOAD(t + 0*5);
    s.a1 = LOAD(t + 1*5);
    s.a2 = LOAD(t + 2*5);
    s.a3 = LOAD(t + 3*5);
    s.a4 = LOAD(t + 4*5);
    s.c4 = SET(t[0*5 + 4], t[1*5 + 4], t[2*5 + 4], t[3*5 + 4]);
    s.a44 = _mm256_set1_epi64x(t[4*5 + 4]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movl $0xc8, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x5060
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x5050
vmovups (%r14), %ymm0
vmovaps %ymm0, (%rbx)
vmovups 0x28(%r14), %ymm0
vmovaps %ymm0, 0x20(%rbx)
vmovups 0x50(%r14), %ymm0
vmovaps %ymm0, 0x40(%rbx)
vmovups 0x78(%r14), %ymm0
vmovaps %ymm0, 0x60(%rbx)
vmovups 0xa0(%r14), %ymm0
vmovaps %ymm0, 0x80(%rbx)
kxnorw %k0, %k0, %k1
vpmovzxbd 0x1d6b9(%rip), %xmm0 # 0x23210
vpxor %xmm1, %xmm1, %xmm1
vpgatherdq (%r14,%xmm0), %ymm1 {%k1}
vmovdqa %ymm1, 0xa0(%rbx)
vbroadcastsd 0xc0(%r14), %ymm0
vmovaps %ymm0, 0xc0(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/Haswell/KeccakP-1600-AVX2.cpp
// Function: KeccakP1600_ExtractAndAddBytes
void KeccakP1600_ExtractAndAddBytes(const void *state, const UINT8 *input, UINT8 *output, size_t offset, size_t length)
//***************************************************************************************
{
    UINT64      t[25];
    UINT64      *t0;
    const UINT64 *dIn = (UINT64 *)input;
    UINT64      *dOut = (UINT64 *)output;
    UINT8       *t1, *dlIn, *dlOut;
    ptrdiff_t   lane_n = length / sizeof(UINT64);
    ptrdiff_t   byte_n = length % sizeof(UINT64);
    ptrdiff_t   i;

    KeccakP1600_ExtractBytes(state, (UINT8 *)t, 0, sizeof(t));

    t0 = (UINT64 *)((UINT8 *)t + offset);

    for (i = 0; i < lane_n; i++)
        dOut[i] = dIn[i] ^ t0[i];

    if (byte_n)
    {
        t1 = (UINT8 *)(t0 + i);
        dlIn = (UINT8 *)(dIn + i);
        dlOut = (UINT8 *)(dOut + i);

        for (i = 0; i < byte_n; i++)
            dlOut[i] = dlIn[i] ^ t1[i];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movl %r15d, %r13d
andl $0x7, %r13d
xorl %ebp, %ebp
movq %rsp, %rsi
movl $0xc8, %ecx
xorl %edx, %edx
callq 0x5060
leaq (%rsp,%r12), %rax
cmpq $0x8, %r15
jb 0x5be4
shrq $0x3, %r15
xorl %ebp, %ebp
movq (%rax,%rbp,8), %rcx
xorq (%r14,%rbp,8), %rcx
movq %rcx, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r15
jne 0x5bd0
testq %r13, %r13
je 0x5c0b
leaq (%rax,%rbp,8), %rax
leaq (%r14,%rbp,8), %rcx
leaq (%rbx,%rbp,8), %rdx
xorl %esi, %esi
movb (%rax,%rsi), %dil
xorb (%rcx,%rsi), %dil
movb %dil, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %r13
jne 0x5bf7
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strisdigit
int strisdigit(char* str)
{
    char*   p   = str;

    while (*p != '\0') {
        if (!isdigit(*p))
            return -1;
        p++;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb (%rdi), %bpl
xorl %ebx, %ebx
testb %bpl, %bpl
je 0x1235
movq %rdi, %r14
callq 0x1120
movq (%rax), %rax
incq %r14
movsbq %bpl, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x1230
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x1218
jmp 0x1235
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: mbstrlen
int mbstrlen(char* src)
{
    int         ch      = 0,
                len     = 0;

    char*       p       = src;

    gunichar*   cpoints;

    setlocale(LC_CTYPE, LOCALE);
    while (*p != '\0') {
        /* get string length */
        if ((ch = mblen(p, MB_CUR_MAX)) < 0)
            return 0;

        if (ch > 1) {
            /* get unicode code point */
            cpoints = g_utf8_to_ucs4_fast(p, sizeof(*p), NULL);

            /*
             * multi byte
             * true : hankaku kana
             * false: other
             */
            if (*cpoints >= 0xff65 && *cpoints <= 0xff9f) {
                len++;
            } else {
                len += 2;
            }
            g_free(cpoints);
        } else {
            /* ascii */
            len++;
        }
        p += ch;
    }

    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xa8e(%rip), %rsi       # 0x2000
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x10d0
cmpb $0x0, (%rbx)
je 0x15e7
movl $0xffff009b, %r15d      # imm = 0xFFFF009B
xorl %ebp, %ebp
callq 0x1060
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1040
testl %eax, %eax
js 0x15e5
movl %eax, %r14d
movl $0x1, %r12d
cmpl $0x2, %eax
jl 0x15d3
movl $0x1, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10f0
movl (%rax), %ecx
addl %r15d, %ecx
cmpl $0x3b, %ecx
movl $0x2, %r12d
sbbl $0x0, %r12d
movq %rax, %rdi
callq 0x1050
addl %r12d, %ebp
movl %r14d, %eax
cmpb $0x0, (%rbx,%rax)
leaq (%rbx,%rax), %rbx
jne 0x1588
jmp 0x15e7
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strmax
int strmax(int val, char** src)
{
    int     i       = 0,
            j       = 0,
            len     = 0,
            max     = 0;

    j = val - 1;
    while (i <= j) {
        if ((len = mbstrlen(*(src + i))) > max)
            max = len;
        if ((len = mbstrlen(*(src + j))) > max)
            max = len;
        i++;
        j--;
    }

    return max;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x1656
movq %rsi, %rbx
movl %edi, %r14d
decq %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movq (%rbx,%r15,8), %rdi
callq 0x1100
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq (%rbx,%r14,8), %rdi
callq 0x1100
cmpl %ebp, %eax
cmovgl %eax, %ebp
incq %r15
leaq -0x1(%r14), %rax
cmpq %r14, %r15
movq %rax, %r14
jl 0x1629
jmp 0x1658
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: mbstrtok
char* mbstrtok(char* str, char* delimiter)
{
    static  char*   ptr = NULL;
            char*   bdy = NULL;

    if (!str)
        str = ptr;

    if (!str)
        return NULL;

    if ((bdy = strstr(str, delimiter)) != NULL) {
        *bdy = '\0';
        ptr = bdy + strlen(delimiter);
    } else {
        ptr = NULL;
    }

    return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x18f5
movq 0x27b3(%rip), %rbx      # 0x40a8
testq %rbx, %rbx
je 0x191d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
testq %rax, %rax
je 0x1921
movq %rax, %r15
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x1070
addq %r15, %rax
jmp 0x1923
xorl %ebx, %ebx
jmp 0x192a
xorl %eax, %eax
movq %rax, 0x277e(%rip)      # 0x40a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: trim
int trim(char* str)
{
    int     i       = 0,
            j       = 0;

    i = strlen(str) - 1;
    while (i >= 0 && isspace(*(str + i))) {
        i--;
    }
    *(str + i + 1) = '\0';
    i = 0;
    while (isspace(*(str + i)))
        i++;

    if (i > 0) {
        j = 0;
        while (*(str + i))
            *(str + j++) = *(str + i++);
        *(str + j) = '\0';
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1070
movl %eax, %r14d
decl %eax
cmpl $-0x1, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmovll %eax, %ebp
decq %r14
testl %r14d, %r14d
js 0x1977
callq 0x1120
movq (%rax), %rax
movl %r14d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movsbq (%rbx,%rcx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x194f
movl %r14d, %ebp
movslq %ebp, %rax
movb $0x0, 0x1(%rbx,%rax)
callq 0x1120
movq (%rax), %rcx
movq $-0x1, %rax
movsbq 0x1(%rbx,%rax), %rdx
incq %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x198e
testq %rax, %rax
je 0x19ca
movl %eax, %ecx
movb (%rbx,%rcx), %cl
testb %cl, %cl
je 0x19c4
xorl %edx, %edx
leaq (%rbx,%rdx), %rsi
movb %cl, (%rbx,%rdx)
incq %rdx
movb 0x1(%rax,%rsi), %cl
testb %cl, %cl
jne 0x19ae
movl %edx, %eax
jmp 0x19c6
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strcmp_lite
int strcmp_lite(const char* str1, const char* str2)
{
    if (str1 == NULL || str2 == NULL)
        return -1;

    size_t  cnt     = 0,
            len1    = 0,
            len2    = 0;

    len1 = strlen(str1);
    len2 = strlen(str2);

    while (*str1 == *str2 && *str1 != '\0' && *str2 != '\0') {
        str1++;
        str2++;
        cnt++;
    }
    if (cnt == len1 && cnt == len2)
        return 0;

    return 1;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jne 0x1a4c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1070
movq %rax, %rbx
movq %r14, %rdi
callq 0x1070
movb (%r14), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x1a39
movb (%r15), %sil
testb %sil, %sil
je 0x1a39
cmpb %dl, %sil
jne 0x1a39
xorl %edx, %edx
leaq 0x1(%rdx), %rcx
movb 0x1(%r14,%rdx), %sil
testb %sil, %sil
je 0x1a39
movb 0x1(%r15,%rdx), %dil
testb %dil, %dil
je 0x1a39
movq %rcx, %rdx
cmpb %sil, %dil
je 0x1a19
xorq %rcx, %rbx
xorq %rcx, %rax
xorl %ecx, %ecx
orq %rbx, %rax
setne %cl
popq %rbx
popq %r14
popq %r15
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strmax_with_regex
int strmax_with_regex(int val, char** src, regex_t* reg)
{
    int     i       = 0,
            j       = 0,
            len     = 0,
            max     = 0;

    j = val - 1;
    while (i <= j) {
        if ((len = mbstrlen_with_regex(*(src + i), reg)) > max)
            max = len;
        if ((len = mbstrlen_with_regex(*(src + j), reg)) > max)
            max = len;
        i++;
        j--;
    }

    return max;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edi, %edi
jle 0x1b96
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
decq %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r14,%r12,8), %rdi
movq %rbx, %rsi
callq 0x10a0
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x10a0
cmpl %ebp, %eax
cmovgl %eax, %ebp
incq %r12
leaq -0x1(%r15), %rax
cmpq %r15, %r12
movq %rax, %r15
jl 0x1b63
jmp 0x1b98
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/perftests/http/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct http_header HH[1];
	struct http_request R;
	char * s;
	struct sock_addr ** sas;
	int done = 0;

	WARNP_INIT;

	/* Sanity-check. */
	if (argc != 3) {
		warn0("Need two arguments (host, path)");
		goto err0;
	}

	/* Construct headers. */
	HH[0].header = "Host";
	HH[0].value = argv[1];

	/* Construct request. */
	R.method = "GET";
	R.path = argv[2];
	R.nheaders = 1;
	R.headers = HH;
	R.bodylen = 0;
	R.body = NULL;

	/* Resolve target addresses. */
	if (asprintf(&s, "%s:80", argv[1]) == -1)
		goto err0;
	if ((sas = sock_resolve(s)) == NULL) {
		warnp("Cannot resolve %s", s);
		goto err1;
	}
	free(s);
	s = NULL;

	/* Send request. */
	(void)http_request(sas, &R, 1000000, donereq, &done);

	/* Wait for request to complete. */
	if (events_spin(&done)) {
		warnp("Error in event loop");
		goto err2;
	}

	/* Free address structures. */
	sock_addr_freelist(sas);

	/* Success! */
	exit(0);

err2:
	sock_addr_freelist(sas);
err1:
	free(s);
err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movl $0x0, 0xc(%rsp)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x25ce
callq 0x75fc
cmpl $0x3, %ebp
jne 0x2666
leaq 0x6a46(%rip), %rax      # 0x9024
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%rcx)
leaq 0x6a34(%rip), %rax      # 0x9029
movq %rax, 0x10(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
leaq 0x6a0d(%rip), %rsi      # 0x902d
movq %rsp, %rdi
xorl %eax, %eax
callq 0x6294
cmpl $-0x1, %eax
je 0x2730
movq (%rsp), %rdi
callq 0x65d4
testq %rax, %rax
jne 0x2684
callq 0x2090
cmpl $0x0, (%rax)
movq (%rsp), %rsi
jne 0x26d4
leaq 0x69d9(%rip), %rdi      # 0x9033
xorl %eax, %eax
callq 0x779b
jmp 0x2727
leaq 0x6997(%rip), %rdi      # 0x9004
xorl %eax, %eax
callq 0x779b
callq 0x2090
movl $0x0, (%rax)
jmp 0x2730
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x2040
movq $0x0, (%rsp)
leaq 0x9b(%rip), %rcx        # 0x273a
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %r14
movl $0xf4240, %edx          # imm = 0xF4240
movq %rbx, %rdi
movq %r14, %r8
callq 0x3c20
movq %r14, %rdi
callq 0x2ab1
testl %eax, %eax
jne 0x26ed
movq %rbx, %rdi
callq 0x6ceb
xorl %edi, %edi
callq 0x2300
movq %rax, %rbx
leaq 0x6955(%rip), %rdi      # 0x9033
xorl %eax, %eax
callq 0x767c
movl $0x0, (%rbx)
jmp 0x2727
callq 0x2090
cmpl $0x0, (%rax)
jne 0x2707
leaq 0x6947(%rip), %rdi      # 0x9045
xorl %eax, %eax
callq 0x779b
jmp 0x271f
movq %rax, %r14
leaq 0x6934(%rip), %rdi      # 0x9045
xorl %eax, %eax
callq 0x767c
movl $0x0, (%r14)
movq %rbx, %rdi
callq 0x6ceb
movq (%rsp), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x2300
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/perftests/http/main.c
// Function: donereq
static int
donereq(void * cookie, struct http_response * R)
{
	int * done = cookie;
	size_t i;

	/* This request is over. */
	*done = 1;

	/* Did we succeed? */
	if (R == NULL) {
		warn0("HTTP request failed");
		return (-1);
	}

	/* Print status and headers. */
	printf("HTTP status = %d\n", R->status);
	for (i = 0; i < R->nheaders; i++)
		printf("%s\n\t%s\n",
		    R->headers[i].header, R->headers[i].value);

	/* Print the body received. */
	fwrite(R->body, 1, R->bodylen, stdout);

	/* Free the body. */
	free(R->body);

	/* Success! */
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x1, (%rdi)
testq %rsi, %rsi
je 0x27c5
movq %rsi, %r14
movl (%rsi), %esi
leaq 0x6913(%rip), %rdi      # 0x906d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2130
cmpq $0x0, 0x8(%r14)
je 0x279e
movl $0x8, %r12d
leaq 0x6908(%rip), %r15      # 0x907f
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2130
incq %r13
addq $0x10, %r12
cmpq 0x8(%r14), %r13
jb 0x277a
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rdi
movq 0xb82b(%rip), %rax      # 0xdfd8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2320
movq 0x20(%r14), %rdi
callq 0x2040
jmp 0x27e3
leaq 0x688d(%rip), %rdi      # 0x9059
xorl %eax, %eax
callq 0x779b
callq 0x2090
movl $0x0, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/main.c
// Function: main
int
main(int argc, char *argv[])
{
	struct sigaction sa;
	FILE *fp = NULL;
	char ch;

	while ((ch = getopt(argc, argv, "")) != -1) {
		switch (ch) {
		default:
			usage();
			break;
		}
	}
	argc -= optind;
	argv += optind;

	/* assign action for SIGFPE */
	sa.sa_handler = sigfpehand;
	sa.sa_flags = 0;
	sigemptyset(&sa.sa_mask);
	if (sigaction(SIGFPE, &sa, NULL) == -1)
		err(1, "sigaction");

	/* open input file */
	if (argc) {
		if (strcmp(*argv, "-") != 0)
			if ((fp = fopen(*argv, "r")) == NULL)
				err(1, "%s", *argv);
		if (fp)
			yyin = fp;
	}

	/* initialize machine */
	init(argc, argv);

	/* parse and execute input until EOF */
	setjmp(begin);
	while (prepare(), yyparse()) {
		if (DEBUG)
			debug();
		execute(NULL);
	}

	/* cleanup machine and close input file */
	cleanup();
	if (fp)
		fclose(fp);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movl %edi, %ebx
leaq 0x6a5d(%rip), %rdx      # 0x9022
callq 0x2270
cmpb $-0x1, %al
jne 0x26e3
movq 0xb9f7(%rip), %rax      # 0xdfd0
movslq (%rax), %r15
leaq 0x118(%rip), %rax       # 0x26fb
leaq 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
movl $0x0, 0x80(%rdi)
callq 0x21d0
xorl %eax, %eax
movl %eax, %edx
movq %rsp, %rsi
movl $0x8, %edi
callq 0x2090
cmpl $-0x1, %eax
je 0x26e8
movl %r15d, %ebp
leaq (%r14,%r15,8), %r14
cmpl %r15d, %ebx
je 0x267c
movq (%r14), %r15
leaq 0x69e3(%rip), %rsi      # 0x900e
movq %r15, %rdi
callq 0x21b0
testl %eax, %eax
je 0x2664
leaq 0x6d22(%rip), %rsi      # 0x9360
movq %r15, %rdi
callq 0x2260
movq %rax, %rcx
testq %rax, %rax
jne 0x2668
movq (%r14), %rdx
leaq 0x6ae2(%rip), %rsi      # 0x913a
xorl %eax, %eax
movl $0x1, %edi
callq 0x2220
xorl %eax, %eax
movl %eax, %ecx
testq %rcx, %rcx
je 0x267c
leaq 0xdcfc(%rip), %rax      # 0x10370
movq %rcx, (%rax)
movq %rcx, %r15
jmp 0x2681
xorl %eax, %eax
movl %eax, %r15d
subl %ebp, %ebx
movl %ebx, %edi
movq %r14, %rsi
callq 0x2a31
leaq 0xbb3c(%rip), %rdi      # 0xe1d0
callq 0x21a0
callq 0x2b7b
callq 0x5200
testl %eax, %eax
je 0x26c1
xorl %eax, %eax
movl %eax, %ebx
movq %rbx, %rdi
callq 0x2d73
callq 0x2b7b
callq 0x5200
testl %eax, %eax
jne 0x26ab
callq 0x2c80
testq %r15, %r15
je 0x26d3
movq %r15, %rdi
callq 0x20e0
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2310
leaq 0x6915(%rip), %rsi      # 0x9004
xorl %eax, %eax
movl $0x1, %edi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/error.c
// Function: warning
void
warning(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof buf - 1, fmt, ap);
	warnx("line %d: %s", yylineno, buf);
	va_end(ap);
	errno = 0;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2781
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xbaf8(%rip), %rbx      # 0xe2a0
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdi
movq %r10, %rdx
callq 0x20b0
leaq 0xb9d1(%rip), %rax      # 0xe190
movl (%rax), %esi
leaq 0x6874(%rip), %rdi      # 0x903c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
callq 0x2050
movl $0x0, (%rax)
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/error.c
// Function: yyerror
void
yyerror(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof buf - 1, fmt, ap);
	warnx("line %d: %s", yylineno, buf);
	va_end(ap);
	errno = 0;
	longjmp(begin, 1);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2845
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xba34(%rip), %rbx      # 0xe2a0
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdi
movq %r10, %rdx
callq 0x20b0
leaq 0xb90d(%rip), %rax      # 0xe190
movl (%rax), %esi
leaq 0x67b0(%rip), %rdi      # 0x903c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
callq 0x2050
movl $0x0, (%rax)
leaq 0xb928(%rip), %rdi      # 0xe1d0
movl $0x1, %esi
callq 0x2250
nop
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: installglobalname
Name *
installglobalname(const char *s, int t)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = t;
	name->next = nametab;
	nametab = name;
	return name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl $0x20, %edi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x2913
leaq 0x67fc(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r15, %rdi
callq 0x22c0
movq %rax, %r15
testq %rax, %rax
jne 0x2931
leaq 0x67de(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r15, 0x8(%r14)
movl %ebx, 0x10(%r14)
movq 0xd960(%rip), %rax      # 0x102a0
movq %rax, (%r14)
movq %r14, 0xd956(%rip)      # 0x102a0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: installlocalname
Name *
installlocalname(const char *s, Name *tab)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = VAR;
	name->next = tab;
	return name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x20, %edi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x297e
leaq 0x6791(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r15, %rdi
callq 0x22c0
movq %rax, %r15
testq %rax, %rax
jne 0x299c
leaq 0x6773(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r15, 0x8(%r14)
movl $0x105, 0x10(%r14)      # imm = 0x105
movq %rbx, (%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: addstr
String *
addstr(char *s, int final)
{
	String **list;
	String *p;

	if ((p = malloc(sizeof *p)) == NULL) {
		free(s);
		yyerror("out of memory");
	}
	if (final) {
		list = &finalstrings;
		p->orig = FINAL;
	} else {
		list = &autostrings;
		p->orig = AUTO;
	}
	p->s = s;
	if (*list)
		(*list)->prev = p;
	p->next = *list;
	p->prev = NULL;
	p->count = 1;
	*list = p;
	return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x28, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x29e5
movq %r14, %rdi
callq 0x2030
leaq 0x672a(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
xorl %ecx, %ecx
testl %ebp, %ebp
sete %cl
leaq 0xd8bd(%rip), %rdx      # 0x102b0
leaq 0xd8ae(%rip), %rax      # 0x102a8
cmoveq %rdx, %rax
movl %ecx, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq (%rax), %rcx
testq %rcx, %rcx
je 0x2a10
movq %rbx, (%rcx)
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
movq $0x0, (%rbx)
movq $0x1, 0x20(%rbx)
movq %rbx, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: init
void
init(int c, char *v[])
{
	Name *name;
	int i;

	argc = c;
	argvstrings = emalloc(argc * sizeof *argvstrings);
	for (i = 0; i < argc; i++) {
		argvstrings[i].s = v[i];
		argvstrings[i].orig = ARGV;
	}

	/* initialize program memory */
	prog.head = emalloc(sizeof *prog.head);
	prog.head->next = NULL;
	prog.base = prog.progp = prog.head;

	/* initialize frame stack */
	frame.head = emalloc(sizeof *frame.head);
	frame.head->next = NULL;
	frame.head->prev = NULL;
	frame.next = frame.head;

	/* initialize random function */
	srand(time(NULL));

	/* initialize symbol table with keyword and builtin names */
	for (i = 0; keywords[i].s; i++)
		installglobalname(keywords[i].s, keywords[i].v);
	for (i = 0; bltins[i].s; i++) {
		name = installglobalname(bltins[i].s, BLTIN);
		name->u.bltin = i;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, 0xd87a(%rip)      # 0x102b8
movslq %edi, %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x2a64
leaq 0x66ab(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, 0xd855(%rip)      # 0x102c0
movslq 0xd846(%rip), %rax      # 0x102b8
testq %rax, %rax
jle 0x2a98
addq $0x18, %r14
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%r14)
movl $0x2, -0x8(%r14)
incq %rcx
addq $0x28, %r14
cmpq %rcx, %rax
jne 0x2a7d
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2ab8
leaq 0x6657(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %rbx, 0xd809(%rip)      # 0x102c8
movq $0x0, (%rbx)
movq %rbx, 0xd80b(%rip)      # 0x102d8
movq %rbx, 0xd80c(%rip)      # 0x102e0
movl $0x30, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2af4
leaq 0x661b(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %rbx, 0xd7f5(%rip)      # 0x102f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, 0xd800(%rip)      # 0x10308
xorl %edi, %edi
callq 0x2200
movl %eax, %edi
callq 0x2180
leaq 0x677a(%rip), %rdi      # 0x9297
movl $0x10, %ebx
leaq 0xace7(%rip), %r14      # 0xd810
movl -0x8(%rbx,%r14), %esi
callq 0x28e9
movq (%rbx,%r14), %rdi
addq $0x10, %rbx
cmpq $0xf0, %rbx
jne 0x2b29
leaq 0x6794(%rip), %rdi      # 0x92df
leaq 0xadc6(%rip), %rbx      # 0xd918
xorl %r14d, %r14d
movl $0x106, %esi            # imm = 0x106
callq 0x28e9
movl %r14d, 0x18(%rax)
incq %r14
movq (%rbx), %rdi
addq $0x18, %rbx
cmpq $0x11, %r14
jne 0x2b55
addq $0x8, %rsp
popq %rbx
popq %r14
retq