LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/util/vector.c
// Function: vector_expand
void vector_expand(vector *v) {
	int n_max = v->max * 2;
	v->table = realloc(v->table, sizeof(void*)*n_max);
	v->max = n_max;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rsi
shlq $0x3, %rsi
callq 0x31c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/util/vector.c
// Function: vector_get
void *vector_get(vector *v, int index) {
	//Check bounds
	if (index < 0 || index >= v->len)
		return NULL;

	return v->table[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x107ad
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x107b7
movq $0x0, -0x8(%rbp)
jmp 0x107ca
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/util/vector.c
// Function: vector_add
void vector_add(vector *v, void *val) {
	//Allocate initial space if vector was initialized as empty
	if (v->max == VECTOR_EMPTY)
		vector_init(v, VECTOR_DEFAULT);

	//Expand the table if there is no room left
	if (v->len+1 >= v->max)
		vector_expand(v);

	//Add value to end of table
	int index = v->len;
	v->table[index] = val;
	v->len++;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x107f8
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x10680
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x10814
movq -0x8(%rbp), %rdi
callq 0x10740
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/util/vector.c
// Function: vector_remove
void vector_remove(vector *v, int index) {
	//Shift all entries if neccesary
	for (int i=index; i<v->len-1; i++)
		v->table[i] = v->table[i+1];
	v->table[v->len-1] = NULL;
	v->len--;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x108a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10861
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/util/vector.c
// Function: vector_pop
void *vector_pop(vector *v) {
	if (v->len == 0) return NULL;
	void *val = v->table[v->len-1];
	vector_remove(v, v->len-1);
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x10920
movq $0x0, -0x8(%rbp)
jmp 0x10957
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
subl $0x1, %esi
callq 0x10850
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: save
void save() {
  FILE *fp;
  if ((fp = fopen("ngaImage", "wb")) == NULL) {
    printf("Unable to save the image!\n");
    exit(2);
  }
  fwrite(&target, sizeof(CELL), here, fp);
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc2c(%rip), %rdi       # 0x201b
leaq 0xc2e(%rip), %rsi       # 0x2024
callq 0x1080
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x141d
leaq 0xc1b(%rip), %rdi       # 0x2027
movb $0x0, %al
callq 0x1050
movl $0x2, %edi
callq 0x10a0
movslq 0x82d2c(%rip), %rdx     # 0x84150
movq -0x8(%rbp), %rcx
leaq 0x2d21(%rip), %rdi      # 0x4150
movl $0x4, %esi
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: lookup
CELL lookup(char *name) {
  CELL slice = -1;
  CELL n = np;
  while (n > 0) {
    n--;
    if (strcmp(Labels[n], name) == 0) {
      slice = Pointers[n];
    }
  }
  return slice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl 0x82ceb(%rip), %eax     # 0x84154
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x14ae
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rax
leaq 0x82cda(%rip), %rdi     # 0x84160
shlq $0x6, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x1060
cmpl $0x0, %eax
jne 0x14ac
movslq -0x10(%rbp), %rcx
leaq 0xc2cba(%rip), %rax     # 0xc4160
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x146c
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: add_label
void add_label(char *name, CELL slice) {
  if (lookup(name) == -1) {
    bsd_strlcpy(Labels[np], name, STRING_LEN);
    Pointers[np] = slice;
    np++;
  } else {
    printf("Fatal error: %s already defined\n", name);
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1450
cmpl $-0x1, %eax
jne 0x1525
movslq 0x82c70(%rip), %rax     # 0x84154
leaq 0x82c75(%rip), %rdi     # 0x84160
shlq $0x6, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x40, %edx
callq 0x1550
movl -0xc(%rbp), %edx
movslq 0x82c4a(%rip), %rcx     # 0x84154
leaq 0xc2c4f(%rip), %rax     # 0xc4160
movl %edx, (%rax,%rcx,4)
movl 0x82c3a(%rip), %eax     # 0x84154
addl $0x1, %eax
movl %eax, 0x82c31(%rip)     # 0x84154
jmp 0x153e
movq -0x8(%rbp), %rsi
leaq 0xb12(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: opcode_for
CELL opcode_for(char *s) {
  char* opcodeList = "..lidudrswpupojucaccreeqneltgtfestadsumudianorxoshzrhaieiqii";
  int16_t* s16 = (int16_t *)s;
  int16_t* op16 = (int16_t *)opcodeList;
  int i = 0;
  for (i = 0; i <= 30; i++) {
    if (s16[0] == op16[i]) {
      return i;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0xa54(%rip), %rax       # 0x2063
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x1e, -0x2c(%rbp)
jg 0x1663
movq -0x20(%rbp), %rax
movswl (%rax), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0x1656
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x166a
jmp 0x1658
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1631
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: pass1
void pass1(char *buffer) {
  switch (buffer[0]) {
    case 'i': here++;                             break;
    case 'r': here++;                             break;
    case 'd': here++;                             break;
    case 's': here = here + strlen(buffer) - 1;   break;
    case ':': add_label(buffer+2, here);          break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3a, %eax
je 0x1716
jmp 0x1691
movl -0xc(%rbp), %eax
subl $0x64, %eax
je 0x16db
jmp 0x169b
movl -0xc(%rbp), %eax
subl $0x69, %eax
je 0x16b9
jmp 0x16a5
movl -0xc(%rbp), %eax
subl $0x72, %eax
je 0x16ca
jmp 0x16af
movl -0xc(%rbp), %eax
subl $0x73, %eax
je 0x16ec
jmp 0x1729
movl 0x82a91(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82a88(%rip)     # 0x84150
jmp 0x1729
movl 0x82a80(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82a77(%rip)     # 0x84150
jmp 0x1729
movl 0x82a6f(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82a66(%rip)     # 0x84150
jmp 0x1729
movslq 0x82a5d(%rip), %rax     # 0x84150
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movl %eax, 0x82a3c(%rip)     # 0x84150
jmp 0x1729
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl 0x82a2c(%rip), %esi     # 0x84150
callq 0x14c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: pass2
void pass2(char *buffer) {
  unsigned int opcode;
  char inst[3];
  inst[2] = '\0';
  switch (buffer[0]) {
    case 'i': memcpy(inst, buffer + 8, 2);
              opcode = opcode_for(inst);
              opcode = opcode << 8;
              memcpy(inst, buffer + 6, 2);
              opcode += opcode_for(inst);
              opcode = opcode << 8;
              memcpy(inst, buffer + 4, 2);
              opcode += opcode_for(inst);
              opcode = opcode << 8;
              memcpy(inst, buffer + 2, 2);
              opcode += opcode_for(inst);
              target[here++] = opcode;
              break;
    case 'r': here++;                             break;
    case 'd': here++;                             break;
    case 's': here = here + strlen(buffer) - 1;   break;
    case ':':                                     break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0xd(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x3a, %eax
je 0x187f
jmp 0x1755
movl -0x14(%rbp), %eax
subl $0x64, %eax
je 0x1844
jmp 0x1763
movl -0x14(%rbp), %eax
subl $0x69, %eax
je 0x178c
jmp 0x176d
movl -0x14(%rbp), %eax
subl $0x72, %eax
je 0x1833
jmp 0x177b
movl -0x14(%rbp), %eax
subl $0x73, %eax
je 0x1855
jmp 0x1881
movq -0x8(%rbp), %rax
movw 0x8(%rax), %ax
movw %ax, -0xf(%rbp)
leaq -0xf(%rbp), %rdi
callq 0x1600
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw 0x6(%rax), %ax
movw %ax, -0xf(%rbp)
leaq -0xf(%rbp), %rdi
callq 0x1600
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw 0x4(%rax), %ax
movw %ax, -0xf(%rbp)
leaq -0xf(%rbp), %rdi
callq 0x1600
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xf(%rbp)
leaq -0xf(%rbp), %rdi
callq 0x1600
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movl 0x82937(%rip), %eax     # 0x84150
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x8292c(%rip)     # 0x84150
movslq %eax, %rcx
leaq 0x2922(%rip), %rax      # 0x4150
movl %edx, (%rax,%rcx,4)
jmp 0x1881
movl 0x82917(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x8290e(%rip)     # 0x84150
jmp 0x1881
movl 0x82906(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x828fd(%rip)     # 0x84150
jmp 0x1881
movslq 0x828f4(%rip), %rax     # 0x84150
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movl %eax, 0x828d3(%rip)     # 0x84150
jmp 0x1881
jmp 0x1881
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: pass3
void pass3(char *buffer) {
  switch (buffer[0]) {
    case 'i': here++;                             break;
    case 'r': here++;                             break;
    case 'd': target[here++] = atoi(buffer+2);    break;
    case 's': here = here + strlen(buffer) - 1;   break;
    case ':':                                     break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3a, %eax
je 0x1954
jmp 0x18b1
movl -0xc(%rbp), %eax
subl $0x64, %eax
je 0x18fb
jmp 0x18bb
movl -0xc(%rbp), %eax
subl $0x69, %eax
je 0x18d9
jmp 0x18c5
movl -0xc(%rbp), %eax
subl $0x72, %eax
je 0x18ea
jmp 0x18cf
movl -0xc(%rbp), %eax
subl $0x73, %eax
je 0x192a
jmp 0x1956
movl 0x82871(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82868(%rip)     # 0x84150
jmp 0x1956
movl 0x82860(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82857(%rip)     # 0x84150
jmp 0x1956
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x1090
movl %eax, %edx
movl 0x82840(%rip), %eax     # 0x84150
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x82835(%rip)     # 0x84150
movslq %eax, %rcx
leaq 0x282b(%rip), %rax      # 0x4150
movl %edx, (%rax,%rcx,4)
jmp 0x1956
movslq 0x8281f(%rip), %rax     # 0x84150
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movl %eax, 0x827fe(%rip)     # 0x84150
jmp 0x1956
jmp 0x1956
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: pass4
void pass4(char *buffer) {
  unsigned int opcode;
  switch (buffer[0]) {
    case 'i': here++;                             break;
    case 'r': here++;                             break;
    case 'd': here++;                             break;
    case 's': opcode = 2;
              while (opcode < strlen(buffer)) {
                target[here++] = buffer[opcode++];
              }
              target[here++] = 0;
                                                  break;
    case ':':                                     break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x3a, %eax
je 0x1a61
jmp 0x1981
movl -0x10(%rbp), %eax
subl $0x64, %eax
je 0x19d4
jmp 0x198b
movl -0x10(%rbp), %eax
subl $0x69, %eax
je 0x19ac
jmp 0x1995
movl -0x10(%rbp), %eax
subl $0x72, %eax
je 0x19c0
jmp 0x199f
movl -0x10(%rbp), %eax
subl $0x73, %eax
je 0x19e5
jmp 0x1a63
movl 0x8279e(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82795(%rip)     # 0x84150
jmp 0x1a63
movl 0x8278a(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82781(%rip)     # 0x84150
jmp 0x1a63
movl 0x82776(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x8276d(%rip)     # 0x84150
jmp 0x1a63
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a3d
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movl %ecx, %ecx
movsbl (%rax,%rcx), %edx
movl 0x8272d(%rip), %eax     # 0x84150
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x82722(%rip)     # 0x84150
movslq %eax, %rcx
leaq 0x2718(%rip), %rax      # 0x4150
movl %edx, (%rax,%rcx,4)
jmp 0x19ec
movl 0x8270d(%rip), %eax     # 0x84150
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x82702(%rip)     # 0x84150
movslq %eax, %rcx
leaq 0x26f8(%rip), %rax      # 0x4150
movl $0x0, (%rax,%rcx,4)
jmp 0x1a63
jmp 0x1a63
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: pass5
void pass5(char *buffer) {
  switch (buffer[0]) {
    case 'i': here++;                             break;
    case 'r': target[here++] = lookup(buffer+2);
              if (lookup(buffer+2) == -1)
                printf("Lookup failed: '%s'\n", buffer+2);
                                                  break;
    case 'd': here++;                             break;
    case 's': here = here + strlen(buffer) - 1;   break;
    case ':':                                     break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3a, %eax
je 0x1b6a
jmp 0x1a91
movl -0xc(%rbp), %eax
subl $0x64, %eax
je 0x1b2f
jmp 0x1a9f
movl -0xc(%rbp), %eax
subl $0x69, %eax
je 0x1ac4
jmp 0x1aa9
movl -0xc(%rbp), %eax
subl $0x72, %eax
je 0x1ad8
jmp 0x1ab3
movl -0xc(%rbp), %eax
subl $0x73, %eax
je 0x1b40
jmp 0x1b6c
movl 0x82686(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x8267d(%rip)     # 0x84150
jmp 0x1b6c
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x1450
movl %eax, %edx
movl 0x82663(%rip), %eax     # 0x84150
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x82658(%rip)     # 0x84150
movslq %eax, %rcx
leaq 0x264e(%rip), %rax      # 0x4150
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x1450
cmpl $-0x1, %eax
jne 0x1b2d
movq -0x8(%rbp), %rsi
addq $0x2, %rsi
leaq 0x57a(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1050
jmp 0x1b6c
movl 0x8261b(%rip), %eax     # 0x84150
addl $0x1, %eax
movl %eax, 0x82612(%rip)     # 0x84150
jmp 0x1b6c
movslq 0x82609(%rip), %rax     # 0x84150
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movl %eax, 0x825e8(%rip)     # 0x84150
jmp 0x1b6c
jmp 0x1b6c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-muri.c
// Function: main
int main(int argc, char **argv) {
  bsd_strlcpy(code_start, "~~~", 32);
  bsd_strlcpy(code_end,   "~~~", 32);
  bsd_strlcpy(test_start, "```", 32);
  bsd_strlcpy(test_end,   "```", 32);
  np = 0;
  if (argc > 1) {
    here = 0; unu(argv[1], 0, &pass1);
    here = 0; unu(argv[1], 0, &pass2);
    here = 0; unu(argv[1], 0, &pass3);
    here = 0; unu(argv[1], 0, &pass4);
    here = 0; unu(argv[1], 0, &pass5);
    save();
    printf("Wrote %lld cells to ngaImage\n", (long long)here);
  }
  else {
    printf("No file specified.\n");
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x24f3(%rip), %rdi      # 0x4090
leaq 0x511(%rip), %rsi       # 0x20b5
movl $0x20, %edx
callq 0x1550
leaq 0x250b(%rip), %rdi      # 0x40c0
leaq 0x4f9(%rip), %rsi       # 0x20b5
movl $0x20, %edx
callq 0x1550
leaq 0x2523(%rip), %rdi      # 0x40f0
leaq 0x4e5(%rip), %rsi       # 0x20b9
movl $0x20, %edx
callq 0x1550
leaq 0x253b(%rip), %rdi      # 0x4120
leaq 0x4cd(%rip), %rsi       # 0x20b9
movl $0x20, %edx
callq 0x1550
movl $0x0, 0x82554(%rip)     # 0x84154
cmpl $0x1, -0x8(%rbp)
jle 0x1cc6
movl $0x0, 0x8253c(%rip)     # 0x84150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
leaq -0x5b5(%rip), %rdx      # 0x1670
callq 0x1300
movl $0x0, 0x8251c(%rip)     # 0x84150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
leaq -0x515(%rip), %rdx      # 0x1730
callq 0x1300
movl $0x0, 0x824fc(%rip)     # 0x84150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
leaq -0x3d5(%rip), %rdx      # 0x1890
callq 0x1300
movl $0x0, 0x824dc(%rip)     # 0x84150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
leaq -0x325(%rip), %rdx      # 0x1960
callq 0x1300
movl $0x0, 0x824bc(%rip)     # 0x84150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
leaq -0x235(%rip), %rdx      # 0x1a70
callq 0x1300
callq 0x13e0
movslq 0x8249a(%rip), %rsi     # 0x84150
leaq 0x400(%rip), %rdi       # 0x20bd
movb $0x0, %al
callq 0x1050
jmp 0x1cd4
leaq 0x40e(%rip), %rdi       # 0x20db
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/radekh[P]palbart/palbart-2.5.c
// Function: endOfBinary
void endOfBinary()
{
  /* Points to end of page for () operands.                                   */
  punchLiteralPool( &cp, clc - 1 );
  /* Points to end of page zero for [] operands.                              */
  punchLiteralPool( &pz, 0 );
  if( error_in_line )
  {
    listed = TRUE;
    clc = ( clc & 070000 ) + (( clc - 1 ) & 07777 );
    errorMessage( &end_of_file, -1 );
    clc = ( clc & 070000 ) + (( clc + 1 ) & 07777 );
  }
  else
  {
    listLine();             /* List line if not done yet.                     */
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movswl 0x85f5(%rip), %eax      # 0xb4d0
subl $0x1, %eax
leaq 0x85f3(%rip), %rdi      # 0xb4d8
movswl %ax, %esi
callq 0x32b0
leaq 0x86e8(%rip), %rdi      # 0xb5dc
xorl %esi, %esi
callq 0x32b0
cmpb $0x0, 0x8862(%rip)      # 0xb764
je 0x2f68
movb $0x1, 0x87d5(%rip)      # 0xb6e0
movswl 0x85be(%rip), %eax      # 0xb4d0
andl $0x7000, %eax           # imm = 0x7000
movswl 0x85b2(%rip), %ecx      # 0xb4d0
subl $0x1, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
addl %ecx, %eax
movw %ax, 0x85a0(%rip)       # 0xb4d0
leaq 0x8129(%rip), %rdi      # 0xb060
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5220
movswl 0x8588(%rip), %eax      # 0xb4d0
andl $0x7000, %eax           # imm = 0x7000
movswl 0x857c(%rip), %ecx      # 0xb4d0
addl $0x1, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
addl %ecx, %eax
movw %ax, 0x856a(%rip)       # 0xb4d0
jmp 0x2f6d
callq 0x6260
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/radekh[P]palbart/palbart-2.5.c
// Function: punchLiteralPool
void punchLiteralPool( LPOOL_T *p, WORD16 lpool_page )
{
  WORD16  loc;
  WORD16  tmplc;

  lpool_page &= 07600;

  if( p->loc < 00200 )
  {
    if( !rim_mode )
    {
      /* Put out origin if not in rim mode.                                   */
      punchOrigin( p->loc | lpool_page );
    }
    /* Put the literals in the object file.                                    */
    for( loc = p->loc; loc < 00200; loc++ )
    {
      tmplc = loc + lpool_page;
      printLine( line, (field | tmplc), p->pool[loc], LOC_VAL );
      punchLocObject( tmplc, p->pool[loc] );
    }
    p->error = FALSE;
    p->loc = 00200;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %eax
andl $0xf80, %eax            # imm = 0xF80
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
cmpl $0x80, %eax
jge 0x3392
cmpb $0x0, 0x7ed2(%rip)      # 0xb1bc
jne 0x3302
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
movswl -0xa(%rbp), %ecx
orl %ecx, %eax
movswl %ax, %edi
callq 0x33a0
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xc(%rbp)
movswl -0xc(%rbp), %eax
cmpl $0x80, %eax
jge 0x3381
movswl -0xc(%rbp), %eax
movswl -0xa(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movswl 0x81a4(%rip), %eax      # 0xb4d2
movswl -0xe(%rbp), %ecx
orl %ecx, %eax
movw %ax, %si
movq -0x8(%rbp), %rax
movswq -0xc(%rbp), %rdx
leaq 0x83b9(%rip), %rdi      # 0xb700
movl $0x3, %ecx
movswl %si, %esi
movswl 0x4(%rax,%rdx,2), %edx
callq 0x33e0
movw -0xe(%rbp), %dx
movq -0x8(%rbp), %rax
movswq -0xc(%rbp), %rcx
movswl %dx, %edi
movswl 0x4(%rax,%rcx,2), %esi
callq 0x6590
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x330e
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movw $0x80, 0x2(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/radekh[P]palbart/palbart-2.5.c
// Function: insertLiteral
WORD16 insertLiteral( LPOOL_T *pool, WORD16 value )
{
  WORD16  ix;
  LPOOL_T *p;

  p = pool;

  /* If page zero is the current page, make sure that literals are inserted   */
  /* in the page zero literal table.                                          */
  if(( clc & 07600 ) == 0 )
  {
     p = &pz;
  }

  /* Search the literal pool for any occurence of the needed value.           */
  ix = PAGE_SIZE - 1;
  while( ix >= p->loc && p->pool[ix] != value )
  {
    ix--;
  }

  /* Check if value found in literal pool. If not, then insert value.         */
  if( ix < p->loc )
  {
    (p->loc)--;
    p->pool[p->loc] = value;
    ix = p->loc;
  }
  return( ix );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movswl 0x67d2(%rip), %eax      # 0xb4d0
andl $0xf80, %eax            # imm = 0xF80
cmpl $0x0, %eax
jne 0x4d13
leaq 0x68cd(%rip), %rax      # 0xb5dc
movq %rax, -0x18(%rbp)
movw $0x7f, -0xc(%rbp)
movswl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movswl 0x2(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jl 0x4d48
movq -0x18(%rbp), %rax
movswq -0xc(%rbp), %rcx
movswl 0x4(%rax,%rcx,2), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4d51
jmp 0x4d5f
movw -0xc(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x4d19
movswl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4da1
movq -0x18(%rbp), %rax
movw 0x2(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x2(%rax)
movw -0xa(%rbp), %dx
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movswq 0x2(%rcx), %rcx
movw %dx, 0x4(%rax,%rcx,2)
movq -0x18(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xc(%rbp)
movw -0xc(%rbp), %ax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/radekh[P]palbart/palbart-2.5.c
// Function: testForLiteralCollision
BOOL testForLiteralCollision( WORD16 loc )
{
  WORD16  pagelc;
  BOOL    result = FALSE;
  WORD16  tmppage;

  tmppage = loc & 07600;
  pagelc  = loc & 00177;

  if( tmppage == 0 )
  {
    if( pagelc >= pz.loc && !pz.error )
    {
      errorMessage( &pz_literal_overflow, -1 );
      pz.error = TRUE;
      result = TRUE;
    }
  }
  else
  {
    if( pagelc >= cp.loc && !cp.error )
    {
      errorMessage( &literal_overflow, -1 );
      cp.error = TRUE;
      result = TRUE;
    }
  }
  return( result );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movb $0x0, -0x5(%rbp)
movswl -0x2(%rbp), %eax
andl $0xf80, %eax            # imm = 0xF80
movw %ax, -0x8(%rbp)
movswl -0x2(%rbp), %eax
andl $0x7f, %eax
movw %ax, -0x4(%rbp)
movswl -0x8(%rbp), %eax
cmpl $0x0, %eax
jne 0x621a
movswl -0x4(%rbp), %eax
movswl 0x53ef(%rip), %ecx      # 0xb5de
cmpl %ecx, %eax
jl 0x6218
cmpb $0x0, 0x53e2(%rip)      # 0xb5dc
jne 0x6218
leaq 0x4e0d(%rip), %rdi      # 0xb010
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5220
movb $0x1, 0x53c8(%rip)      # 0xb5dc
movb $0x1, -0x5(%rbp)
jmp 0x6250
movswl -0x4(%rbp), %eax
movswl 0x52b5(%rip), %ecx      # 0xb4da
cmpl %ecx, %eax
jl 0x624e
cmpb $0x0, 0x52a8(%rip)      # 0xb4d8
jne 0x624e
leaq 0x4dc7(%rip), %rdi      # 0xb000
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5220
movb $0x1, 0x528e(%rip)      # 0xb4d8
movb $0x1, -0x5(%rbp)
jmp 0x6250
movb -0x5(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: CloseAGG
void CloseAGG(struct aggfile *agg)
{
	if (!agg)
		return;
	if (agg->filename)
		free(agg->filename);
	if (agg->buf)
		free(agg->buf);
	if (agg->allentry)
		free(agg->allentry);
	fclose(agg->fin);
	free(agg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1255
jmp 0x12b1
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x126b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1283
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x129b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: HashFilename
unsigned short HashFilename(char *filename)
{
	unsigned char actual;
	unsigned short result = 0;

	while (*filename)
	{
		actual = *filename++ & 0x7F;
		if (actual >= 0x60)
			actual = actual - 32;
		result = ROL16((result >> 8) | ((result & 0xFF) << 8), 1) - actual;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movw $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1347
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
andl $0x7f, %eax
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x60, %eax
jl 0x1302
movzbl -0x9(%rbp), %eax
subl $0x20, %eax
movb %al, -0x9(%rbp)
movzwl -0xc(%rbp), %eax
sarl $0x8, %eax
movzwl -0xc(%rbp), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
shll %eax
movzwl -0xc(%rbp), %ecx
sarl $0x8, %ecx
movzwl -0xc(%rbp), %edx
andl $0xff, %edx
shll $0x8, %edx
orl %edx, %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
sarl $0xf, %ecx
orl %ecx, %eax
movzbl -0x9(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0xc(%rbp)
jmp 0x12ce
movw -0xc(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: fillentry
void fillentry(struct aggfile *agg)
{
	struct aggentry *aggentry = NULL;
	char *bufname = NULL;
	unsigned int i;

	agg->numentry = *(unsigned short*)agg->buf;
	if (!(agg->allentry = malloc(sizeof (struct entry) * agg->numentry)))
	{
		perror("malloc()");
		return;
	}
	printf("NUM_ENTRY = %X\n", agg->numentry);
	bufname = (char*)(agg->buf + agg->bufsize - (agg->numentry * 15));
	aggentry = (struct aggentry*)(agg->buf + 2);
	for (i = 0; i < agg->numentry; i++)
	{
		agg->allentry[i].hash = aggentry->hash;
		agg->allentry[i].buf = agg->buf + aggentry->off;
		agg->allentry[i].size = aggentry->size;
		strncpy(agg->allentry[i].filename, bufname, 15 - 1);
		bufname += 15;
		aggentry++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movw (%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movzwl 0x1c(%rax), %eax
movl %eax, %edi
shlq $0x5, %rdi
callq 0x10c0
movq -0x8(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x13b1
leaq 0xc5d(%rip), %rdi       # 0x2004
callq 0x1100
jmp 0x14c7
movq -0x8(%rbp), %rax
movzwl 0x1c(%rax), %esi
leaq 0xc4d(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
imull $0xf, %ecx, %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
cmpl %ecx, %eax
jae 0x14c7
movq -0x10(%rbp), %rax
movw (%rax), %cx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movw %cx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x2(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x6(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x1c(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rdi
addq $0xe, %rdi
movq -0x18(%rbp), %rsi
movl $0xe, %edx
callq 0x1040
movq -0x18(%rbp), %rax
addq $0xf, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0xe, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x140a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: direxists
int direxists(char* absolutePath)
{
	if (access(absolutePath, 0) == 0)
	{
        	struct stat status;
        	stat(absolutePath, &status);
        	if ((status.st_mode & S_IFDIR) == 0)
			return 0;
		return 1;
    	}
    	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x10e0
cmpl $0x0, %eax
jne 0x1521
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x10b0
movl -0x88(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x1518
movl $0x0, -0x4(%rbp)
jmp 0x1528
movl $0x1, -0x4(%rbp)
jmp 0x1528
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: dump_to_file
void dump_to_file(char *filename, unsigned char *buf, size_t size)
{
	FILE *fout;

	if (!(fout = fopen(filename, "wb")))
	{
		perror("fopen()");
		return;
	}
	fwrite(buf, 1, size, fout);
	fclose(fout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xabe(%rip), %rsi       # 0x201d
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x157c
leaq 0xaab(%rip), %rdi       # 0x2020
callq 0x1100
jmp 0x159b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1120
movq -0x20(%rbp), %rdi
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: extractall
void extractall(struct aggfile *agg, char *outputdir)
{
	char output_name[4096];
	unsigned int i;

	if (!direxists(outputdir))
		return;
	for (i = 0; i < agg->numentry; i++)
	{
		strcpy(output_name, outputdir);
  		strcat(output_name, agg->allentry[i].filename);
		dump_to_file(output_name, agg->allentry[i].buf, agg->allentry[i].size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14d0
cmpl $0x0, %eax
jne 0x15d6
jmp 0x167d
movl $0x0, -0x1014(%rbp)
movl -0x1014(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
cmpl %ecx, %eax
jae 0x167d
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0x1014(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rsi
addq $0xe, %rsi
callq 0x1110
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1014(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1014(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x1540
movl -0x1014(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1014(%rbp)
jmp 0x15e0
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: InfoAGG
void InfoAGG(struct aggfile *agg)
{
	unsigned int i;

	printf("Filename = %s\n", agg->filename);
	printf("NumEntry = %X\n", agg->numentry);
	for (i = 0; i < agg->numentry; i++)
	{
		printf("Hash = %X\n", agg->allentry[i].hash);
		printf("Name = %s\n", agg->allentry[i].filename);
		printf("Size = %X\n", agg->allentry[i].size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x97e(%rip), %rdi       # 0x2028
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
movzwl 0x1c(%rax), %esi
leaq 0x977(%rip), %rdi       # 0x2037
movb $0x0, %al
callq 0x1080
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
cmpl %ecx, %eax
jae 0x1756
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movzwl 0xc(%rax), %esi
leaq 0x94c(%rip), %rdi       # 0x2046
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0xc(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rsi
addq $0xe, %rsi
leaq 0x933(%rip), %rdi       # 0x2051
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
leaq 0x91b(%rip), %rdi       # 0x205c
movb $0x0, %al
callq 0x1080
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16ce
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/agg.c
// Function: OpenAGG
struct aggfile *OpenAGG(char *filename)
{
	struct aggfile *newagg = NULL;

	if (!(newagg = malloc(sizeof (struct aggfile))))
	{
		perror("malloc()");
		return NULL;
	}
	newagg->filename = strdup(filename);
	if (!(newagg->fin = fopen(filename, "rb")))
	{
		perror("fopen()");
		CloseAGG(newagg);
		return NULL;
	}
        fseek(newagg->fin,0, SEEK_END);
        newagg->bufsize = ftell(newagg->fin);
        fseek(newagg->fin, 0, SEEK_SET);
	if (!(newagg->buf = malloc(sizeof (char) * newagg->bufsize)))
	{
		perror("fopen()");
		CloseAGG(newagg);
		return NULL;
	}
	if (fread(newagg->buf, 1, newagg->bufsize, newagg->fin) != newagg->bufsize)
	{
		perror("fread()");
		CloseAGG(newagg);
		return NULL;
	}
	return newagg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x28, %edi
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17a1
leaq 0x875(%rip), %rdi       # 0x2004
callq 0x1100
movq $0x0, -0x8(%rbp)
jmp 0x18c8
movq -0x10(%rbp), %rdi
callq 0x1130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x8a8(%rip), %rsi       # 0x2067
callq 0x10f0
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x17f4
leaq 0x847(%rip), %rdi       # 0x2020
callq 0x1100
movq -0x18(%rbp), %rdi
callq 0x1240
movq $0x0, -0x8(%rbp)
jmp 0x18c8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10d0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x10c0
movq -0x18(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x1872
leaq 0x7c6(%rip), %rdi       # 0x2020
callq 0x1100
movq -0x18(%rbp), %rdi
callq 0x1240
movq $0x0, -0x8(%rbp)
jmp 0x18c8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x1060
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %ecx
cmpq %rcx, %rax
je 0x18c0
leaq 0x7c2(%rip), %rdi       # 0x206a
callq 0x1100
movq -0x18(%rbp), %rdi
callq 0x1240
movq $0x0, -0x8(%rbp)
jmp 0x18c8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Agg/main.c
// Function: main
int main(int argc, char *argv[])
{
	struct aggfile *agg = NULL;

	if (argc != 2)
	{
		fprintf(stderr, "%s <*.AGG>\n", argv[0]);
		return EXIT_FAILURE;
	}
	if (!(agg = OpenAGG(argv[1])))
		return EXIT_FAILURE;
	fillentry(agg);
	InfoAGG(agg);
	extractall(agg, "./extract/");
	CloseAGG(agg);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x192c
movq 0x26ed(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x756(%rip), %rsi       # 0x2072
movb $0x0, %al
callq 0x1090
movl $0x1, -0x4(%rbp)
jmp 0x197e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1760
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x194c
movl $0x1, -0x4(%rbp)
jmp 0x197e
movq -0x18(%rbp), %rdi
callq 0x1350
movq -0x18(%rbp), %rdi
callq 0x1690
movq -0x18(%rbp), %rdi
leaq 0x715(%rip), %rsi       # 0x207e
callq 0x15b0
movq -0x18(%rbp), %rdi
callq 0x1240
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/XCOPY.c
// Function: mycplink
int mycplink(char *name1, char *name2)
{
    char buf[1024]="";
    int ret;
    ret=readlink(name1, buf, sizeof(buf));
    if(ret!=0)
    {
        symlink(buf , name2 );
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1090
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x1040
movl %eax, -0x414(%rbp)
cmpl $0x0, -0x414(%rbp)
je 0x145a
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1080
xorl %eax, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/XCOPY.c
// Function: mycp
int mycp(char *dir1, char *dir2)
{
    int fd1;
    int fd2;
    int ret;
    int sts;
    char buf[1024];
    fd1=open(dir1, O_RDONLY);
    fd2=open(dir2, O_WRONLY|O_CREAT|O_TRUNC, 0666);
    while(1)
    {
        bzero(buf, sizeof(buf));
        ret= read(fd1, buf, sizeof(buf)-1 );
        if(ret<=0)
            break;
        sts=write(fd2, buf, ret);
        while(sts<ret)
        {
            sts+=write(fd2, buf+sts, ret-sts);
         }
    }
    close(fd1);
    close(fd2);
    struct stat info;
    ret=stat(dir1, &info);
    if(ret!=0)
    {
        perror("stat");
        return 1;
    }
    chmod(dir2, info.st_mode);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1120
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x1120
movl %eax, -0x20(%rbp)
leaq -0x430(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1090
movl -0x1c(%rbp), %edi
leaq -0x430(%rbp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x10c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jg 0x14dd
jmp 0x152b
movl -0x20(%rbp), %edi
leaq -0x430(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x1050
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1529
movl -0x20(%rbp), %edi
leaq -0x430(%rbp), %rsi
movslq -0x28(%rbp), %rax
addq %rax, %rsi
movl -0x24(%rbp), %eax
subl -0x28(%rbp), %eax
movslq %eax, %rdx
callq 0x1050
movq %rax, %rcx
movslq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x28(%rbp)
jmp 0x14f3
jmp 0x14ab
movl -0x1c(%rbp), %edi
callq 0x10a0
movl -0x20(%rbp), %edi
callq 0x10a0
movq -0x10(%rbp), %rdi
leaq -0x4c0(%rbp), %rsi
callq 0x10e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1569
leaq 0xaa9(%rip), %rdi       # 0x2004
callq 0x1130
movl $0x1, -0x4(%rbp)
jmp 0x157f
movq -0x18(%rbp), %rdi
movl -0x4a8(%rbp), %esi
callq 0x1110
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/XCOPY.c
// Function: main
int main(int argc, char **argv)
{
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    mycpdir(lines[1], lines[2]);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x28(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1260
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0xff, %rdi
addq $0x1fe, %rsi            # imm = 0x1FE
callq 0x1590
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmMultVec
void hpmMultVec(const float *pointA, float m, float *result){
    HPMpoint *a = (HPMpoint *) pointA;
    HPMpoint *r = (HPMpoint *) result;
    r->x = a->x * m;
    r->y = a->y * m;
    r->z = a->z * m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
mulss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
mulss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
mulss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmAddVec
void hpmAddVec(const float *pointA, const float *pointB, float *result){
    HPMpoint *a = (HPMpoint *) pointA;
    HPMpoint *b = (HPMpoint *) pointB;
    HPMpoint *r = (HPMpoint *) result;
    r->x = a->x + b->x;
    r->y = a->y + b->y;
    r->z = a->z + b->z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x28(%rbp), %rax
addss (%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x28(%rbp), %rax
addss 0x4(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
addss 0x8(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmCross
void hpmCross(const float *pointA, const float *pointB, float *result){
    HPMpoint *a = (HPMpoint *) pointA;
    HPMpoint *b = (HPMpoint *) pointB;
    HPMpoint *r = (HPMpoint *) result;
    r->x = a->y*b->z - a->z*b->y;
    r->y = a->z*b->x - a->x*b->z;
    r->z = a->x*b->y - a->y*b->x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm2
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x28(%rbp), %rax
mulss 0x4(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
movss (%rax), %xmm2
movq -0x20(%rbp), %rax
movss (%rax), %xmm1
movq -0x28(%rbp), %rax
mulss 0x8(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm2
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x28(%rbp), %rax
mulss (%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)