LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/lsmtable_impl.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::getBytes() const
size_t LSMTable<CONTAINER>::getBytes() const{
	size_t result = 0;

	for(const auto &table : container_ )
		result += table.getBytes();

	return result;
}

// Assembly:
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x51d2
addq 0x58(%rcx), %rax
addq $0xe0, %rcx
jmp 0x51c0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/lsmtable_impl.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::getCountEstimated() const
auto LSMTable<CONTAINER>::getCountEstimated() const -> size_type{
	size_type result = 0;

	for(const auto &table : container_ )
		result += table.getCount();

	return result;
}

// Assembly:
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x51f2
addq 0x8(%rcx), %rax
addq $0xe0, %rcx
jmp 0x51e0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/lsmtable_impl.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::get(StringRef const&) const
Pair LSMTable<CONTAINER>::get(const StringRef &key) const{
	// CONTAINER is responsible for ordering the tables,
	// in correct (probably reverse) order.
	for(const auto &table : container_ ){
		if (Pair pair = table.get(key))
			return pair;
	}

	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %rbx, %rdi
cmpq %r12, %r15
je 0x5e1a
movq %r15, %rsi
movq %r14, %rdx
callq 0x7e6e
cmpq $0x0, (%rbx)
jne 0x5e21
movq %rbx, %rdi
callq 0x6f68
addq $0xe0, %r15
jmp 0x5df0
xorl %esi, %esi
callq 0x6fac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/tableloader/directorytableloader.cc
// Function: hm3::tableloader::DirectoryTableLoader::refresh()
bool DirectoryTableLoader::refresh(){
	container_.clear();

	MyGlob gl;
	if (gl.open(path_) == false)
		return true;

	const auto &files = gl.getData();

	container_.reserve(files.size());

	// order in the iterator, does not matter
	// but order in get, still very important
	auto it_rend = files.rend();
	for (auto it = files.rbegin(); it != it_rend; ++it){
		const auto &filename = *it;

                DiskTable dt;
                dt.open(filename);
                container_.push_back( std::move(dt) );
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x67ec
movq %rsp, %rdi
movb $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
andq $0x0, 0x60(%rdi)
movq 0x8(%r14), %rax
leaq 0x68(%rsp), %rsi
movq %rax, (%rsi)
movq (%r14), %rax
movq %rax, 0x8(%rsi)
callq 0x6d20
testb %al, %al
je 0x67ae
movq 0x58(%rsp), %rsi
subq 0x50(%rsp), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x67f4
movq 0x50(%rsp), %r12
movq 0x58(%rsp), %r14
leaq 0x70(%rsp), %r13
xorl %ebp, %ebp
leaq 0x68(%rsp), %r15
cmpq %r12, %r14
je 0x67ae
movb %bpl, 0x68(%rsp)
movb %bpl, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movups %xmm0, 0x28(%r13)
andq $0x0, 0x38(%r13)
movups %xmm0, 0x18(%r13)
andl $0x0, 0x54(%r13)
addq $-0x10, %r14
movups %xmm0, 0x44(%r13)
movl $0x1, 0xcc(%rsp)
movups %xmm0, 0x60(%r13)
andl $0x0, 0xfc(%rsp)
movups %xmm0, 0x74(%r13)
andl $0x0, 0x84(%r13)
movb $0x1, 0x100(%rsp)
movups %xmm0, 0xc8(%r13)
movups %xmm0, 0xb8(%r13)
movups %xmm0, 0xa8(%r13)
movups %xmm0, 0x98(%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x76a4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ac8
movq %r15, %rdi
callq 0x3c92
jmp 0x6707
movq %rsp, %rdi
callq 0x68a0
movb $0x1, %al
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x67dc
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3c92
movq %rsp, %rdi
callq 0x68a0
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]floppytools/kryoflux4.cpp
// Function: main
int main(int argc,char **argv) {
    struct flux_bits fb;
    struct kryoflux_event ev;

    if (argc < 2) {
        fprintf(stderr,"%s <raw>\n",argv[0]);
        return 1;
    }

    FILE *fp = fopen(argv[1],"rb");
    if (fp == NULL) return 1;

    if (!autodetect_flux_bits_mfm(fb,ev,fp)) {
        fprintf(stderr,"Autodetect failure\n");
        return 1;
    }

    /* TODO: autodetection is possible (for MFM at least).
     *       look at the histogram code in kryoflux2.cpp */

    /* from my tests:
     *
     * distance of 10101010101010 = 49
     * change in distance to encode 1001001001001001 = 23.
     *
     * shortest is therefore 49 - 23 = 26 which is the distance to encode 111111111111 */

    fb.clear();

    do {
        kryoflux_bits_refill(fb,ev,fp);

        unsigned int c = fb.avail();
        for (unsigned int i=0;i < c;i++) printf("%u",fb.get(1));

        kryoflux_bits_refill(fb,ev,fp);
    } while (fb.avail() > 0);

    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x50(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
cmpl $0x1, %edi
jle 0x13ac
movq 0x8(%rsi), %rdi
leaq 0x1d1e(%rip), %rsi      # 0x300e
callq 0x1110
pushq $0x1
popq %rbx
testq %rax, %rax
je 0x1392
movq %rax, %r14
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x16f1
testb %al, %al
je 0x13cc
leaq -0x38(%rbp), %rdi
callq 0x166c
leaq -0x38(%rbp), %r15
pushq $0x1
popq %r13
leaq 0x1cf1(%rip), %rbx      # 0x3025
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
movq %r14, %rdx
callq 0x1580
movq %r15, %rdi
callq 0x160a
movl %eax, %r12d
subl $0x1, %r12d
jb 0x136d
movq %r15, %rdi
movl %r13d, %esi
callq 0x16b2
movq %rbx, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
jmp 0x134e
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
movq %r14, %rdx
callq 0x1580
movq %r15, %rdi
callq 0x160a
testl %eax, %eax
jne 0x1334
movq %r14, %rdi
callq 0x10e0
xorl %ebx, %ebx
leaq -0x50(%rbp), %rdi
callq 0x1404
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3c2d(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0x1c44(%rip), %rsi      # 0x3004
xorl %eax, %eax
callq 0x1160
pushq $0x1
popq %rbx
jmp 0x1392
movq 0x3c0d(%rip), %rax      # 0x4fe0
movq (%rax), %rcx
leaq 0x1c34(%rip), %rdi      # 0x3011
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x11b0
jmp 0x1392
jmp 0x13f0
jmp 0x13f0
jmp 0x13f0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1404
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/PrzemekWirkus[P]functional-workshop/src/utest.h
// Function: bool CHECK_EQUAL<int, int>(char const*, int, int)
bool CHECK_EQUAL<int, int>(const char *str, int t1, int t2) {
    using namespace std;

    bool result = t1 == t2;
    if (__NOT result) {
        cout << endl << __FILE__ << ": Value mismatch: " << t1 << " != " << t2 << endl;
    }
    cout << str << "\t" << (result ? "OK" : "FAIL") << endl;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpl %edx, %esi
jne 0x1348
leaq 0xce4(%rip), %r15       # 0x202a
jmp 0x13a5
movq 0x2c89(%rip), %rdi      # 0x3fd8
callq 0x1050
leaq 0xca9(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x10a0
leaq 0xca6(%rip), %rsi       # 0x2010
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x10f0
leaq 0xc9f(%rip), %rsi       # 0x2023
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
movl %ebp, %esi
callq 0x10f0
movq %rax, %rdi
callq 0x1050
leaq 0xc88(%rip), %r15       # 0x202d
cmpl %ebp, %r14d
sete %bpl
movq 0x2c25(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x10a0
leaq 0xc66(%rip), %rsi       # 0x2028
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x10a0
movq %rax, %rdi
callq 0x1050
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/display_test.cpp
// Function: generatePositions(unsigned int*, unsigned int, unsigned int)
usint*
generatePositions(weight_type* weights, usint size, usint number)
{
  DeltaEncoder weight_encoder(2 * sizeof(usint));
  DeltaEncoder pos_encoder(2 * sizeof(usint));
  usint sum = 0;
  for(usint i = 0; i < size; i++)
  {
    if(weights[i] > 0)
    {
      sum += weights[i];
      weight_encoder.addBit(sum);
      pos_encoder.addBit(i);
    }
  }
  weight_encoder.flush();
  pos_encoder.flush();
  DeltaVector weight_vector(weight_encoder, sum);
  DeltaVector pos_vector(pos_encoder, size);

  usint* result = new usint[number];
  DeltaVector::Iterator weight_iter(weight_vector);
  DeltaVector::Iterator pos_iter(pos_vector);
  for(usint i = 0; i < number; i++)
  {
    result[i] = pos_iter.select(weight_iter.rank(rand() % sum));
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movl %edx, 0x4(%rsp)
movl %esi, %ebx
movq %rdi, %r15
leaq 0x108(%rsp), %rdi
pushq $0x8
popq %rbp
movl %ebp, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0xf726
leaq 0x98(%rsp), %rdi
movl %ebp, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0xf726
movl %ebx, %r14d
xorl %r12d, %r12d
leaq 0x98(%rsp), %rbp
xorl %r13d, %r13d
cmpq %r12, %r14
je 0x4367
movl (%r15,%r12,4), %ebx
testl %ebx, %ebx
je 0x435c
addl %r13d, %ebx
leaq 0x108(%rsp), %rdi
movl %ebx, %esi
callq 0xf796
movq %rbp, %rdi
movl %r12d, %esi
callq 0xf796
jmp 0x435f
movl %r13d, %ebx
incq %r12
movl %ebx, %r13d
jmp 0x4330
leaq 0x108(%rsp), %rdi
callq 0xf7a2
leaq 0x98(%rsp), %rdi
callq 0xf7a2
leaq 0x50(%rsp), %rdi
leaq 0x108(%rsp), %rsi
movl %r13d, %edx
callq 0xf430
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
movl %r14d, %edx
callq 0xf430
movl 0x4(%rsp), %ebx
leaq (,%rbx,4), %rdi
callq 0x3030
movq %rax, %r14
leaq 0x1f0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf448
leaq 0x178(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf448
xorl %ebp, %ebp
leaq 0x1f0(%rsp), %r15
leaq 0x178(%rsp), %r12
cmpq %rbp, %rbx
je 0x4423
callq 0x30a0
xorl %edx, %edx
divl %r13d
movq %r15, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xf454
movq %r12, %rdi
movl %eax, %esi
callq 0xf4e6
movl %eax, (%r14,%rbp,4)
incq %rbp
jmp 0x43f5
leaq 0x178(%rsp), %rdi
callq 0xf44e
leaq 0x1f0(%rsp), %rdi
callq 0xf44e
leaq 0x8(%rsp), %rdi
callq 0xf436
leaq 0x50(%rsp), %rdi
callq 0xf436
leaq 0x98(%rsp), %rdi
callq 0xf72e
leaq 0x108(%rsp), %rdi
callq 0xf72e
movq %r14, %rax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x44af
jmp 0x4487
movq %rax, %rbx
jmp 0x44bc
movq %rax, %rbx
jmp 0x44c6
jmp 0x449a
movq %rax, %rbx
jmp 0x44dd
jmp 0x449a
movq %rax, %rbx
jmp 0x44d0
movq %rax, %rbx
leaq 0x178(%rsp), %rdi
callq 0xf44e
leaq 0x1f0(%rsp), %rdi
callq 0xf44e
leaq 0x8(%rsp), %rdi
callq 0xf436
leaq 0x50(%rsp), %rdi
callq 0xf436
leaq 0x98(%rsp), %rdi
callq 0xf72e
leaq 0x108(%rsp), %rdi
callq 0xf72e
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::~HasPtr()
HasPtr::~HasPtr()
{
	std::cout << "deconstructor." << std::endl;
	if (--*use == 0) {   // if the reference count goes to 0
		std::cout << "delete memory." << std::endl;
		delete ps;       // delete the string
		delete use;      // and the counter
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2d9b(%rip), %rdi      # 0x3fd8
leaq 0xdc0(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, %rdi
callq 0x1070
movq 0x10(%rbx), %rax
decq (%rax)
je 0x125f
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2d72(%rip), %rdi      # 0x3fd8
leaq 0xda6(%rip), %rsi       # 0x2013
callq 0x1090
movq %rax, %rdi
callq 0x1070
movq (%rbx), %r14
testq %r14, %r14
je 0x128a
movq %r14, %rdi
callq 0x1060
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x10b0
movq 0x10(%rbx), %rdi
pushq $0x8
popq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x10b0
movq %rax, %rdi
callq 0x14ce
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::operator=(HasPtr&&)
HasPtr& HasPtr::operator=(HasPtr&& rhs)
{
	std::cout << "move assign." << std::endl;
	if (this != &rhs) {
		if (--*use == 0) {   // do the work of the destructor
			delete ps;
			delete use;
		}
		ps = rhs.ps;         // do the work of the move constructor
		i = rhs.i;
		use = rhs.use;

		rhs.ps = nullptr;
		++*rhs.use;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2d13(%rip), %rdi      # 0x3fd8
leaq 0xd56(%rip), %rsi       # 0x2022
callq 0x1090
movq %rax, %rdi
callq 0x1070
cmpq %r14, %rbx
je 0x132a
movq 0x10(%rbx), %rax
decq (%rax)
jne 0x130e
movq (%rbx), %r15
testq %r15, %r15
je 0x12f7
movq %r15, %rdi
callq 0x1060
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x10b0
movq 0x10(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x10b0
movq (%r14), %rax
movq %rax, (%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
andq $0x0, (%r14)
incq (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::operator=(HasPtr const&)
HasPtr& HasPtr::operator=(const HasPtr& rhs)
{
	std::cout << "copy assign." << std::endl;
	++*rhs.use;  // increment the use count of the right-hand operand
	if (--*use == 0) {   // then decrement this object's counter
		delete ps;       // if no other users
		delete use;      // free this object's allocated members
	}
	ps = rhs.ps;         // copy data from rhs into this object
	i = rhs.i;
	use = rhs.use;
	return *this;        // return this object
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2c89(%rip), %rdi      # 0x3fd8
leaq 0xcd9(%rip), %rsi       # 0x202f
callq 0x1090
movq %rax, %rdi
callq 0x1070
movq 0x10(%r14), %rax
incq (%rax)
movq 0x10(%rbx), %rcx
decq (%rcx)
jne 0x139e
movq (%rbx), %r15
testq %r15, %r15
je 0x1383
movq %r15, %rdi
callq 0x1060
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x10b0
movq 0x10(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x10b0
movq 0x10(%r14), %rax
movq (%r14), %rcx
movq %rcx, (%rbx)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: f(HasPtr)
HasPtr f(HasPtr hp) // HasPtr passed by value, so it is copied
{
	HasPtr ret;
	ret = hp;        // assignment copies the given HasPtr
	// proces ret
	return ret;      // ret and hp are destroyed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x30(%rbp), %rsi
callq 0x14dc
leaq -0x30(%rbp), %rdi
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1338
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x122c
jmp 0x1420
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x1060
movq %r14, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: main
int main()
{
	HasPtr h("hi mom!");

	// no new memory is allocated,
	// h and h2 share the same underlying string
	HasPtr h2 = h;

	HasPtr h3 = std::move(h2);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq 0xc04(%rip), %rsi       # 0x203c
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x1040
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14dc
leaq -0x28(%rbp), %rdi
callq 0x1060
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1558
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x159e
leaq -0x58(%rbp), %rdi
callq 0x122c
leaq -0x28(%rbp), %rdi
callq 0x122c
leaq -0x40(%rbp), %rdi
callq 0x122c
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x122c
jmp 0x14aa
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x122c
jmp 0x14c6
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1060
jmp 0x14c6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/fact.cc
// Function: main
int main()
{
	cout << factorial(5) << endl;
	cout << fact(5) << endl;
	cout << factorial(0) << endl;
	cout << fact(0) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $0x5
popq %r14
movl %r14d, %edi
callq 0x125a
movq 0x2e12(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movl %eax, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movl %r14d, %edi
callq 0x1243
movq %rbx, %rdi
movl %eax, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x125a
movq %rbx, %rdi
movl %eax, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1243
movq %rbx, %rdi
movl %eax, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/LocalMath.cc
// Function: gcd(int, int)
int gcd(int v1, int v2)
{
    while (v2) {
        int temp = v2;
        v2 = v1 % v2;
        v1 = temp;
    }
    return v1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %edx
movl %edi, %eax
testl %edx, %edx
je 0x1241
movl %edx, %ecx
cltd
idivl %ecx
movl %ecx, %eax
jmp 0x1234
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/LocalMath.cc
// Function: fact(int)
int fact(int val)
{
	int ret = 1; // local variable to hold the result as we calculate it
	while (val > 1) 
		ret *= val--;  // assign ret * val to ret and decrement val
	return ret;        // return the result
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpl $0x2, %edi
jl 0x1258
imull %edi, %eax
decl %edi
jmp 0x124c
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH04_Expressions/examples/unaryOps.cc
// Function: main
int main()
{
	int i = 1024;
	int k = -i; // i is -1024
	
	bool b = true;
	bool b2 = -b; // b2 is true!
	
	cout << b << " " << b2 << " " << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2e0e(%rip), %rdi      # 0x3fd8
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1070
leaq 0xe29(%rip), %r14       # 0x2004
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/convert.cpp
// Function: IntToString[abi:cxx11](int const&)
string IntToString(const int& value) {

    string str;
    int tmp = value;
    bool negate_flag = false;

    if(tmp < 0) {
        negate_flag = true;
        tmp = -tmp;
    }

    if(tmp == 0) {
        str.insert(0, 1, '0');
    } else {
        while(tmp > 0) {
            char c = (tmp % 10) + '0';
            str.insert(0, 1, c);
            tmp /= 10;
        }
    }

    if(negate_flag) {
        str.insert(0, 1, '-');
    }

    return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl (%rsi), %r15d
testl %r15d, %r15d
je 0x12b2
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
pushq $0xa
popq %r12
pushq $0x1
popq %r14
testl %ebp, %ebp
je 0x12a9
movl %ebp, %eax
xorl %edx, %edx
divl %r12d
orb $0x30, %dl
movzbl %dl, %ecx
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x10e0
jmp 0x1287
testl %r15d, %r15d
jns 0x12c4
movb $0x2d, %al
jmp 0x12b4
movb $0x30, %al
movzbl %al, %ecx
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10e0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/inc/stringproc.h
// Function: tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters )
{
	// Skip delimiters at beginning.
    std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    std::string::size_type pos     = str.find_first_of(delimiters, lastPos);

    while (std::string::npos != pos || std::string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
xorl %edx, %edx
callq 0x21f0
movq %rax, %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2210
movq %rax, %r13
leaq 0x8(%rsp), %r12
movq %rbp, %rax
andq %r13, %rax
cmpq $-0x1, %rax
je 0x258d
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x22a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x39f4
movq %r12, %rdi
callq 0x2120
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x21f0
movq %rax, %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2210
movq %rax, %r13
jmp 0x2536
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/inc/main.h
// Function: vertex_shader_interface(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<unsigned long long, std::allocator<unsigned long long>>*)
void vertex_shader_interface(std::string fileName, 
	std::vector<unsigned long long int > *vertexShader )
{
	// Opening file
	std::ifstream myFile;
	myFile.open(fileName.data());

	// Read file into vector for easier processing
	std::vector<std::string> data;
	std::string line;
	while( myFile.good() )
	{
		getline(myFile, line);
		line[line.length()] = '\0';
		data.push_back(line);
	}

	myFile.close();

	for ( auto i : data )
	{
		vertexShader->push_back(stoull(i,0,0));
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x22b0
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x21a0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movaps %xmm0, (%r14)
movb $0x0, (%rax)
leaq 0x68(%rsp), %r15
leaq 0x28(%rsp), %r12
movq 0x68(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x88(%rsp,%rax)
jne 0x2b62
movq %r15, %rdi
movq %r12, %rsi
callq 0x20a0
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x33c8
jmp 0x2b29
leaq 0x68(%rsp), %rdi
callq 0x20b0
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r13
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq %r13, %r14
je 0x2bba
movq %r15, %rdi
movq %r14, %rsi
callq 0x22e0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x34dd
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45c4
movq %r15, %rdi
callq 0x2120
addq $0x20, %r14
jmp 0x2b80
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0x10(%rsp), %rdi
callq 0x34bc
leaq 0x68(%rsp), %rdi
callq 0x20c0
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2c01
movq %rax, %rbx
jmp 0x2c18
jmp 0x2c01
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2120
jmp 0x2c04
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0x10(%rsp), %rdi
callq 0x34bc
leaq 0x68(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/inc/main.h
// Function: constant_file_interface(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<float, std::allocator<float>>*)
void constant_file_interface(std::string fileName,
	std::vector<float> *constants)
{
	// Opening file
	std::ifstream myFile;
	myFile.open(fileName.data());

	// Read file into vector for easier processing
	std::vector<std::string> data;
	std::string line;
	while( myFile.good() )
	{
		getline(myFile, line);
		line[line.length()] = '\0';
		data.push_back(line);
	}

	myFile.close();

	// Tokenize data
	std::string delims = " \t\n,";
	std::vector<std::string> tempData;

	// Store tokenized data into tempData
	for ( auto i : data )
	{
		tokenize(i, tempData, delims);
	}

	for ( auto i : tempData )
	{
		constants->push_back(std::stof(i));
	}		
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
callq 0x22b0
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x21a0
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r14
andq $0x0, 0x10(%r14)
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movaps %xmm0, (%r14)
movb $0x0, (%rax)
leaq 0xb0(%rsp), %r15
leaq 0x50(%rsp), %r12
movq 0xb0(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0xd0(%rsp,%rax)
jne 0x2cca
movq %r15, %rdi
movq %r12, %rsi
callq 0x20a0
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x33c8
jmp 0x2c8e
leaq 0xb0(%rsp), %rdi
callq 0x20b0
leaq 0x536f(%rip), %rsi      # 0x804d
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x3404
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %rbp
leaq 0x70(%rsp), %r12
leaq 0x90(%rsp), %r13
cmpq %rbp, %r15
je 0x2d44
movq %r12, %rdi
movq %r15, %rsi
callq 0x22e0
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x24fc
movq %r12, %rdi
callq 0x2120
addq $0x20, %r15
jmp 0x2d18
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r13
leaq 0x70(%rsp), %r15
leaq 0xc(%rsp), %r12
cmpq %r13, %r14
je 0x2d91
movq %r15, %rdi
movq %r14, %rsi
callq 0x22e0
movq %r15, %rdi
xorl %esi, %esi
callq 0x34f9
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3e10
movq %r15, %rdi
callq 0x2120
addq $0x20, %r14
jmp 0x2d58
leaq 0x10(%rsp), %rdi
callq 0x34bc
leaq 0x90(%rsp), %rdi
callq 0x2120
leaq 0x50(%rsp), %rdi
callq 0x2120
leaq 0x30(%rsp), %rdi
callq 0x34bc
leaq 0xb0(%rsp), %rdi
callq 0x20c0
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e13
jmp 0x2e13
movq %rax, %rbx
jmp 0x2e2a
jmp 0x2de6
movq %rax, %rbx
jmp 0x2dfa
jmp 0x2ded
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2120
leaq 0x10(%rsp), %rdi
callq 0x34bc
leaq 0x90(%rsp), %rdi
callq 0x2120
jmp 0x2e16
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2120
leaq 0x30(%rsp), %rdi
callq 0x34bc
leaq 0xb0(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/inc/screen.h
// Function: init_screen()
bool init_screen() {

	// Initialization flag
	bool success = true;

	// Initialize SDL
	if (SDL_Init( SDL_INIT_VIDEO) < 0) {
		printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
		success = false;
	}
	else {

		//Set texture filtering to linear
		if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
		{
			printf( "Warning: Linear texture filtering not enabled!" );
		}

		// Create window
		gWindow = SDL_CreateWindow("GPU", SDL_WINDOWPOS_UNDEFINED,
			SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );

		if (gWindow == NULL) {
			printf("Window could not created! SDL_Error: %s\n", SDL_GetError());
			success = false;
		}
		else {

			// Create renderer for window
			gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED);
			if ( gRenderer == NULL ) {
				printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
				success = false;
			}
			else {
				// Initialize renderer color
				SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			}
		}
	}

	return success;
}

// Assembly:
pushq %rbx
pushq $0x20
popq %rdi
callq 0x2230
testl %eax, %eax
js 0x2ed5
leaq 0x5224(%rip), %rdi      # 0x807b
leaq 0x5236(%rip), %rsi      # 0x8094
callq 0x2370
testl %eax, %eax
jne 0x2e75
leaq 0x5228(%rip), %rdi      # 0x8096
xorl %eax, %eax
callq 0x2060
leaq 0x5249(%rip), %rdi      # 0x80c5
pushq $0x4
popq %r9
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x320, %ecx            # imm = 0x320
movl $0x280, %r8d            # imm = 0x280
callq 0x2070
movq %rax, 0x935f(%rip)      # 0xc200
testq %rax, %rax
je 0x2ee3
pushq $-0x1
popq %rsi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x2040
movq %rax, 0x9355(%rip)      # 0xc210
testq %rax, %rax
je 0x2ef1
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x22f0
movb $0x1, %bl
jmp 0x2f09
callq 0x21c0
leaq 0x5171(%rip), %rdi      # 0x8052
jmp 0x2efd
callq 0x21c0
leaq 0x51da(%rip), %rdi      # 0x80c9
jmp 0x2efd
callq 0x21c0
leaq 0x51f5(%rip), %rdi      # 0x80f2
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x2060
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/inc/screen.h
// Function: thread_screen(unsigned char (*) [800][3])
void thread_screen( unsigned char FB[][SCREEN_WIDTH][3])
{
	// Event handler
	SDL_Event e;

	// Accessing each byte in vram
	int x, y;

	// Start up SDL and create window
	if ( !init_screen() ) {
		std::cout << "Failed to Initialize!\n";
	}
	else {
		// While application is running
		while( !m_quit ) {

			// Handle events on queue
			while( SDL_PollEvent(&e) != 0) {
				// User requests quit
				if ( e.type == SDL_QUIT ) { m_quit = true; }
			}

			// Clear screen
			SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			SDL_RenderClear( gRenderer );

			// Render to screen given frame buffer
			for (y = 0; y < SCREEN_HEIGHT; y++) {
				for (x = 0; x < SCREEN_WIDTH; x++) {

					// Render pixel
					SDL_Rect pixel = { x, y, 1, 1};

					// Draw to the screen
					SDL_SetRenderDrawColor( gRenderer, 
							FB[y][x][0], 
							FB[y][x][1], 
							FB[y][x][2], 
							255
						);
					SDL_RenderFillRect( gRenderer, &pixel );
				}
			}

			// Update screen
			SDL_RenderPresent( gRenderer );
		}

		// Free resources and close SDL
		close_sdl();
		
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x2e3f
testb %al, %al
je 0x303c
addq $0x2, %rbx
leaq 0x20(%rsp), %r14
movabsq $0x100000001, %r12      # imm = 0x100000001
leaq 0x10(%rsp), %r15
movq %rbx, 0x8(%rsp)
cmpb $0x0, 0x928b(%rip)      # 0xc1f9
jne 0x305d
movq %r14, %rdi
callq 0x2180
testl %eax, %eax
je 0x2f93
cmpl $0x100, 0x20(%rsp)      # imm = 0x100
jne 0x2f74
movb $0x1, 0x9268(%rip)      # 0xc1f9
jmp 0x2f74
movq 0x9276(%rip), %rdi      # 0xc210
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x22f0
movq 0x9261(%rip), %rdi      # 0xc210
callq 0x2260
xorl %ebp, %ebp
cmpq $0x280, %rbp            # imm = 0x280
je 0x3021
movq %rbx, %r13
xorl %r14d, %r14d
cmpq $0x320, %r14            # imm = 0x320
je 0x3015
movl %r14d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r12, 0x18(%rsp)
movq 0x922d(%rip), %rdi      # 0xc210
movzbl -0x2(%r13), %esi
movzbl -0x1(%r13), %edx
movzbl (%r13), %ecx
movl $0xff, %r8d
callq 0x22f0
movq 0x920c(%rip), %rdi      # 0xc210
movq %r15, %rsi
callq 0x2150
incq %r14
addq $0x3, %r13
jmp 0x2fc5
incq %rbp
addq $0x960, %rbx            # imm = 0x960
jmp 0x2fb6
movq 0x91e8(%rip), %rdi      # 0xc210
callq 0x2090
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %r14
jmp 0x2f67
movq 0x8f7d(%rip), %rdi      # 0xbfc0
leaq 0x50d6(%rip), %rsi      # 0x8120
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2270
callq 0x2f0d
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::load_const_mem(std::vector<float, std::allocator<float>>)
void gpu::load_const_mem(vector<float> constants)
{
	// Load this baby up.
	int index = 0;
	for ( int i = 0; i < constants.size(); i += 4 )
	{
		main_mem[CONST_REG][index].x = constants[i];
		main_mem[CONST_REG][index].y = constants[i+1];
		main_mem[CONST_REG][index].z = constants[i+2];
		main_mem[CONST_REG][index].w = constants[i+3];
		index++;
	}
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
jbe 0x4a8e
movss (%rax,%rdx,4), %xmm0
movss %xmm0, 0x7d8cc(%rdi,%rdx,4)
movss 0x4(%rax,%rdx,4), %xmm0
movss %xmm0, 0x7d8c8(%rdi,%rdx,4)
movss 0x8(%rax,%rdx,4), %xmm0
movss %xmm0, 0x7d8c4(%rdi,%rdx,4)
movss 0xc(%rax,%rdx,4), %xmm0
movss %xmm0, 0x7d8c0(%rdi,%rdx,4)
addq $0x4, %rdx
jmp 0x4a48
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::mov_instr(unsigned long long)
void gpu::mov_instr(u64 instr)
{

	u128 temp;

	// Determine destination and source paths
	u8 dest = get_dest_type(instr);
	u8 destIndex = get_dest_index(instr);
	u8 destW = get_dest_w(instr);
	u8 destZ = get_dest_z(instr);
	u8 destY = get_dest_y(instr);
	u8 destX = get_dest_x(instr);

	u8 src = get_srcN_type(instr, 0);
	u8 srcIndex = get_srcN_index(instr, 0);
	u8 srcW = get_srcN_w(instr, 0);
	u8 srcZ = get_srcN_z(instr, 0);
	u8 srcY = get_srcN_y(instr, 0);
	u8 srcX = get_srcN_x(instr, 0);

	// Swizzle it
	temp = swizzle(main_mem[src][srcIndex], srcW, srcZ, srcY, srcX);

	// Negate it
	if (get_srcN_neg(instr, 0))
	{
		temp.x = -temp.x;
		temp.y = -temp.y;
		temp.z = -temp.z;
		temp.w = -temp.w;
	}

	// Bop it..
	if ( dest == TEMP_REG )
	{
		if (destW) main_mem[dest][destIndex].w = temp.w;
		if (destZ) main_mem[dest][destIndex].z = temp.z;
		if (destY) main_mem[dest][destIndex].y = temp.y;
		if (destX) main_mem[dest][destIndex].x = temp.x;
	}
	else
	{
		if (destW) VOB[destIndex].w = temp.w;
		if (destZ) VOB[destIndex].z = temp.z;
		if (destY) VOB[destIndex].y = temp.y;
		if (destX) VOB[destIndex].x = temp.x;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %r15
shrq $0x34, %r15
andl $0xf, %r15d
movq %rsi, %rbp
shrq $0x32, %rbp
movq %rsi, %r13
shrq $0x31, %r13
movq %rsi, %r12
shrq $0x30, %r12
movq %rsi, %rax
shrq $0x2d, %rax
andl $0x3, %eax
movq %rsi, %rdi
shrq $0x29, %rdi
andl $0xf, %edi
shrq $0x27, %rsi
movq %r14, %rdx
shrq $0x25, %rdx
movq %r14, %rcx
shrq $0x23, %rcx
movq %r14, %r8
shrq $0x21, %r8
shll $0x8, %eax
addq %rbx, %rax
addq $0x7d6c0, %rax          # imm = 0x7D6C0
shll $0x4, %edi
movsd (%rdi,%rax), %xmm0
movsd 0x8(%rdi,%rax), %xmm1
andl $0x3, %esi
andl $0x3, %edx
andl $0x3, %ecx
andl $0x3, %r8d
callq 0x775c
btq $0x2f, %r14
jae 0x4c7a
movaps 0x35ec(%rip), %xmm2     # 0x8260
xorps %xmm2, %xmm1
xorps %xmm2, %xmm0
btq $0x38, %r14
jb 0x4cd9
addq $0x7d6c0, %rbx          # imm = 0x7D6C0
btq $0x33, %r14
jae 0x4c9a
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, (%rbx,%rax)
testb $0x1, %bpl
je 0x4cb0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, 0x4(%rbx,%rax)
testb $0x1, %r13b
je 0x4cc2
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x8(%rbx,%rax)
testb $0x1, %r12b
je 0x4d35
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
shll $0x4, %r15d
movss %xmm1, 0xc(%rbx,%r15)
jmp 0x4d35
btq $0x33, %r14
jae 0x4cef
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, 0x7dec0(%rbx,%rax)
testb $0x1, %bpl
je 0x4d08
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, 0x7dec4(%rbx,%rax)
testb $0x1, %r13b
je 0x4d1d
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec8(%rbx,%rax)
testb $0x1, %r12b
je 0x4d35
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
shll $0x4, %r15d
movss %xmm1, 0x7decc(%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::rcp_instr(unsigned long long)
void gpu::rcp_instr(u64 instr)
{
	u128 temp;

	// Determine destination and source paths
	u8 dest = get_dest_type(instr);
	u8 destIndex = get_dest_index(instr);
	u8 destW = get_dest_w(instr);
	u8 destZ = get_dest_z(instr);
	u8 destY = get_dest_y(instr);
	u8 destX = get_dest_x(instr);

	u8 src = get_srcN_type(instr, 0);
	u8 srcIndex = get_srcN_index(instr, 0);
	u8 srcW = get_srcN_w(instr, 0);
	u8 srcZ = get_srcN_z(instr, 0);
	u8 srcY = get_srcN_y(instr, 0);
	u8 srcX = get_srcN_x(instr, 0);

	// Swizzle it
	temp = swizzle(main_mem[src][srcIndex], srcW, srcZ, srcY, srcX);

	if (get_srcN_neg(instr, 0))
	{
		temp.x = -temp.x;
	}

	if ( temp.x == 1.0 )
		temp.x = 1;
	else {
		temp.x = 1.0 / temp.x;
	}

	// Bop it..
	if ( dest == TEMP_REG )
	{
		if (destW) main_mem[dest][destIndex].w = temp.x;
		if (destZ) main_mem[dest][destIndex].z = temp.x;
		if (destY) main_mem[dest][destIndex].y = temp.x;
		if (destX) main_mem[dest][destIndex].x = temp.x;
	}
	else
	{
		if (destW) VOB[destIndex].w = temp.x;
		if (destZ) VOB[destIndex].z = temp.x;
		if (destY) VOB[destIndex].y = temp.x;
		if (destX) VOB[destIndex].x = temp.x;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %r15
shrq $0x34, %r15
andl $0xf, %r15d
movq %rsi, %rbp
shrq $0x32, %rbp
movq %rsi, %r13
shrq $0x31, %r13
movq %rsi, %r12
shrq $0x30, %r12
movq %rsi, %rax
shrq $0x2d, %rax
andl $0x3, %eax
movq %rsi, %rdi
shrq $0x29, %rdi
andl $0xf, %edi
shrq $0x27, %rsi
movq %r14, %rdx
shrq $0x25, %rdx
movq %r14, %rcx
shrq $0x23, %rcx
movq %r14, %r8
shrq $0x21, %r8
shll $0x8, %eax
addq %rbx, %rax
addq $0x7d6c0, %rax          # imm = 0x7D6C0
shll $0x4, %edi
movsd (%rdi,%rax), %xmm0
movsd 0x8(%rdi,%rax), %xmm1
andl $0x3, %esi
andl $0x3, %edx
andl $0x3, %ecx
andl $0x3, %r8d
callq 0x775c
btq $0x2f, %r14
jae 0x61ca
xorps 0x2096(%rip), %xmm1     # 0x8260
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss 0x211a(%rip), %xmm0     # 0x82f0
movaps %xmm0, %xmm2
divss %xmm1, %xmm2
cmpeqss %xmm0, %xmm1
movaps %xmm1, %xmm3
andnps %xmm2, %xmm3
andps %xmm0, %xmm1
orps %xmm3, %xmm1
btq $0x38, %r14
jb 0x6246
addq $0x7d6c0, %rbx          # imm = 0x7D6C0
btq $0x33, %r14
jae 0x620e
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, (%rbx,%rax)
testb $0x1, %bpl
je 0x6220
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x4(%rbx,%rax)
testb $0x1, %r13b
je 0x6232
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x8(%rbx,%rax)
testb $0x1, %r12b
je 0x629e
shll $0x4, %r15d
leaq (%rbx,%r15), %rax
addq $0xc, %rax
jmp 0x629a
btq $0x33, %r14
jae 0x625c
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec0(%rbx,%rax)
testb $0x1, %bpl
je 0x6271
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec4(%rbx,%rax)
testb $0x1, %r13b
je 0x6286
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec8(%rbx,%rax)
testb $0x1, %r12b
je 0x629e
shll $0x4, %r15d
leaq (%rbx,%r15), %rax
addq $0x7decc, %rax          # imm = 0x7DECC
movss %xmm1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::projection(__u128*)
void gpu::projection(u128 *VOB)
{
	// Project V1
	VOB[0].x = ( ( ( VOB[0].x/4 ) + 1 ) / 2 ) * SCREEN_WIDTH;
	VOB[0].y = ( ( ( (-VOB[0].y)/4 ) + 1 ) / 2 ) * SCREEN_HEIGHT;
	VOB[0].z = ( ( ( VOB[0].z/4 ) + 1 ) / 2 ) * SCREEN_DEPTH;

	// Project V2
	VOB[1].x = ( ( ( VOB[1].x/4 ) + 1 ) / 2 ) * SCREEN_WIDTH;
	VOB[1].y = ( ( ( (-VOB[1].y)/4 ) + 1 ) / 2 ) * SCREEN_HEIGHT;
	VOB[1].z = ( ( ( VOB[1].z/4 ) + 1 ) / 2 ) * SCREEN_DEPTH;

	// Project V3
	VOB[2].x = ( ( ( VOB[2].x/4 ) + 1 ) / 2 ) * SCREEN_WIDTH;
	VOB[2].y = ( ( ( (-VOB[2].y)/4 ) + 1 ) / 2 ) * SCREEN_HEIGHT;
	VOB[2].z = ( ( ( VOB[2].z/4 ) + 1 ) / 2 ) * SCREEN_DEPTH;
}

// Assembly:
movss 0x1592(%rip), %xmm1     # 0x82fc
movss 0xc(%rsi), %xmm2
mulss %xmm1, %xmm2
movss 0x1575(%rip), %xmm0     # 0x82f0
addss %xmm0, %xmm2
movss 0x1579(%rip), %xmm3     # 0x8300
mulss %xmm3, %xmm2
movss 0x1571(%rip), %xmm4     # 0x8304
mulss %xmm4, %xmm2
movss %xmm2, 0xc(%rsi)
movaps 0x14fd(%rip), %xmm6     # 0x82a0
movsd 0x4(%rsi), %xmm7
movsd 0x14(%rsi), %xmm9
movsd 0x24(%rsi), %xmm5
mulps %xmm6, %xmm7
movaps 0x14f3(%rip), %xmm2     # 0x82b0
movaps %xmm2, %xmm10
subps %xmm7, %xmm10
addps %xmm0, %xmm7
shufps $0x1, %xmm7, %xmm10     # xmm10 = xmm10[1,0],xmm7[0,0]
shufps $0xe2, %xmm7, %xmm10    # xmm10 = xmm10[2,0],xmm7[2,3]
movaps 0x14e7(%rip), %xmm7     # 0x82c0
mulps %xmm7, %xmm10
movsd 0x14ea(%rip), %xmm8     # 0x82d0
mulps %xmm8, %xmm10
movlps %xmm10, 0x4(%rsi)
movss 0x1c(%rsi), %xmm10
mulss %xmm1, %xmm10
addss %xmm0, %xmm10
mulss %xmm3, %xmm10
mulss %xmm4, %xmm10
movss %xmm10, 0x1c(%rsi)
mulps %xmm6, %xmm9
movaps %xmm2, %xmm10
subps %xmm9, %xmm10
addps %xmm0, %xmm9
shufps $0x1, %xmm9, %xmm10     # xmm10 = xmm10[1,0],xmm9[0,0]
shufps $0xe2, %xmm9, %xmm10    # xmm10 = xmm10[2,0],xmm9[2,3]
mulps %xmm7, %xmm10
mulps %xmm8, %xmm10
movlps %xmm10, 0x14(%rsi)
mulss 0x2c(%rsi), %xmm1
addss %xmm0, %xmm1
mulss %xmm3, %xmm1
mulss %xmm4, %xmm1
movss %xmm1, 0x2c(%rsi)
mulps %xmm6, %xmm5
addps %xmm5, %xmm0
subps %xmm5, %xmm2
shufps $0x1, %xmm0, %xmm2      # xmm2 = xmm2[1,0],xmm0[0,0]
shufps $0xe2, %xmm0, %xmm2     # xmm2 = xmm2[2,0],xmm0[2,3]
mulps %xmm7, %xmm2
mulps %xmm8, %xmm2
movlps %xmm2, 0x24(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getXMin(__u128*)
int gpu::getXMin(u128 v[])
{
	int min = v[0].x;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].x < min)
			min = v[i].x;
	}	

	return min;
}

// Assembly:
cvttss2si 0xc(%rsi), %eax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x7051
movss 0x1c(%rsi,%rcx), %xmm0
cvtsi2ss %eax, %xmm1
ucomiss %xmm0, %xmm1
cvttss2si %xmm0, %edx
cmoval %edx, %eax
addq $0x10, %rcx
jmp 0x7031
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getXMax(__u128*)
int gpu::getXMax(u128 v[])
{
	int max = v[0].x;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].x > max)
			max = v[i].x;
	}	

	return max;
}

// Assembly:
cvttss2si 0xc(%rsi), %eax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x7079
movss 0x1c(%rsi,%rcx), %xmm0
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
cvttss2si %xmm0, %edx
cmoval %edx, %eax
addq $0x10, %rcx
jmp 0x7059
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getYMin(__u128*)
int gpu::getYMin(u128 v[])
{
	int min = v[0].y;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].y < min)
			min = v[i].y;
	}	

	return min;
}

// Assembly:
cvttss2si 0x8(%rsi), %eax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x70a1
movss 0x18(%rsi,%rcx), %xmm0
cvtsi2ss %eax, %xmm1
ucomiss %xmm0, %xmm1
cvttss2si %xmm0, %edx
cmoval %edx, %eax
addq $0x10, %rcx
jmp 0x7081
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getYMax(__u128*)
int gpu::getYMax(u128 v[])
{
	int max = v[0].y;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].y > max)
			max = v[i].y;
	}	

	return max;
}

// Assembly:
cvttss2si 0x8(%rsi), %eax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x70c9
movss 0x18(%rsi,%rcx), %xmm0
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
cvttss2si %xmm0, %edx
cmoval %edx, %eax
addq $0x10, %rcx
jmp 0x70a9
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getZ(__u128*, int, int)
int gpu::getZ(u128 v[], int x, int y)
{
	// if all z's same return one of them
	if (v[0].z == v[1].z && v[1].z == v[2].z)
		return v[0].z;

	// if not, then do calculations
	// plane equation
	return
	( -((v[0].z*( v[1].x - v[2].x )+
		   v[1].z*( v[2].x - v[0].x )+
		   v[2].z*( v[0].x - v[1].x)) * x +
	
		  (v[0].y*( v[1].z - v[2].z )+
		   v[1].y*( v[2].z - v[0].z )+
		   v[2].y*( v[0].z - v[1].z)) * y) /

		(v[0].x*( v[1].y - v[2].y )+
		   v[1].x*( v[2].y - v[0].y )+
		   v[2].x*( v[0].y - v[1].y))

	);

}

// Assembly:
movss 0x4(%rsi), %xmm0
movss 0x14(%rsi), %xmm4
ucomiss %xmm4, %xmm0
movss 0x24(%rsi), %xmm1
jne 0x7117
jp 0x7117
ucomiss %xmm1, %xmm4
jne 0x7117
jnp 0x71d9
movss 0x1c(%rsi), %xmm3
movss 0x2c(%rsi), %xmm7
movaps %xmm3, %xmm6
subss %xmm7, %xmm6
movss 0x8(%rsi), %xmm2
movss 0xc(%rsi), %xmm5
mulss %xmm0, %xmm6
movaps %xmm5, %xmm8
subss %xmm3, %xmm8
mulss %xmm1, %xmm8
movaps %xmm4, %xmm9
subss %xmm1, %xmm9
movss 0x18(%rsi), %xmm10
subss %xmm0, %xmm1
mulss %xmm2, %xmm9
movss 0x28(%rsi), %xmm11
subss %xmm4, %xmm0
mulss %xmm11, %xmm0
movaps %xmm10, %xmm12
subss %xmm11, %xmm12
subss %xmm2, %xmm11
subss %xmm10, %xmm2
mulss %xmm7, %xmm2
subss %xmm5, %xmm7
mulss %xmm4, %xmm7
addss %xmm7, %xmm6
addss %xmm6, %xmm8
cvtsi2ss %edx, %xmm4
mulss %xmm8, %xmm4
mulss %xmm10, %xmm1
cvtsi2ss %ecx, %xmm6
addss %xmm1, %xmm9
addss %xmm9, %xmm0
mulss %xmm0, %xmm6
addss %xmm4, %xmm6
xorps 0x10a2(%rip), %xmm6     # 0x8260
mulss %xmm3, %xmm11
mulss %xmm5, %xmm12
addss %xmm11, %xmm12
addss %xmm12, %xmm2
divss %xmm2, %xmm6
movaps %xmm6, %xmm0
cvttss2si %xmm0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::swizzle(__u128, unsigned char, unsigned char, unsigned char, unsigned char)
u128 gpu::swizzle(u128 data, u8 w, u8 z, u8 y, u8 x)
{
	// No swizzle 
	if (w == 3 && z == 2 && y == 1 && x == 0)
		return data;

	u32 temp[4];

	// Tear apart all componets, put them in array..
	temp[0] = data.x;
	temp[1] = data.y;
	temp[2] = data.z;
	temp[3] = data.w;

	data.x = temp[x];
	data.y = temp[y];
	data.z = temp[z];
	data.w = temp[w];

	return data;
}

// Assembly:
movl %esi, %eax
xorb $0x3, %al
movl %edx, %edi
xorb $0x2, %dil
orb %al, %dil
movl %ecx, %eax
xorb $0x1, %al
orb %dil, %al
orb %r8b, %al
je 0x78bb
cvttss2si %xmm1, %rax
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
movss 0xb7b(%rip), %xmm2      # 0x8308
cvttss2si %xmm3, %rdi
subss %xmm2, %xmm3
cvttss2si %xmm3, %r9
movq %rdi, %r10
sarq $0x3f, %r10
andq %r9, %r10
orq %rdi, %r10
movq %r10, -0x28(%rsp)
subss %xmm2, %xmm1
cvttss2si %xmm1, %rdi
movq %rax, %r9
sarq $0x3f, %r9
andq %rdi, %r9
orq %rax, %r9
cvttss2si %xmm0, %rax
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
cvttss2si %xmm1, %rdi
movq %r9, -0x20(%rsp)
subss %xmm2, %xmm1
cvttss2si %xmm1, %r9
movq %rdi, %r10
sarq $0x3f, %r10
andq %r9, %r10
orq %rdi, %r10
movq %r10, -0x18(%rsp)
subss %xmm2, %xmm0
cvttss2si %xmm0, %rdi
movq %rax, %r9
sarq $0x3f, %r9
andq %rdi, %r9
orq %rax, %r9
movq %r9, -0x10(%rsp)
movzbl %r8b, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x7824
cvtsi2ss %rax, %xmm2
jmp 0x7839
movq %rax, %rdi
shrq %rdi
andl $0x1, %eax
orq %rdi, %rax
cvtsi2ss %rax, %xmm2
addss %xmm2, %xmm2
movzbl %cl, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x784d
cvtsi2ss %rax, %xmm1
jmp 0x7862
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
movzbl %dl, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x7876
cvtsi2ss %rax, %xmm3
jmp 0x788b
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm3
addss %xmm3, %xmm3
movzbl %sil, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x78a0
cvtsi2ss %rax, %xmm0
jmp 0x78b5
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
retq