LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/maths.h
// Function: squish::Truncate(squish::Vec3 const&)
Vec3 Truncate( Arg v )
    {
        return Vec3(
            v.m_x > 0.0f ? std::floor( v.m_x ) : std::ceil( v.m_x ),
            v.m_y > 0.0f ? std::floor( v.m_y ) : std::ceil( v.m_y ),
            v.m_z > 0.0f ? std::floor( v.m_z ) : std::ceil( v.m_z )
        );
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xae8a0
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
callq 0xabdd0
movss %xmm0, 0x1c(%rsp)
jmp 0xae8b4
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
callq 0xabdf0
movss %xmm0, 0x1c(%rsp)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xae8e9
movq 0x30(%rsp), %rax
movss 0x4(%rax), %xmm0
callq 0xabdd0
movss %xmm0, 0x14(%rsp)
jmp 0xae8fe
movq 0x30(%rsp), %rax
movss 0x4(%rax), %xmm0
callq 0xabdf0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movss 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xae933
movq 0x30(%rsp), %rax
movss 0x8(%rax), %xmm0
callq 0xabdd0
movss %xmm0, 0xc(%rsp)
jmp 0xae948
movq 0x30(%rsp), %rax
movss 0x8(%rax), %xmm0
callq 0xabdf0
movss %xmm0, 0xc(%rsp)
movss 0x10(%rsp), %xmm1
movss 0x18(%rsp), %xmm0
movss 0xc(%rsp), %xmm2
leaq 0x3c(%rsp), %rdi
callq 0xabe10
movl 0x44(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x3c(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/singlecolourfit.cpp
// Function: squish::SingleColourFit::SingleColourFit(squish::ColourSet const*, int)
SingleColourFit::SingleColourFit( ColourSet const* colours, int flags )
  : ColourFit( colours, flags )
{
    // grab the single colour
    Vec3 const* values = m_colours->GetPoints();
    m_colour[0] = ( u8 )FloatToInt( 255.0f*values->X(), 255 );
    m_colour[1] = ( u8 )FloatToInt( 255.0f*values->Y(), 255 );
    m_colour[2] = ( u8 )FloatToInt( 255.0f*values->Z(), 255 );

    // initialise the best error
    m_besterror = INT_MAX;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0xac5b0
movq (%rsp), %rdi
leaq 0x2018c(%rip), %rax     # 0xcec60
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
callq 0xab3a0
movq (%rsp), %rdi
addq $0x24, %rdi
callq 0xab3a0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xab450
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xab550
movaps %xmm0, %xmm1
movss 0x7ac0(%rip), %xmm0     # 0xb65d8
mulss %xmm1, %xmm0
movl $0xff, %edi
callq 0xaeba0
movl %eax, %ecx
movq (%rsp), %rax
movb %cl, 0x14(%rax)
movq 0x8(%rsp), %rdi
callq 0xab560
movaps %xmm0, %xmm1
movss 0x7a94(%rip), %xmm0     # 0xb65d8
mulss %xmm1, %xmm0
movl $0xff, %edi
callq 0xaeba0
movl %eax, %ecx
movq (%rsp), %rax
movb %cl, 0x15(%rax)
movq 0x8(%rsp), %rdi
callq 0xab570
movaps %xmm0, %xmm1
movss 0x7a68(%rip), %xmm0     # 0xb65d8
mulss %xmm1, %xmm0
movl $0xff, %edi
callq 0xaeba0
movl %eax, %ecx
movq (%rsp), %rax
movb %cl, 0x16(%rax)
movl $0x7fffffff, 0x38(%rax) # imm = 0x7FFFFFFF
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/singlecolourfit.cpp
// Function: squish::SingleColourFit::Compress3(void*)
void SingleColourFit::Compress3( void* block )
{
    // build the table of lookups
    SingleColourLookup const* const lookups[] =
    {
        lookup_5_3,
        lookup_6_3,
        lookup_5_3
    };

    // find the best end-points and index
    ComputeEndPoints( lookups );

    // build the block if we win
    if( m_error < m_besterror )
    {
        // remap the indices
        u8 indices[16];
        m_colours->RemapIndices( &m_index, indices );

        // save the block
        WriteColourBlock3( m_start, m_end, indices, block );

        // save the error
        m_besterror = m_error;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20081(%rip), %rax     # 0xcec90
movq %rax, 0x20(%rsp)
movq 0x2007d(%rip), %rax     # 0xcec98
movq %rax, 0x28(%rsp)
movq 0x20079(%rip), %rax     # 0xceca0
movq %rax, 0x30(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xaec90
movq 0x8(%rsp), %rcx
movl 0x34(%rcx), %eax
cmpl 0x38(%rcx), %eax
jge 0xaec84
movq 0x8(%rsp), %rsi
movq 0x8(%rsi), %rdi
addq $0x30, %rsi
leaq 0x10(%rsp), %rdx
callq 0xacb60
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x24, %rsi
leaq 0x10(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0xabe50
movq 0x8(%rsp), %rax
movl 0x34(%rax), %ecx
movl %ecx, 0x38(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/libsquish/singlecolourfit.cpp
// Function: squish::SingleColourFit::Compress4(void*)
void SingleColourFit::Compress4( void* block )
{
    // build the table of lookups
    SingleColourLookup const* const lookups[] =
    {
        lookup_5_4,
        lookup_6_4,
        lookup_5_4
    };

    // find the best end-points and index
    ComputeEndPoints( lookups );

    // build the block if we win
    if( m_error < m_besterror )
    {
        // remap the indices
        u8 indices[16];
        m_colours->RemapIndices( &m_index, indices );

        // save the block
        WriteColourBlock4( m_start, m_end, indices, block );

        // save the error
        m_besterror = m_error;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x1fe21(%rip), %rax     # 0xcecb0
movq %rax, 0x20(%rsp)
movq 0x1fe1d(%rip), %rax     # 0xcecb8
movq %rax, 0x28(%rsp)
movq 0x1fe19(%rip), %rax     # 0xcecc0
movq %rax, 0x30(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xaec90
movq 0x8(%rsp), %rcx
movl 0x34(%rcx), %eax
cmpl 0x38(%rcx), %eax
jge 0xaef04
movq 0x8(%rsp), %rsi
movq 0x8(%rsi), %rdi
addq $0x30, %rsi
leaq 0x10(%rsp), %rdx
callq 0xacb60
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x24, %rsi
leaq 0x10(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0xac0f0
movq 0x8(%rsp), %rax
movl 0x34(%rax), %ecx
movl %ecx, 0x38(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/mi_mkdir.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 4) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}
	//Montamos el disco
	bmount(argv[1]);

	unsigned int permisos = atoi(argv[2]);
	if(permisos < 0 || permisos > 7) {
		puts("Permisos no válidos\n");
		bumount();
		return -1;
	}
	int charF = strlen(argv[3])-1;

	if(argv[3][charF] == '/') { // DIRECTORIO
		if(mi_creat(argv[3], permisos) == 0){
			printf("El directorio %s se ha creado correctamente\n", argv[3]);
		} else printf("Error: No se ha podido llevar a cabo mi_mkdir");
	} else { // FICHERO
		if(mi_creat(argv[3], permisos) == 0){
			printf("El archivo %s se ha creado correctamente\n", argv[3]);
		} else printf("Error: No se ha podido llevar a cabo mi_mkdir");
	}

	bumount();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x5e96
leaq 0x6d4(%rip), %rdi       # 0x6557
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f95
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1290
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1150
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jb 0x5ebf
cmpl $0x7, -0x14(%rbp)
jbe 0x5ede
leaq 0x6b4(%rip), %rdi       # 0x657a
callq 0x1060
movb $0x0, %al
callq 0x12f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f95
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1080
subq $0x1, %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x5f47
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x4b90
cmpl $0x0, %eax
jne 0x5f37
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x662(%rip), %rdi       # 0x6590
movb $0x0, %al
callq 0x1090
jmp 0x5f45
leaq 0x67f(%rip), %rdi       # 0x65bd
movb $0x0, %al
callq 0x1090
jmp 0x5f87
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x4b90
cmpl $0x0, %eax
jne 0x5f77
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x67d(%rip), %rdi       # 0x65eb
movb $0x0, %al
callq 0x1090
jmp 0x5f85
leaq 0x63f(%rip), %rdi       # 0x65bd
movb $0x0, %al
callq 0x1090
jmp 0x5f87
movb $0x0, %al
callq 0x12f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_for
static uint32_t eval_for(uint8_t var, vm_t* vm) {
  uint32_t i = eval(vm); // start
  uint32_t j = eval(vm); // end
  int32_t s = eval(vm);  // step
  uint8_t* pc = vm->pc;
  uint32_t ret = 0;
  if (i <= j) j -= (j - i) % s;
  else j += (i - j) % s, s = -s;
  while (true) {
    // printf("LOOP SET %d=%d\n", var, i);
    vm->vars[var] = i;
    vm->pc = pc;
    ret = eval(vm);
    if (i == j) return ret;
    i += s;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11d0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11d0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11d0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
ja 0x1766
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
xorl %edx, %edx
divl -0x1c(%rbp)
movl -0x18(%rbp), %eax
subl %edx, %eax
movl %eax, -0x18(%rbp)
jmp 0x177f
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
xorl %edx, %edx
divl -0x1c(%rbp)
addl -0x18(%rbp), %edx
movl %edx, -0x18(%rbp)
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1781
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movzbl -0x1(%rbp), %ecx
movl %edx, 0x38(%rax,%rcx,4)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rdi
callq 0x11d0
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x17b9
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movl -0x1c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1781
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_while
static uint32_t eval_while(vm_t* vm) {
  uint8_t* cond = vm->pc;
  uint32_t ret = 0;
  while (vm->pc = cond, eval(vm)) {
    ret = eval(vm);
  }
  skip(vm);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
callq 0x11d0
cmpl $0x0, %eax
je 0x1817
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0x14(%rbp)
jmp 0x17ef
movq -0x8(%rbp), %rdi
callq 0x2290
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_do
static uint32_t eval_do(vm_t* vm) {
  int32_t ret = 0;
  while (*vm->pc != END) ret = eval(vm);
  vm->pc++;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzbl (%rax), %eax
cmpl $0xad, %eax
je 0x18b3
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0xc(%rbp)
jmp 0x1893
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_hue
static uint32_t eval_hue(vm_t* vm) {
  // h is an integer from 0 to 1535, it has 6 color segments, each 256 wide.
  // Output is a 24-bit RGB value
  uint32_t h = eval(vm);
  h = h % 1536;
  uint32_t r, g, b;
  // Red to Yellow
  (h < 0x100) ? (r = 0xff, g = h, b = 0) :
  // Yellow to Green
  (h < 0x200) ? (r = 0x1ff - h, g = 0xff, b = 0) :
  // Green to Cyan
  (h < 0x300) ? (r = 0, g = 0xff, b = h - 0x200) :
  // Cyan to Blue
  (h < 0x400) ? (r = 0, g = 0x3ff - h, b = 0xff) :
  // Blue to Magenta
  (h < 0x500) ? (r = h - 0x400, g = 0, b = 0xff) :
  // Magenta to Red
                (r = 0xff, g = 0, b = 0x5ff - h);
  // printf("h=%d rgb=%02x %02x %02x\n", h, r, g, b);
  return (r << 16) | (g << 8) | b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x600, %ecx            # imm = 0x600
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x1919
movl $0xff, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
jmp 0x19f8
cmpl $0x200, -0xc(%rbp)      # imm = 0x200
jae 0x1945
movl $0x1ff, %eax            # imm = 0x1FF
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0xff, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19f5
cmpl $0x300, -0xc(%rbp)      # imm = 0x300
jae 0x196f
movl $0x0, -0x10(%rbp)
movl $0xff, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl $0x200, %eax            # imm = 0x200
movl %eax, -0x18(%rbp)
movl %eax, -0x20(%rbp)
jmp 0x19ef
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
jae 0x199b
movl $0x0, -0x10(%rbp)
movl $0x3ff, %eax            # imm = 0x3FF
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0xff, -0x18(%rbp)
movl $0xff, %eax
movl %eax, -0x24(%rbp)
jmp 0x19e9
cmpl $0x500, -0xc(%rbp)      # imm = 0x500
jae 0x19c7
movl -0xc(%rbp), %eax
subl $0x400, %eax            # imm = 0x400
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0xff, -0x18(%rbp)
movl $0xff, %eax
movl %eax, -0x28(%rbp)
jmp 0x19e3
movl $0xff, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x5ff, %eax            # imm = 0x5FF
subl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x10(%rbp), %eax
shll $0x10, %eax
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
orl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_rgb
static uint32_t eval_rgb(vm_t* vm) {
  // Input is 3 expressions for Red, Green, and Blue from 0-255 each.
  // Output is a 24-bit RGB value
  return ((eval(vm) & 0xff) << 16) |
         ((eval(vm) & 0xff) << 8) |
          (eval(vm) & 0xff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
andl $0xff, %eax
shll $0x10, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, %ecx
movl -0x10(%rbp), %eax
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, %ecx
movl -0xc(%rbp), %eax
andl $0xff, %ecx
orl %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_mix
static uint32_t eval_mix(vm_t* vm) {
  uint32_t rgb1 = eval(vm);
  uint32_t rgb2 = eval(vm);
  // y is mix between values
  // 0 is all left
  // 255 is all right
  uint32_t y = (eval(vm) & 0xff) + 1;
  uint32_t x = 256 - y;
  return (((((rgb1 >> 16) & 0xff) * x + ((rgb2 >> 16) & 0xff) * y) >> 8) << 16) |
         (((((rgb1 >> 8) & 0xff) * x + ((rgb2 >> 8) & 0xff) * y) >> 8) << 8) |
          (((rgb1 & 0xff) * x + (rgb2 & 0xff) * y) >> 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
andl $0xff, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x100, %eax            # imm = 0x100
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
imull -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
imull -0x14(%rbp), %ecx
addl %ecx, %eax
shrl $0x8, %eax
shll $0x10, %eax
movl -0xc(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
imull -0x18(%rbp), %ecx
movl -0x10(%rbp), %edx
shrl $0x8, %edx
andl $0xff, %edx
imull -0x14(%rbp), %edx
addl %edx, %ecx
shrl $0x8, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0xc(%rbp), %ecx
andl $0xff, %ecx
imull -0x18(%rbp), %ecx
movl -0x10(%rbp), %edx
andl $0xff, %edx
imull -0x14(%rbp), %edx
addl %edx, %ecx
shrl $0x8, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_rand
static uint32_t eval_rand(vm_t* vm) {
  uint32_t range = eval(vm);
	deadbeef_seed = (deadbeef_seed << 7) ^ ((deadbeef_seed >> 25) + deadbeef_beef);
	deadbeef_beef = (deadbeef_beef << 7) ^ ((deadbeef_beef >> 25) + 0xdeadbeef);
	return deadbeef_seed % range;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0xc(%rbp)
movl 0x35b2(%rip), %eax      # 0x5100
shll $0x7, %eax
movl 0x35a9(%rip), %ecx      # 0x5100
shrl $0x19, %ecx
addl 0x3518(%rip), %ecx      # 0x5078
xorl %ecx, %eax
movl %eax, 0x3598(%rip)      # 0x5100
movl 0x350a(%rip), %eax      # 0x5078
shll $0x7, %eax
movl 0x3501(%rip), %ecx      # 0x5078
shrl $0x19, %ecx
addl $0xdeadbeef, %ecx       # imm = 0xDEADBEEF
xorl %ecx, %eax
movl %eax, 0x34f0(%rip)      # 0x5078
movl 0x3572(%rip), %eax      # 0x5100
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_write
static uint32_t eval_write(vm_t* vm) {
  uint32_t index = eval(vm);
  uint32_t rgb = eval(vm);
  if (index < LED_COUNT) {
    int i = index * LED_BPP;
    vm->pixels[i + 0] = (rgb >> 16) & 0xff;
    vm->pixels[i + 1] = (rgb >>  8) & 0xff;
    vm->pixels[i + 2] = (rgb >>  0) & 0xff;
  }
  return rgb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0x10(%rbp)
cmpl $0x8, -0xc(%rbp)
jae 0x1c6b
imull $0x3, -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movl -0x10(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_fill
static uint32_t eval_fill(vm_t* vm) {
  uint32_t rgb = eval(vm);
  for (int i = 0; i < LED_COUNT * LED_BPP; i += LED_BPP) {
    vm->pixels[i] = (rgb >> 16) & 0xff;
    vm->pixels[i + 1] = (rgb >> 8) & 0xff;
    vm->pixels[i + 2] = (rgb >> 0) & 0xff;
  }
  return rgb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x18, -0x10(%rbp)
jge 0x1d05
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, 0x20(%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c9f
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_fade
static uint32_t eval_fade(vm_t* vm) {
  uint32_t rgb = eval(vm);
  // y is mix between values
  // 0 is all old value
  // 255 is all new value
  uint32_t y = (eval(vm) & 0xff) + 1;
  uint32_t x = 256 - y + 1;
  for (int i = 0; i < LED_COUNT * LED_BPP; i += LED_BPP) {
    vm->pixels[i + 0] = (vm->pixels[i + 0] * x + ((rgb >> 16) & 0xff) * y) >> 8;
    vm->pixels[i + 1] = (vm->pixels[i + 1] * x + ((rgb >>  8) & 0xff) * y) >> 8;
    vm->pixels[i + 2] = (vm->pixels[i + 2] * x + ((rgb >>  0) & 0xff) * y) >> 8;
  }
  return rgb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
andl $0xff, %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl $0x100, %eax            # imm = 0x100
subl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x18, -0x18(%rbp)
jge 0x1e23
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl 0x20(%rax,%rcx), %eax
imull -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
imull -0x10(%rbp), %ecx
addl %ecx, %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl 0x20(%rax,%rcx), %eax
imull -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
imull -0x10(%rbp), %ecx
addl %ecx, %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl 0x20(%rax,%rcx), %eax
imull -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl $0x0, %ecx
andl $0xff, %ecx
imull -0x10(%rbp), %ecx
addl %ecx, %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x20(%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d51
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/color-control.c
// Function: eval_pin
static uint32_t eval_pin(vm_t* vm, uint8_t bank) {
  uint8_t pin = eval(vm);
  bool state = eval(vm);
  vm->on_pin(bank, pin, state);
  return state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb -0x9(%rbp), %sil
movb -0xa(%rbp), %dl
movb -0xb(%rbp), %cl
andb $0x1, %cl
movzbl %sil, %edi
movzbl %dl, %esi
movzbl %cl, %edx
callq *%rax
movb -0xb(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/libs/reader.c
// Function: reader_reset
void reader_reset(reader_t* reader) {
  free(reader->body);
  reader->body = NULL;
  reader->size = 0;
  reader->offset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/simulate.c
// Function: main
int main()
{

  while (true)
  {
    uint8_t buf[CHUNK_SIZE];
    ssize_t bytes_read = read(0, buf, CHUNK_SIZE);
    if (bytes_read < 0)
    {
      fprintf(stderr, "Problem reading data from stdin: %s\n", strerror(errno));
      return -1;
    }
    if (!bytes_read)
      return -1;
    reader_result_t res = reader_push(&reader, buf, bytes_read);
    if (res == READER_NEED_MORE)
      continue;
    if (res == READER_DONE)
    {
      run_program(reader.body);
      reader_reset(&reader);
      return 0;
    }
    fprintf(stderr, "Ignoring invalid data: code %d\n", res);
    reader_reset(&reader);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rsi
xorl %edi, %edi
movl $0x10, %edx
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x21a5
movq 0x2e87(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x10c0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x1060(%rip), %rsi      # 0x31f2
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x222d
cmpq $0x0, -0x28(%rbp)
jne 0x21b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x222d
leaq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
leaq 0x2f2c(%rip), %rdi      # 0x50f0
movzwl %ax, %edx
callq 0x1f00
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jne 0x21da
jmp 0x214f
cmpl $0x0, -0x2c(%rbp)
jne 0x2201
movq 0x2f11(%rip), %rdi      # 0x50f8
callq 0x2240
leaq 0x2efd(%rip), %rdi      # 0x50f0
callq 0x2100
movl $0x0, -0x4(%rbp)
jmp 0x222d
movq 0x2df0(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl -0x2c(%rbp), %edx
leaq 0x1002(%rip), %rsi      # 0x3217
movb $0x0, %al
callq 0x1070
leaq 0x2ecd(%rip), %rdi      # 0x50f0
callq 0x2100
jmp 0x214f
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/simulate.c
// Function: delay
static void delay(uint32_t ms)
{
  // printf("Delay %u\n", ms);
  struct timeval t = {
      .tv_sec = ms / 1000,
      .tv_usec = (ms % 1000) * 1000};
  select(0, NULL, NULL, NULL, &t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
movl %eax, %eax
movq %rax, -0x10(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x1090
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTMap_test.c
// Function: test_create
void test_create(void) {

	// Δημιουργούμε μια κενή λίστα (χωρίς αυτόματο free)
	Map map = map_create(compare_ints, NULL, NULL);
	map_set_hash_function(map, hash_int);
	map_set_destroy_key(map, NULL);
	map_set_destroy_value(map, NULL);

	// Ελέγχουμε ότι δεν απέτυχε η malloc στην λίστα, και ότι
	// αρχικοποιείται με μέγεθος 0 (δηλαδή χωρίς κόμβους)
	TEST_ASSERT(map != NULL);
	TEST_ASSERT(map_size(map) == 0);

	map_destroy(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x2f(%rip), %rdi       # 0x43a0
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x5e20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1f66(%rip), %rsi      # 0x6350
callq 0x6370
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6170
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x61a0
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x3ec4(%rip), %rsi      # 0x82e1
movl $0x1d, %edx
leaq 0x41ae(%rip), %rcx      # 0x85d7
leaq 0x3ebf(%rip), %r8       # 0x82ef
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4441
callq 0x2e50
jmp 0x4443
jmp 0x4445
movq -0x8(%rbp), %rdi
callq 0x5f70
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x3e81(%rip), %rsi      # 0x82e1
movl $0x1e, %edx
leaq 0x416b(%rip), %rcx      # 0x85d7
leaq 0x3e88(%rip), %r8       # 0x82fb
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4484
callq 0x2e50
jmp 0x4486
movq -0x8(%rbp), %rdi
callq 0x61d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno.c
// Function: pass_loc
static void
pass_loc(char *pref, char *par)
{
	strcat(loc_args, pref);
	if (par)
	{	strcat(loc_args, par);
		strcat(loc_args, " ");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x29a5(%rip), %rdi      # 0x40d0
callq 0x10f0
cmpq $0x0, -0x10(%rbp)
je 0x175a
movq -0x10(%rbp), %rsi
leaq 0x298e(%rip), %rdi      # 0x40d0
callq 0x10f0
leaq 0x2982(%rip), %rdi      # 0x40d0
leaq 0x9ed(%rip), %rsi       # 0x2142
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno.c
// Function: set_glb
static void
set_glb(char *par)
{
	glob_prop++;
#ifndef DEBUG
	int fd;
	fd = creat("_uno_.c", 0644);
	if (fd < 0)
	{	fprintf(stderr, "uno: cannot create temp files\n");
		exit(1);
	}
	close(fd);
#else
	System("echo \"/* empty file */\" > _uno_.c");
#endif
	sprintf(buf, "%s -prop %s _uno_.c", lx, par);
	System(buf);
#if 1
	unlink("_uno_.c");
#else
	System("rm -f _uno_.c");
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x498a(%rip), %eax      # 0x60fc
addl $0x1, %eax
movl %eax, 0x4981(%rip)      # 0x60fc
leaq 0xa9b(%rip), %rdi       # 0x221d
movl $0x1a4, %esi            # imm = 0x1A4
callq 0x1100
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x17b7
movq 0x285c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa4c(%rip), %rsi       # 0x21f2
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1120
movl -0xc(%rbp), %edi
callq 0x10b0
movq 0x28ea(%rip), %rdx      # 0x40b0
movq -0x8(%rbp), %rcx
leaq 0x492f(%rip), %rdi      # 0x6100
leaq 0xa39(%rip), %rsi       # 0x2211
movb $0x0, %al
callq 0x1110
cmpl $0x0, 0x48ea(%rip)      # 0x60d0
je 0x17fd
leaq 0xa36(%rip), %rdi       # 0x2225
leaq 0x490a(%rip), %rsi      # 0x6100
movb $0x0, %al
callq 0x1080
leaq 0x48fc(%rip), %rdi      # 0x6100
callq 0x1070
leaq 0xa0d(%rip), %rdi       # 0x221d
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno.c
// Function: add_target
static void
add_target(char *f)
{	Fnm *n;

	if (f[0] == '_')
	{	return;	/* avoid re-preprocessing stale uno intermediaries */
	}

	n = (Fnm *) malloc(sizeof(Fnm));
	n->f = (char *) malloc(strlen(f) + 1);
	strcpy(n->f, f);
	n->nxt = fnames;
	fnames = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x1b2a
jmp 0x1b81
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rdi
addq $0x1, %rdi
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x1050
movq 0x4582(%rip), %rcx      # 0x60f0
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x456f(%rip)      # 0x60f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno.c
// Function: cleanup
static void
cleanup(int unused)
{
	if (verbose)
	{	return;
	}

	if ((int) strlen(glob_cmd) > glob_base && glob_base > 5)
	{	memset(glob_cmd, ' ', glob_base);
		strncpy(glob_cmd, "rm -f", 5); /* replace first 5 chars */
		if (w_dir)
		{	char *p = malloc(strlen(glob_cmd) + strlen("cd ;") + strlen(w_dir) + 1);
			sprintf(p, "cd %s; %s\n", w_dir, glob_cmd);
			if (verbose) { printf("%s\n", p); }
			System(p);
		} else
		{
			if (verbose) { printf("%s\n", glob_cmd); }
			System(glob_cmd);
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x452e(%rip)      # 0x60d0
je 0x1ba9
jmp 0x1ceb
leaq 0x3520(%rip), %rdi      # 0x50d0
callq 0x1060
cmpl 0x453d(%rip), %eax      # 0x60f8
jle 0x1ceb
cmpl $0x5, 0x4530(%rip)      # 0x60f8
jle 0x1ceb
movslq 0x4523(%rip), %rdx      # 0x60f8
leaq 0x34f4(%rip), %rdi      # 0x50d0
movl $0x20, %esi
callq 0x10a0
leaq 0x34e3(%rip), %rdi      # 0x50d0
leaq 0xb03(%rip), %rsi       # 0x26f7
movl $0x5, %edx
callq 0x1040
cmpq $0x0, 0x44d2(%rip)      # 0x60d8
je 0x1ca1
leaq 0x34bd(%rip), %rdi      # 0x50d0
callq 0x1060
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq 0x44b1(%rip), %rdi      # 0x60d8
callq 0x1060
movq -0x18(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x10e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x448d(%rip), %rdx      # 0x60d8
leaq 0xaab(%rip), %rsi       # 0x26fd
leaq 0x3477(%rip), %rcx      # 0x50d0
movb $0x0, %al
callq 0x1110
cmpl $0x0, 0x4469(%rip)      # 0x60d0
je 0x1c7b
movq -0x10(%rbp), %rsi
leaq 0xa9a(%rip), %rdi       # 0x270e
movb $0x0, %al
callq 0x1080
cmpl $0x0, 0x444e(%rip)      # 0x60d0
je 0x1c96
movq -0x10(%rbp), %rsi
leaq 0x596(%rip), %rdi       # 0x2225
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
callq 0x1070
jmp 0x1ce9
cmpl $0x0, 0x4428(%rip)      # 0x60d0
je 0x1cbf
leaq 0xa5d(%rip), %rdi       # 0x270e
leaq 0x3418(%rip), %rsi      # 0x50d0
movb $0x0, %al
callq 0x1080
cmpl $0x0, 0x440a(%rip)      # 0x60d0
je 0x1cdd
leaq 0x556(%rip), %rdi       # 0x2225
leaq 0x33fa(%rip), %rsi      # 0x50d0
movb $0x0, %al
callq 0x1080
leaq 0x33ec(%rip), %rdi      # 0x50d0
callq 0x1070
jmp 0x1ceb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno.c
// Function: run_uno
static void
run_uno(void)
{	char *p;

	while (fnames)
	{	strcpy(buf, loc_args);
		strcat(buf, fnames->f);
		if (verbose)
		{	printf("call: %s\n", buf);
		}
		System(buf);

		strcat(glob_cmd, fnames->f);
		p = strrchr(glob_cmd, '.');
		if (!p)
		{	fprintf(stderr, "uno: cannot happen1\n");
			exit(1);
		}
		*p = '\0'; /* replace .c with .uno */
		strcat(glob_cmd, ".uno ");

		fnames = fnames->nxt;
	}
	if (!localonly)
	{	if (glob_prop)
		{	strcat(glob_cmd, "_uno_.uno ");
		}
		if (w_dir)
		{	p = malloc(strlen(glob_cmd) + strlen("cd ;") + strlen(w_dir) + 1);
			sprintf(p, "cd %s; %s\n", w_dir, glob_cmd);
			System(p);
		} else
		{	System(glob_cmd);
	}	}
	cleanup(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x43e0(%rip)      # 0x60f0
je 0x1e0c
leaq 0x43e3(%rip), %rdi      # 0x6100
leaq 0x23ac(%rip), %rsi      # 0x40d0
callq 0x1050
movq 0x43c0(%rip), %rax      # 0x60f0
movq (%rax), %rsi
leaq 0x43c6(%rip), %rdi      # 0x6100
callq 0x10f0
cmpl $0x0, 0x438a(%rip)      # 0x60d0
je 0x1d5d
leaq 0x9b9(%rip), %rdi       # 0x2708
leaq 0x43aa(%rip), %rsi      # 0x6100
movb $0x0, %al
callq 0x1080
cmpl $0x0, 0x436c(%rip)      # 0x60d0
je 0x1d7b
leaq 0x4b8(%rip), %rdi       # 0x2225
leaq 0x438c(%rip), %rsi      # 0x6100
movb $0x0, %al
callq 0x1080
leaq 0x437e(%rip), %rdi      # 0x6100
callq 0x1070
movq 0x4362(%rip), %rax      # 0x60f0
movq (%rax), %rsi
leaq 0x3338(%rip), %rdi      # 0x50d0
callq 0x10f0
leaq 0x332c(%rip), %rdi      # 0x50d0
movl $0x2e, %esi
callq 0x1090
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1ddb
movq 0x2238(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x948(%rip), %rsi       # 0x2712
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1120
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
leaq 0x32e7(%rip), %rdi      # 0x50d0
leaq 0x93c(%rip), %rsi       # 0x272c
callq 0x10f0
movq 0x42f4(%rip), %rax      # 0x60f0
movq 0x8(%rax), %rax
movq %rax, 0x42e9(%rip)      # 0x60f0
jmp 0x1d08
cmpl $0x0, 0x42cd(%rip)      # 0x60e0
jne 0x1ee5
cmpl $0x0, 0x42dc(%rip)      # 0x60fc
je 0x1e35
leaq 0x32a7(%rip), %rdi      # 0x50d0
leaq 0x8f7(%rip), %rsi       # 0x2727
callq 0x10f0
cmpq $0x0, 0x429b(%rip)      # 0x60d8
je 0x1eb9
leaq 0x328a(%rip), %rdi      # 0x50d0
callq 0x1060
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq 0x427e(%rip), %rdi      # 0x60d8
callq 0x1060
movq -0x10(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x10e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x425a(%rip), %rdx      # 0x60d8
leaq 0x878(%rip), %rsi       # 0x26fd
leaq 0x3244(%rip), %rcx      # 0x50d0
movb $0x0, %al
callq 0x1110
cmpl $0x0, 0x4236(%rip)      # 0x60d0
je 0x1eae
movq -0x8(%rbp), %rsi
leaq 0x37e(%rip), %rdi       # 0x2225
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rdi
callq 0x1070
jmp 0x1ee3
cmpl $0x0, 0x4210(%rip)      # 0x60d0
je 0x1ed7
leaq 0x35c(%rip), %rdi       # 0x2225
leaq 0x3200(%rip), %rsi      # 0x50d0
movb $0x0, %al
callq 0x1080
leaq 0x31f2(%rip), %rdi      # 0x50d0
callq 0x1070
jmp 0x1ee5
xorl %edi, %edi
callq 0x1b90
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/./global_basic.h
// Function: mmp_uint_arr
static inline mmp_uint_t mmp_uint_arr (char *cofname)
{
 mmp_uint_t cofilemmp;
 int fd;
 struct stat s;
 fd = open (cofname, O_RDONLY);
 check (fd < 0, "open %s failed: %s", cofname, strerror (errno));
 fstat (fd, & s);
 cofilemmp.fsize = s.st_size;
 cofilemmp.mmpco = mmap(NULL, s.st_size , PROT_READ, MAP_PRIVATE, fd, 0);
 check ( cofilemmp.mmpco == MAP_FAILED, "mmap %s failed: %s", cofname, strerror (errno));
 close(fd);
 return cofilemmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0xc8(%rbp)
movb %sil, %al
movb %al, -0xb1(%rbp)
callq 0x3350
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x1f, %eax
movl %eax, -0xd4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x3440
movl -0xd4(%rbp), %edi
movq -0xd0(%rbp), %rdx
movq %rax, %rcx
movb -0xb1(%rbp), %al
leaq 0x185d3(%rip), %rsi     # 0x1c19f
callq 0x4ca0
movl -0x1c(%rbp), %edi
leaq -0xb0(%rbp), %rsi
callq 0x3470
movl -0xc8(%rbp), %eax
movq -0x80(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x80(%rbp), %rsi
movl -0x1c(%rbp), %r8d
movl %eax, %r9d
movl $0x1, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x3130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
subq $-0x1, %rax
sete %al
movzbl %al, %eax
movl %eax, -0xc4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x3440
movl -0xc4(%rbp), %edi
movq -0xc0(%rbp), %rdx
movq %rax, %rcx
movb -0xb1(%rbp), %al
leaq 0x1855b(%rip), %rsi     # 0x1c1b2
callq 0x4ca0
movl -0x1c(%rbp), %edi
callq 0x3200
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/co2mco.c
// Function: write_unit_arrmco_file
unsigned int write_unit_arrmco_file(const char* unitmcofname, gidobj_t** arrmco)
{
  FILE *outf;
  if( (outf = fopen(unitmcofname,"wb") ) == NULL ) err(errno,"write_unit_arrmco_file()");
  size_t comp_sz = (1LLU << 4*COMPONENT_SZ);
 unsigned int validrow=0;
  for(size_t i = 0; i< comp_sz ; i++ ){
    if(arrmco[i] != NULL){
   validrow++;
   fwrite(&i,sizeof(i),1,outf);
   fwrite(arrmco[i], sizeof(gidobj_t), (unsigned int)arrmco[i][0] + 1, outf);
  }
  }
 fclose(outf);
 return validrow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1773f(%rip), %rsi     # 0x1c05a
callq 0x3370
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x493f
callq 0x3050
movl (%rax), %edi
leaq 0x17801(%rip), %rsi     # 0x1c139
movb $0x0, %al
callq 0x3300
movq $0x10000000, -0x20(%rbp) # imm = 0x10000000
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x49ce
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x49be
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x3420
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movl $0x4, %esi
callq 0x3420
jmp 0x49c0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4956
movq -0x18(%rbp), %rdi
callq 0x30e0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/co2mco.c
// Function: read_unit_arrmco_file
gidobj_t** read_unit_arrmco_file(const char *mco_fncode)
{
 FILE *inf;
 if( (inf = fopen(mco_fncode ,"rb") ) == NULL ) err(errno,"read_unit_arrmco_file()");
 size_t comp_sz = (1LLU << 4*COMPONENT_SZ);
 unsigned int ind ;
 gidobj_t** arrmco = calloc(comp_sz, sizeof(gidobj_t*));
  gidobj_t gid_arr_len;
 while( fread(&ind,sizeof(ind),1,inf) == 1){
  fread(&gid_arr_len, sizeof(gidobj_t), 1 , inf);
  arrmco[ind] = malloc(sizeof(gidobj_t)* ( (unsigned int)gid_arr_len + 1));
  arrmco[ind][0] = gid_arr_len;
  fread( arrmco[ind] + 1, sizeof(gidobj_t), (unsigned int)gid_arr_len , inf);
 }
 fclose(inf);
 return arrmco ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x17660(%rip), %rsi     # 0x1c057
callq 0x3370
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x4a1b
callq 0x3050
movl (%rax), %edi
leaq 0x1773e(%rip), %rsi     # 0x1c152
movb $0x0, %al
callq 0x3300
movq $0x10000000, -0x18(%rbp) # imm = 0x10000000
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x3270
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x30a0
cmpq $0x1, %rax
jne 0x4ac1
movq -0x10(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x30a0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x3310
movq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edx
movq (%rax,%rdx,8), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x4, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
jmp 0x4a35
movq -0x10(%rbp), %rdi
callq 0x30e0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/co2mco.c
// Function: free_unit_arrmco
void free_unit_arrmco(gidobj_t** unit_arrmco)
{
 size_t comp_sz = (1LLU << 4*COMPONENT_SZ);
 for(size_t i = 0; i < comp_sz ; i++){
  if(unit_arrmco[i] != NULL)
   free(unit_arrmco[i]);
 }
 free(unit_arrmco);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x10000000, -0x10(%rbp) # imm = 0x10000000
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4b36
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4b26
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3040
jmp 0x4b28
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4afc
movq -0x8(%rbp), %rdi
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/co2mco.c
// Function: precise_est_unitllmco_mem
size_t precise_est_unitllmco_mem(const char *co_dstat_fpath)
{
 FILE *co_stat_fp;
 if( ( co_stat_fp = fopen(co_dstat_fpath,"rb")) == NULL )
   err(errno,"precise_est_unitllmco_mem():%s",co_dstat_fpath);
 co_dstat_t co_dstat_readin;
 fread( &co_dstat_readin, sizeof(co_dstat_t),1,co_stat_fp );
 size_t comp_sz = (1LLU << 4*COMPONENT_SZ) ;
 double ctx_spc_use_rate = (double)co_dstat_readin.all_ctx_ct
  /co_dstat_readin.infile_num/co_dstat_readin.comp_num/comp_sz ;
 printf("ctx_spc_use_rate=%lf\n",ctx_spc_use_rate);
 size_t mem_sz = comp_sz
        *( sizeof(mco_entry_stat_t*)
        + sizeof(mco_entry_stat_t)
        + ( (unsigned int)( ( (double) BIN_SZ * ctx_spc_use_rate ) / GID_ARR_SZ ) + 1 )
         * ( sizeof(gidobj_t) * GID_ARR_SZ + sizeof(gid_arr_llist_t *) )
        );
 fclose(co_stat_fp);
 return mem_sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x174c0(%rip), %rsi     # 0x1c057
callq 0x3370
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x4bbf
callq 0x3050
movl (%rax), %edi
movq -0x8(%rbp), %rdx
leaq 0x175b2(%rip), %rsi     # 0x1c16a
movb $0x0, %al
callq 0x3300
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
movl $0x1, %edx
callq 0x30a0
movq $0x10000000, -0x38(%rbp) # imm = 0x10000000
movaps 0x1743b(%rip), %xmm3    # 0x1c020
movq -0x18(%rbp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x1743a(%rip), %xmm2    # 0x1c030
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x38(%rbp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
leaq 0x17545(%rip), %rdi     # 0x1c189
movb $0x1, %al
callq 0x3150
movq -0x38(%rbp), %rax
movsd -0x40(%rbp), %xmm0
movsd 0x173ac(%rip), %xmm1    # 0x1c008
mulsd %xmm1, %xmm0
movsd 0x173a8(%rip), %xmm1    # 0x1c010
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
addl $0x1, %ecx
movl %ecx, %ecx
imulq $0x48, %rcx, %rcx
addq $0x18, %rcx
imulq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/./global_basic.h
// Function: check
static inline void check (int test, const char * message, ...)
{
    if (test) {
        va_list args;
        va_start (args, message);
        vfprintf (stderr, message, args);
        va_end (args);
        fprintf (stderr, "\n");
        exit (EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4cd8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x4d62
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x1d2cc(%rip), %rax     # 0x21ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x33c0
leaq -0x30(%rbp), %rax
movq 0x1d2b1(%rip), %rax     # 0x21ff8
movq (%rax), %rdi
leaq 0x1a25e(%rip), %rsi     # 0x1efaf
movb $0x0, %al
callq 0x3290
movl $0x1, %edi
callq 0x3410
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)