LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/util/map.c
// Function: map_get
void *map_get(map *m, const char *key) {
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		if (!strcmp(m->keys[index], key)) {
			return m->table[index];
		}
		index = (index + 1) % m->max;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc5ed
movl 0x14(%rbx), %r12d
xorl %edx, %edx
divl %r12d
movq 0x8(%rbx), %r13
movslq %edx, %r15
movq (%r13,%r15,8), %rdi
testq %rdi, %rdi
je 0xc755
movl %edx, %ebp
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0xc759
incl %ebp
movl %ebp, %eax
cltd
idivl %r12d
jmp 0xc730
xorl %eax, %eax
jmp 0xc760
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/util/map.c
// Function: map_insert
void map_insert(map *m, const char *key, void *val) {
	//Expand the table capacity if load factor > 0.75
	if (m->count / (float)m->max > 0.75)
		map_expand(m);

	//Hash the key and perform linear probing if necessary
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		if (m->table[index] == NULL) break;
		index = (index + 1) % m->max;
	}

	//Insert the value and key
	m->table[index] = val;
	m->keys[index] = key;
	m->count++;

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
divss %xmm1, %xmm0
ucomiss 0x2901(%rip), %xmm0     # 0xf098
jbe 0xc7a1
movq %rbx, %rdi
callq 0xc633
movq %r14, %rdi
callq 0xc5ed
movl 0x14(%rbx), %ecx
xorl %edx, %edx
divl %ecx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movslq %edx, %rax
cmpq $0x0, (%rdi,%rax,8)
je 0xc7d1
cmpq $0x0, (%rsi,%rax,8)
je 0xc7d1
incl %edx
movl %edx, %eax
cltd
idivl %ecx
jmp 0xc7b7
movq %r15, (%rsi,%rax,8)
movq 0x8(%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/util/map.c
// Function: map_remove
void map_remove(map *m, const char *key) {
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		/* The data pointer is set to NULL, but the key isn't.
		 * As a result, get operations will return NULL, and insertion
		 * does an additional check to see if the space has been
		 * previously removed. If not reused, these spaces disappear
		 * upon resizing.
		 */
		if (!strcmp(m->keys[index], key)) {
			m->table[index] = NULL;
			break;
		}
		index = (index + 1) % m->max;
	}

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc5ed
movl 0x14(%rbx), %r15d
xorl %edx, %edx
divl %r15d
movq 0x8(%rbx), %r12
movslq %edx, %r13
movq (%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0xc83b
movl %edx, %ebp
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0xc830
incl %ebp
movl %ebp, %eax
cltd
idivl %r15d
jmp 0xc80c
movq (%rbx), %rax
movq $0x0, (%rax,%r13,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/util/vector.c
// Function: vector_init
void vector_init(vector *v, int size) {
	if (size > 0) {
		v->table = malloc(sizeof(void*)*size);
	} else {
		v->table = NULL;
	}
	v->len = 0;
	v->max = size;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xc8a6
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x3170
jmp 0xc8a8
xorl %eax, %eax
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movl %ebx, 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %edx
testl %edx, %edx
je 0xc93c
movl 0x8(%rbx), %ecx
movq (%rbx), %rax
jmp 0xc95e
movl $0x80, %edi
callq 0x3170
movq %rax, (%rbx)
movabsq $0x1000000000, %rcx     # imm = 0x1000000000
movq %rcx, 0x8(%rbx)
xorl %ecx, %ecx
movl $0x10, %edx
leal 0x1(%rcx), %esi
cmpl %edx, %esi
jl 0xc987
addl %edx, %edx
movslq %edx, %r15
leaq (,%r15,8), %rsi
movq %rax, %rdi
callq 0x31a0
movq %rax, (%rbx)
movl %r15d, 0xc(%rbx)
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %esi
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
movl %esi, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x8(%rdi), %rcx
leaq -0x1(%rcx), %rax
movq %rax, %rdx
cmpl %esi, %eax
jle 0xc9c3
movslq %esi, %rsi
movslq %eax, %rdx
incq %rsi
movq (%rdi), %r8
movq (%r8,%rsi,8), %r9
movq %r9, -0x8(%r8,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0xc9af
movq (%rdi), %rcx
movq $0x0, (%rcx,%rdx,8)
movl %eax, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xc9f9
movq (%rdi), %rdx
leaq -0x1(%rcx), %rsi
movq -0x8(%rdx,%rcx,8), %rax
movq $0x0, -0x8(%rdx,%rcx,8)
movl %esi, 0x8(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0xca0(%rip), %rdi       # 0x2006
leaq 0xca2(%rip), %rsi       # 0x200f
callq 0x1090
testq %rax, %rax
je 0x139e
movq %rax, %rbx
movslq 0x82dcf(%rip), %rdx     # 0x84150
leaq 0x2dc8(%rip), %rdi      # 0x4150
movl $0x4, %esi
movq %rax, %rcx
callq 0x10c0
movq %rbx, %rdi
popq %rbx
jmp 0x1040
leaq 0xd12(%rip), %rdi       # 0x20b7
callq 0x1030
movl $0x2, %edi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x82d91(%rip), %rax     # 0x84154
testq %rax, %rax
jle 0x1411
movq %rdi, %rbx
leaq 0x1(%rax), %r15
shlq $0x6, %rax
leaq 0x82d86(%rip), %rcx     # 0x84160
leaq (%rax,%rcx), %r14
addq $-0x40, %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0xc2d72(%rip), %r12     # 0xc4160
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
testl %eax, %eax
jne 0x1402
movl -0x8(%r12,%r15,4), %ebp
decq %r15
addq $-0x40, %r14
cmpq $0x1, %r15
ja 0x13ee
jmp 0x1416
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x13b4
cmpl $-0x1, %eax
jne 0x1482
movslq 0x82d1a(%rip), %rax     # 0x84154
movq %rax, %rdx
shlq $0x6, %rdx
leaq 0x82d18(%rip), %rcx     # 0x84160
addq %rdx, %rcx
xorl %edx, %edx
cmpq $0x3f, %rdx
je 0x1465
movb (%rbx,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
testb %sil, %sil
jne 0x144d
jmp 0x1469
movb $0x0, (%rcx,%rdx)
leaq 0xc2cf0(%rip), %rcx     # 0xc4160
movl %ebp, (%rcx,%rax,4)
incl %eax
movl %eax, 0x82cd9(%rip)     # 0x84154
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb89(%rip), %rdi       # 0x2012
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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:
movzbl (%rdi), %eax
cmpl $0x68, %eax
jle 0x151a
cmpl $0x73, %eax
je 0x152b
cmpl $0x72, %eax
je 0x1524
cmpl $0x69, %eax
je 0x1524
retq
cmpl $0x3a, %eax
je 0x1543
cmpl $0x64, %eax
jne 0x1519
incl 0x82c26(%rip)           # 0x84150
retq
pushq %rbx
movl 0x82c1e(%rip), %ebx     # 0x84150
callq 0x1050
addl %ebx, %eax
decl %eax
movl %eax, 0x82c0f(%rip)     # 0x84150
popq %rbx
retq
addq $0x2, %rdi
movl 0x82c03(%rip), %esi     # 0x84150
jmp 0x1421
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movzbl (%rdi), %eax
cmpl $0x71, %eax
jg 0x1626
cmpl $0x64, %eax
je 0x1647
cmpl $0x69, %eax
jne 0x164d
movzwl 0x8(%rdi), %eax
leaq 0xab7(%rip), %rdx       # 0x2033
xorl %ecx, %ecx
cmpw (%rdx), %ax
je 0x1599
addq $0x10000, %rcx          # imm = 0x10000
addq $0x2, %rdx
cmpq $0x1f0000, %rcx         # imm = 0x1F0000
jne 0x157e
xorl %ecx, %ecx
movzwl 0x6(%rdi), %edx
leaq 0xa8f(%rip), %rsi       # 0x2033
xorl %eax, %eax
cmpw (%rsi), %dx
je 0x15bf
addq $0x100, %rax            # imm = 0x100
addq $0x2, %rsi
cmpq $0x1f00, %rax           # imm = 0x1F00
jne 0x15a6
xorl %eax, %eax
addl %ecx, %eax
movzwl 0x4(%rdi), %edx
leaq 0xa67(%rip), %rsi       # 0x2033
xorl %ecx, %ecx
cmpw (%rsi), %dx
je 0x15e2
incq %rcx
addq $0x2, %rsi
cmpq $0x1f, %rcx
jne 0x15ce
xorl %ecx, %ecx
addl %ecx, %eax
shll $0x8, %eax
movzwl 0x2(%rdi), %edx
leaq 0xa41(%rip), %rsi       # 0x2033
xorl %ecx, %ecx
cmpw (%rsi), %dx
je 0x1608
incq %rcx
addq $0x2, %rsi
cmpq $0x1f, %rcx
jne 0x15f4
xorl %ecx, %ecx
addl %eax, %ecx
movslq 0x82b3f(%rip), %rax     # 0x84150
leal 0x1(%rax), %edx
movl %edx, 0x82b36(%rip)     # 0x84150
leaq 0x2b2f(%rip), %rdx      # 0x4150
movl %ecx, (%rdx,%rax,4)
jmp 0x164d
cmpl $0x72, %eax
je 0x1647
cmpl $0x73, %eax
jne 0x164d
movl 0x82b1a(%rip), %ebx     # 0x84150
callq 0x1050
addl %ebx, %eax
decl %eax
movl %eax, 0x82b0b(%rip)     # 0x84150
jmp 0x164d
incl 0x82b03(%rip)           # 0x84150
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movzbl (%rdi), %eax
cmpl $0x71, %eax
jg 0x1664
cmpl $0x64, %eax
je 0x168d
cmpl $0x69, %eax
je 0x1685
jmp 0x16b0
cmpl $0x72, %eax
je 0x1685
cmpl $0x73, %eax
jne 0x16b0
movl 0x82adc(%rip), %ebx     # 0x84150
callq 0x1050
addl %ebx, %eax
decl %eax
movl %eax, 0x82acd(%rip)     # 0x84150
jmp 0x16b0
incl 0x82ac5(%rip)           # 0x84150
jmp 0x16b0
addq $0x2, %rdi
callq 0x10a0
movslq 0x82ab3(%rip), %rcx     # 0x84150
leal 0x1(%rcx), %edx
movl %edx, 0x82aaa(%rip)     # 0x84150
leaq 0x2aa3(%rip), %rdx      # 0x4150
movl %eax, (%rdx,%rcx,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movzbl (%rdi), %eax
cmpl $0x71, %eax
jg 0x16cd
cmpl $0x64, %eax
je 0x1761
cmpl $0x69, %eax
je 0x1761
retq
cmpl $0x72, %eax
je 0x1761
cmpl $0x73, %eax
jne 0x16cc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x82a60(%rip), %r14d    # 0x84150
callq 0x1050
leaq 0x2a54(%rip), %r15      # 0x4150
cmpq $0x3, %rax
jb 0x173d
movslq %r14d, %rax
leaq (%r15,%rax,4), %r12
movl $0x2, %r13d
movl $0x3, %ebp
movsbl (%rbx,%r13), %eax
incl %r14d
movl %r14d, 0x82a2d(%rip)    # 0x84150
movl %eax, (%r12)
movl %ebp, %r13d
movq %rbx, %rdi
callq 0x1050
addq $0x4, %r12
incl %ebp
cmpq %r13, %rax
ja 0x1714
leal 0x1(%r14), %eax
movl %eax, 0x82a09(%rip)     # 0x84150
movslq %r14d, %rax
movl $0x0, (%r15,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl 0x829e9(%rip)           # 0x84150
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movzbl (%rdi), %eax
cmpl $0x71, %eax
jg 0x1786
cmpl $0x64, %eax
je 0x177e
cmpl $0x69, %eax
jne 0x17e2
incl 0x829cc(%rip)           # 0x84150
jmp 0x17e2
movq %rdi, %rbx
cmpl $0x72, %eax
je 0x17af
cmpl $0x73, %eax
jne 0x17e2
movl 0x829b6(%rip), %r14d    # 0x84150
movq %rbx, %rdi
callq 0x1050
addl %r14d, %eax
decl %eax
movl %eax, 0x829a3(%rip)     # 0x84150
jmp 0x17e2
addq $0x2, %rbx
movq %rbx, %rdi
callq 0x13b4
movslq 0x8298e(%rip), %rcx     # 0x84150
leal 0x1(%rcx), %edx
movl %edx, 0x82985(%rip)     # 0x84150
leaq 0x297e(%rip), %rdx      # 0x4150
movl %eax, (%rdx,%rcx,4)
movq %rbx, %rdi
callq 0x13b4
cmpl $-0x1, %eax
je 0x17ea
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x87f(%rip), %rdi       # 0x2070
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl $0x7e7e7e, %eax         # imm = 0x7E7E7E
movl %eax, 0x2880(%rip)      # 0x4090
movl %eax, 0x28aa(%rip)      # 0x40c0
movl $0x606060, %eax         # imm = 0x606060
movl %eax, 0x28cf(%rip)      # 0x40f0
movl %eax, 0x28f9(%rip)      # 0x4120
movl $0x0, 0x82923(%rip)     # 0x84154
cmpl $0x2, %edi
jl 0x18d3
movq %rsi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x8290b(%rip)     # 0x84150
movq 0x8(%rsi), %rdi
leaq -0x34e(%rip), %rdx      # 0x1502
xorl %esi, %esi
callq 0x128a
movl %ebp, 0x828f3(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x316(%rip), %rdx      # 0x1552
xorl %esi, %esi
callq 0x128a
movl %ebp, 0x828db(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x231(%rip), %rdx      # 0x164f
xorl %esi, %esi
callq 0x128a
movl %ebp, 0x828c3(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x1e6(%rip), %rdx      # 0x16b2
xorl %esi, %esi
callq 0x128a
movl %ebp, 0x828ab(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x148(%rip), %rdx      # 0x1768
xorl %esi, %esi
callq 0x128a
callq 0x135e
movslq 0x8288d(%rip), %rsi     # 0x84150
leaq 0x7bb(%rip), %rdi       # 0x2085
xorl %eax, %eax
callq 0x1060
jmp 0x18df
leaq 0x7f7(%rip), %rdi       # 0x20d1
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/radekh[P]palbart/palbart-2.5.c
// Function: defineSymbol
SYM_T *defineSymbol( char *name, WORD16 val, SYMTYP type, WORD16 start )
{
  SYM_T  *sym;
  int     xref_count;

  if( strlen( name ) < 1 )
  {
    return( &sym_undefined );   /* Protect against non-existent names.        */
  }
  sym = lookup( name );
  if( M_FIXED( sym->type ))
  {
      return( sym );            /* Can't modify permanent symbols.            */
  }

  xref_count = 0;               /* Set concordance for normal defintion.      */

  if( M_DEFINED( sym->type ))
  {
    if( pass == 2 && sym->val != val )
    {
      /* Generate diagnostic if redefining a symbol.                          */
      if( M_REDEFINED( sym->type ))
      {
        errorSymbol( &redefined_symbol, sym->name, start );
      }
      type = type | REDEFINED;
      sym->xref_count++;      /* Referenced suymbol, count it.                */
      xref_count = sym->xref_count;
    }
  }

  if( pass == 2 && xref )
  {
    /* Put the definition line number in the concordance table.               */
    /* Defined symbols are not counted as references.                         */
    xreftab[sym->xref_index] = lineno;
    /* Put the line number in the concordance table.                          */
    xreftab[sym->xref_index + xref_count] = lineno;
  }

  /* Now set the value and the type.                                          */
  sym->val = ( type == LABEL) ? val : val & 07777;
  sym->type = ( pass == 1 ) ? ( type | CONDITION ) : type;
  return( sym );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x2c46
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x3c11
movq %rax, %rbx
movl (%rax), %edx
testb $0x2, %dl
jne 0x2c4d
movl 0x865b(%rip), %eax      # 0xb200
cmpl $0x2, %eax
sete %sil
andb %dl, %sil
xorl %ecx, %ecx
cmpb $0x1, %sil
jne 0x2bf2
movl $0x2, %eax
cmpw %r14w, 0xc(%rbx)
je 0x2bf2
notl %edx
testb $0x11, %dl
jne 0x2be7
movq %rbx, %rsi
addq $0x4, %rsi
movswl %r15w, %edx
leaq 0x8424(%rip), %rdi      # 0xb000
callq 0x3daa
movl 0x8619(%rip), %eax      # 0xb200
orl $0x11, %ebp
movl 0x14(%rbx), %ecx
incl %ecx
movl %ecx, 0x14(%rbx)
cmpl $0x2, %eax
jne 0x2c20
cmpb $0x0, 0x8560(%rip)      # 0xb15e
je 0x2c20
movzwl 0x8a7d(%rip), %edx      # 0xb684
movq 0x8752(%rip), %rsi      # 0xb360
movslq 0x10(%rbx), %rdi
movw %dx, (%rsi,%rdi,2)
movslq %ecx, %rcx
addq %rdi, %rcx
movw %dx, (%rsi,%rcx,2)
movl %r14d, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
cmpl $0x9, %ebp
cmovel %r14d, %ecx
movw %cx, 0xc(%rbx)
movl %ebp, %ecx
orl $0x81, %ecx
cmpl $0x1, %eax
cmovnel %ebp, %ecx
movl %ecx, (%rbx)
jmp 0x2c4d
leaq 0x84f3(%rip), %rbx      # 0xb140
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movzwl 0x7d04(%rip), %eax      # 0xb470
decl %eax
movswl %ax, %esi
leaq 0x7d00(%rip), %rdi      # 0xb478
callq 0x3a33
leaq 0x7df8(%rip), %rdi      # 0xb57c
xorl %esi, %esi
callq 0x3a33
cmpb $0x0, 0x7f72(%rip)      # 0xb704
je 0x37eb
movb $0x1, 0x7ee5(%rip)      # 0xb680
movzwl 0x7cce(%rip), %eax      # 0xb470
movl $0x7000, %ebx           # imm = 0x7000
movl %eax, %ecx
andl %ebx, %ecx
decl %eax
movl $0xfff, %ebp            # imm = 0xFFF
andl %ebp, %eax
orl %ecx, %eax
movw %ax, 0x7cb3(%rip)       # 0xb470
leaq 0x78ac(%rip), %rdi      # 0xb070
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5062
movzwl 0x7c9b(%rip), %eax      # 0xb470
andl %eax, %ebx
incl %eax
andl %ebp, %eax
orl %ebx, %eax
movw %ax, 0x7c8c(%rip)       # 0xb470
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5d05
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzwl 0x2(%rdi), %ebp
cmpw $0x7f, %bp
jg 0x3ae1
movq %rdi, %rbx
andl $0xf80, %esi            # imm = 0xF80
cmpb $0x0, 0x7703(%rip)      # 0xb15c
movzwl %si, %r15d
jne 0x3a86
movl %ebp, %edi
orl %r15d, %edi
shrl $0x6, %edi
andl $0x3f, %edi
orl $0x40, %edi
callq 0x5fac
andl $0x3f, %ebp
movl %ebp, %edi
callq 0x5fac
movzwl 0x2(%rbx), %ebp
cmpw $0x7f, %bp
jg 0x3ad8
movswq %bp, %r12
incq %r12
addl %ebp, %r15d
leaq 0x7c09(%rip), %r14      # 0xb6a0
movzwl 0x79d4(%rip), %eax      # 0xb472
orw %r15w, %ax
movswl 0x2(%rbx,%r12,2), %edx
movswl %ax, %esi
movq %r14, %rdi
movl $0x3, %ecx
callq 0x3b06
movswl 0x2(%rbx,%r12,2), %esi
movswl %r15w, %edi
callq 0x5f67
movzwl %r12w, %eax
incq %r12
incl %r15d
cmpl $0x80, %eax
jne 0x3a97
movb $0x0, (%rbx)
movw $0x80, 0x2(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/radekh[P]palbart/palbart-2.5.c
// Function: printLine
void printLine( char *line, WORD16 loc, WORD16 val, LINESTYLE_T linestyle )
{
  if( listfile == NULL )
  {
    save_error_count = 0;
    return;
  }

  printPageBreak();

  list_lineno++;
  page_lineno++;
  switch( linestyle )
  {
  default:
  case LINE:
    fprintf(listfile, "%5d             ", lineno );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_VAL:
    fprintf(listfile, "%5d       %4.4o  ", lineno, val );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_LOC_VAL:
    if( !listed )
    {
      if( indirect_generated )
      {
        fprintf( listfile, "%5d %5.5o %4.4o@ ", lineno, loc, val );
      }
      else
      {
        fprintf( listfile, "%5d %5.5o %4.4o  ", lineno, loc, val );
      }
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    }
    break;

  case LOC_VAL:
    fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    break;
  }
  printErrorMessages();
}

// Assembly:
cmpq $0x0, 0x7842(%rip)      # 0xb350
je 0x3b65
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x5d2b
incl 0x7b5f(%rip)            # 0xb68c
incl 0x76f1(%rip)            # 0xb224
cmpl $0x1, %r15d
je 0x3b97
cmpl $0x2, %r15d
je 0x3b70
cmpl $0x3, %r15d
je 0x3b79
movq 0x7804(%rip), %rdi      # 0xb350
movl 0x7b32(%rip), %edx      # 0xb684
leaq 0x3bb8(%rip), %rsi      # 0x7711
xorl %eax, %eax
callq 0x2110
jmp 0x3bec
movl $0x0, 0x768d(%rip)      # 0xb1fc
retq
cmpb $0x0, 0x7b09(%rip)      # 0xb680
je 0x3bb7
movq 0x77d0(%rip), %rdi      # 0xb350
movswl %r14w, %edx
movswl %bp, %ecx
leaq 0x3bca(%rip), %rsi      # 0x7758
xorl %eax, %eax
callq 0x2110
jmp 0x3c02
movq 0x77b2(%rip), %rdi      # 0xb350
movl 0x7ae0(%rip), %edx      # 0xb684
movswl %bp, %ecx
leaq 0x3b74(%rip), %rsi      # 0x7722
xorl %eax, %eax
callq 0x2110
jmp 0x3bec
cmpb $0x0, 0x7b56(%rip)      # 0xb714
movq 0x778b(%rip), %rdi      # 0xb350
movl 0x7ab9(%rip), %edx      # 0xb684
movswl %r14w, %ecx
movswl %bp, %r8d
leaq 0x3b6c(%rip), %rax      # 0x7746
leaq 0x3b53(%rip), %rsi      # 0x7734
cmoveq %rax, %rsi
xorl %eax, %eax
callq 0x2110
movq 0x775d(%rip), %rsi      # 0xb350
movq %rbx, %rdi
callq 0x20b0
movb $0x1, 0x7a7e(%rip)      # 0xb680
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5e70
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
xorl %eax, %eax
callq 0x1110
movl %eax, %r15d
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x1110
movl %eax, %r12d
leaq -0x4d0(%rbp), %rbx
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movl $0x3ff, %edx            # imm = 0x3FF
movl %r15d, %edi
movq %rbx, %rsi
callq 0x10c0
movq %rax, %rbx
testl %ebx, %ebx
jle 0x1492
leaq -0x4d0(%rbp), %r13
movl %ebx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl %r12d, %edi
movq %r13, %rsi
callq 0x1050
cmpl %eax, %ebx
jle 0x146c
movslq %eax, %r14
leaq (%r14,%rbp), %rsi
addq $-0x4d0, %rsi           # imm = 0xFB30
movl %ebx, %eax
subl %r14d, %eax
movslq %eax, %rdx
movl %r12d, %edi
callq 0x1050
addq %r14, %rax
jmp 0x1445
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movl $0x3ff, %edx            # imm = 0x3FF
movl %r15d, %edi
movq %r13, %rsi
callq 0x10c0
movq %rax, %rbx
testl %ebx, %ebx
jg 0x1432
movl %r15d, %edi
callq 0x10a0
movl %r12d, %edi
callq 0x10a0
leaq -0xc8(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x10e0
testl %eax, %eax
jne 0x14d9
movl -0xb0(%rbp), %esi
movq -0x30(%rbp), %rdi
callq 0x1100
xorl %eax, %eax
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb24(%rip), %rdi       # 0x2004
callq 0x1120
movl $0x1, %eax
jmp 0x14c7
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmMat4VecArrayMult
void hpmMat4VecArrayMult(const float *mat, float *vec, size_t length, size_t stride){
    int i;
    stride = (stride) ? stride : 3 * sizeof(float);
    for (i = 0; i < length; i++){
        hpmMat4VecMult(mat, vec);
        vec = ((float *) ((char *) vec + stride));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
movl $0xc, %r12d
cmovneq %rcx, %r12
testq %rdx, %rdx
je 0x4970
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x41c0
addq %r12, %r14
decq %rbx
jne 0x495d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmQuatVecRotate
void hpmQuatVecRotate(const float *quat, float *point){
    float r[4], i[4];
    HPMpoint *pt = (HPMpoint *) point;
    HPMquat p;
    p.x = pt->x;
    p.y = pt->y;
    p.z = pt->z;
    p.w = 0;
    hpmQuatInverse(quat, i);
    hpmQuatCross(i, (float *) &p, r);
    hpmQuatCross(r, quat, i);
    pt->x = i[0];
    pt->y = i[1];
    pt->z = i[2];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movsd (%rbx), %xmm0
movsd (%rdi), %xmm2
movaps 0x6532(%rip), %xmm5     # 0xb050
movaps %xmm2, %xmm3
xorps %xmm5, %xmm3
movss 0x8(%rbx), %xmm1
movq %rsp, %r14
movlps %xmm3, (%r14)
movss 0x8(%rdi), %xmm4
xorps %xmm4, %xmm5
movss %xmm5, 0x8(%r14)
movaps %xmm4, %xmm6
shufps $0xd4, %xmm2, %xmm6     # xmm6 = xmm6[0,1],xmm2[1,3]
movaps %xmm0, %xmm7
movlhps %xmm2, %xmm7            # xmm7 = xmm7[0],xmm2[0]
shufps $0x22, %xmm7, %xmm6     # xmm6 = xmm6[2,0],xmm7[2,0]
movapd 0x6509(%rip), %xmm7     # 0xb060
movapd %xmm7, %xmm8
movsd %xmm2, %xmm8            # xmm8 = xmm2[0],xmm8[1]
shufps $0x24, %xmm8, %xmm7     # xmm7 = xmm7[0,1],xmm8[2,0]
mulps %xmm6, %xmm7
movss 0xc(%rdi), %xmm6
shufps $0x0, %xmm6, %xmm6      # xmm6 = xmm6[0,0,0,0]
xorps %xmm8, %xmm8
movlhps %xmm0, %xmm8            # xmm8 = xmm8[0],xmm0[0]
movaps %xmm1, %xmm9
shufps $0xd4, %xmm0, %xmm9     # xmm9 = xmm9[0,1],xmm0[1,3]
shufps $0x22, %xmm8, %xmm9     # xmm9 = xmm9[2,0],xmm8[2,0]
mulps %xmm6, %xmm9
addps %xmm7, %xmm9
movaps %xmm2, %xmm6
shufps $0x11, %xmm3, %xmm6     # xmm6 = xmm6[1,0],xmm3[1,0]
shufps $0x20, %xmm6, %xmm3     # xmm3 = xmm3[0,0],xmm6[2,0]
movss %xmm5, %xmm3            # xmm3 = xmm5[0],xmm3[1,2,3]
movaps %xmm1, %xmm5
shufps $0x30, %xmm0, %xmm5     # xmm5 = xmm5[0,0],xmm0[3,0]
shufps $0x40, %xmm0, %xmm1     # xmm1 = xmm1[0,0],xmm0[0,1]
shufps $0x84, %xmm5, %xmm0     # xmm0 = xmm0[0,1],xmm5[0,2]
shufps $0x64, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,1]
mulps %xmm3, %xmm0
addps %xmm9, %xmm0
shufps $0x4, %xmm4, %xmm2      # xmm2 = xmm2[0,1],xmm4[0,0]
shufps $0x78, %xmm1, %xmm1     # xmm1 = xmm1[0,2,3,1]
mulps %xmm2, %xmm1
addps %xmm0, %xmm1
shufps $0xd2, %xmm1, %xmm1     # xmm1 = xmm1[2,0,1,3]
leaq 0x10(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %r14, %rdx
callq 0x4130
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmAxisAngleQuatRotation
void hpmAxisAngleQuatRotation(float *axis, float angle, float *quat){
    HPMquat *q = (HPMquat *) quat;
    HPMpoint *a = (HPMpoint *) axis;
    float s = sin(angle/2.0);
    q->x = s*a->x;
    q->y = s*a->y;
    q->z = s*a->z;
    q->w = cos(angle/2.0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
mulsd 0x6403(%rip), %xmm0     # 0xb010
movsd %xmm0, (%rsp)
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movsd (%r14), %xmm1
movaps %xmm0, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
mulps %xmm1, %xmm2
movlps %xmm2, (%rbx)
mulss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%rbx)
movsd (%rsp), %xmm0
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatAxisAngle
void hpmRotateQuatAxisAngle(float *axis, float angle, float *quat){
    float rot[4], r[4];
    hpmAxisAngleQuatRotation(axis, angle, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
mulsd 0x63a3(%rip), %xmm0     # 0xb010
movsd %xmm0, 0x8(%rsp)
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movsd (%r14), %xmm1
movaps %xmm0, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
mulps %xmm1, %xmm2
leaq 0x20(%rsp), %r15
movlps %xmm2, (%r15)
mulss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%r15)
movsd 0x8(%rsp), %xmm0
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%r15)
leaq 0x10(%rsp), %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4130
movaps (%r14), %xmm0
movups %xmm0, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatX
void hpmRotateQuatX(float angle, float *quat){
    if (angle == 0.0) return;
    float rot[4], r[4];
    hpmXQuatRotation(angle, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4d35
jp 0x4d35
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
mulsd 0x62c3(%rip), %xmm0     # 0xb010
movsd %xmm0, 0x8(%rsp)
callq 0x4210
cvtsd2ss %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movss %xmm0, (%r14)
xorps %xmm1, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x4(%r14)
movss %xmm1, 0x8(%r14)
movsd 0x8(%rsp), %xmm0
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%r14)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4130
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatZ
void hpmRotateQuatZ(float angle, float *quat){
    if (angle == 0.0) return;
    float rot[4], r[4];
    hpmZQuatRotation(angle, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4ee9
jp 0x4ee9
retq
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
mulsd 0x6111(%rip), %xmm0     # 0xb010
movsd %xmm0, 0x8(%rsp)
callq 0x4210
movapd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4310
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
cvtpd2ps %xmm1, %xmm0
xorpd %xmm1, %xmm1
mulss %xmm0, %xmm1
leaq 0x30(%rsp), %rdi
movss %xmm1, (%rdi)
movss %xmm1, 0x4(%rdi)
movlpd %xmm0, 0x8(%rdi)
leaq 0x20(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4130
movaps (%r14), %xmm0
movups %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmSlerp
void hpmSlerp(const float *quatA, const float *quatB, float t, float *result){
    HPMquat *a = (HPMquat *) quatA;
    HPMquat *b = (HPMquat *) quatB;
    HPMquat *r = (HPMquat *) result;
    float cosOmega = a->x*b->x + a->y*b->y + a->z*b->z + a->w*b->w;
    if (cosOmega < 0){
        b->x = -b->x;
        b->y = -b->y;
        b->z = -b->z;
        b->w = -b->w;
        cosOmega = -cosOmega;
    }
    float ka, kb;
    if (cosOmega > 0.9999){ // Linear interpolation when close
        ka = 1-t;
        kb = t;
    } else {
        float sinOmega = sqrt(1 - cosOmega*cosOmega);
        float omega = atan2(sinOmega, cosOmega);
        float oneOverSinOmega = 1/sinOmega;
        ka = sin((1-t) * omega) *oneOverSinOmega;
        kb = sin(t * omega) *oneOverSinOmega;
    }
    r->x = a->x*ka + b->x*kb;
    r->y = a->y*ka + b->y*kb;
    r->z = a->z*ka + b->z*kb;
    r->w = a->w*ka + b->w*kb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movups (%rsi), %xmm4
movaps %xmm4, %xmm1
shufps $0x55, %xmm4, %xmm1     # xmm1 = xmm1[1,1],xmm4[1,1]
mulss 0x4(%rdi), %xmm1
movss (%rdi), %xmm2
mulss %xmm4, %xmm2
addss %xmm1, %xmm2
movaps %xmm4, %xmm3
unpckhpd %xmm4, %xmm3            # xmm3 = xmm3[1],xmm4[1]
mulss 0x8(%rdi), %xmm3
addss %xmm2, %xmm3
movaps %xmm4, %xmm5
shufps $0xff, %xmm4, %xmm5     # xmm5 = xmm5[3,3],xmm4[3,3]
mulss 0xc(%rdi), %xmm5
addss %xmm3, %xmm5
xorps %xmm2, %xmm2
ucomiss %xmm5, %xmm2
jbe 0x507e
movaps 0x5fdc(%rip), %xmm2     # 0xb050
xorps %xmm2, %xmm4
movups %xmm4, (%r15)
xorps %xmm2, %xmm5
xorps %xmm1, %xmm1
cvtss2sd %xmm5, %xmm1
ucomisd 0x5f8b(%rip), %xmm1     # 0xb018
jbe 0x50a3
movss 0x5f99(%rip), %xmm1     # 0xb030
subss %xmm0, %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
jmp 0x515b
movaps %xmm0, 0x20(%rsp)
mulss %xmm5, %xmm5
movss 0x5f7c(%rip), %xmm0     # 0xb030
subss %xmm5, %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jb 0x50c6
sqrtss %xmm0, %xmm0
jmp 0x50d5
movsd %xmm1, (%rsp)
callq 0x42a0
movsd (%rsp), %xmm1
movss %xmm0, (%rsp)
cvtss2sd %xmm0, %xmm0
callq 0x40f0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movss %xmm1, 0x1c(%rsp)
movss 0x5f38(%rip), %xmm0     # 0xb030
movaps %xmm0, %xmm2
divss (%rsp), %xmm2
movss %xmm2, (%rsp)
subss 0x20(%rsp), %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4210
movaps %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
movaps %xmm0, (%rsp)
movss 0x1c(%rsp), %xmm0
mulss 0x20(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4210
movaps 0x30(%rsp), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd (%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
cvtpd2ps %xmm0, %xmm1
movups (%r15), %xmm4
movapd %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
mulps %xmm4, %xmm2
movups (%r14), %xmm0
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
mulps %xmm0, %xmm1
addps %xmm2, %xmm1
movups %xmm1, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmPrintMat4
void hpmPrintMat4(const float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    printf("[%f, %f, %f, %f,\n",   m->_11, m->_12, m->_13, m->_14);
    printf(" %f, %f, %f, %f,\n",   m->_21, m->_22, m->_23, m->_24);
    printf(" %f, %f, %f, %f,\n",   m->_31, m->_32, m->_33, m->_34);
    printf(" %f, %f, %f, %f]\n\n", m->_41, m->_42, m->_43, m->_44);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtss2sd (%rdi), %xmm0
cvtss2sd 0x10(%rdi), %xmm1
cvtss2sd 0x20(%rdi), %xmm2
cvtss2sd 0x30(%rdi), %xmm3
leaq 0x5ecf(%rip), %rdi      # 0xb090
movb $0x4, %al
callq 0x4150
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x14(%rbx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x24(%rbx), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0x34(%rbx), %xmm3
leaq 0x5eb3(%rip), %r14      # 0xb0a2
movq %r14, %rdi
movb $0x4, %al
callq 0x4150
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x18(%rbx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x28(%rbx), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0x38(%rbx), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x4150
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x1c(%rbx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x2c(%rbx), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0x3c(%rbx), %xmm3
leaq 0x5e6a(%rip), %rdi      # 0xb0b4
movb $0x4, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmIdentityMat4
void hpmIdentityMat4(float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    memset(m, 0, sizeof(HPMmat4));
    m->_11 = 1.0;
    m->_22 = 1.0;
    m->_33 = 1.0;
    m->_44 = 1.0;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rdi)
movups %xmm0, 0x24(%rdi)
movups %xmm0, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%rdi)
movl %eax, 0x14(%rdi)
movl %eax, 0x28(%rdi)
movl %eax, 0x3c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmXRotation
void hpmXRotation(float rotation, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    float c = cos(rotation);
    float s = sin(rotation);
    m->_11 = 1.0;
    m->_22 = c;
    m->_33 = c;
    m->_23 = -s;
    m->_32 = s;
    m->_44 = 1.0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%rbx)
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x14(%rbx)
movss %xmm1, 0x28(%rbx)
movaps 0x5881(%rip), %xmm1     # 0xb050
xorps %xmm0, %xmm1
movss %xmm1, 0x24(%rbx)
movss %xmm0, 0x18(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateX
void hpmRotateX(float rotation, float *mat){
    if (rotation == 0.0) return;
    float rot[16], r[16];
    hpmXRotation(rotation, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x57f0
jp 0x57f0
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x50(%rsp), %r14
movups %xmm1, 0x4(%r14)
movups %xmm1, 0x14(%r14)
movups %xmm1, 0x24(%r14)
movq $0x0, 0x34(%r14)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%r14)
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x14(%r14)
movss %xmm1, 0x28(%r14)
movaps 0x57e9(%rip), %xmm1     # 0xb050
xorps %xmm0, %xmm1
movss %xmm1, 0x24(%r14)
movss %xmm0, 0x18(%r14)
movl %eax, 0x3c(%r14)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4110
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movaps 0x30(%r15), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmYRotation
void hpmYRotation(float rotation, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    float c = cos(rotation);
    float s = sin(rotation);
    m->_11 = c;
    m->_22 = 1.0;
    m->_33 = c;
    m->_13 = s;
    m->_31 = -s;
    m->_44 = 1.0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%rbx)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x14(%rbx)
movss %xmm1, 0x28(%rbx)
movss %xmm0, 0x20(%rbx)
xorps 0x572a(%rip), %xmm0     # 0xb050
movss %xmm0, 0x8(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateY
void hpmRotateY(float rotation, float *mat){
    if (rotation == 0.0) return;
    float rot[16], r[16];
    hpmYRotation(rotation, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x593f
jp 0x593f
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x50(%rsp), %r14
movups %xmm1, 0x4(%r14)
movups %xmm1, 0x14(%r14)
movups %xmm1, 0x24(%r14)
movq $0x0, 0x34(%r14)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%r14)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x14(%r14)
movss %xmm1, 0x28(%r14)
movss %xmm0, 0x20(%r14)
xorps 0x5694(%rip), %xmm0     # 0xb050
movss %xmm0, 0x8(%r14)
movl %eax, 0x3c(%r14)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4110
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movaps 0x30(%r15), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmZRotation
void hpmZRotation(float rotation, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    float c = cos(rotation);
    float s = sin(rotation);
    m->_11 = c;
    m->_22 = c;
    m->_12 = -s;
    m->_21 = s;
    m->_33 = 1.0;
    m->_44 = 1.0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x28(%rdi)
movups %xmm1, 0x18(%rdi)
movups %xmm1, 0x8(%rdi)
movl $0x0, 0x38(%rdi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%rbx)
movss %xmm1, 0x14(%rbx)
movaps 0x55ec(%rip), %xmm1     # 0xb050
xorps %xmm0, %xmm1
movss %xmm1, 0x10(%rbx)
movss %xmm0, 0x4(%rbx)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateZ
void hpmRotateZ(float rotation, float *mat){
    if (rotation == 0.0) return;
    float rot[16], r[16];
    hpmZRotation(rotation, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x5a8d
jp 0x5a8d
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x50(%rsp), %r14
movups %xmm1, 0x8(%r14)
movups %xmm1, 0x18(%r14)
movups %xmm1, 0x28(%r14)
movl $0x0, 0x38(%r14)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%r14)
movss %xmm1, 0x14(%r14)
movaps 0x5555(%rip), %xmm1     # 0xb050
xorps %xmm0, %xmm1
movss %xmm1, 0x10(%r14)
movss %xmm0, 0x4(%r14)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%r14)
movl %eax, 0x3c(%r14)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4110
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movaps 0x30(%r15), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq