LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
callq 0x71f40
leaq 0x20134(%rip), %rax     # 0x92c40
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
movss 0x7a85(%rip), %xmm0     # 0x7a5a0
movss 0x4(%rcx), %xmm1
mulss %xmm0, %xmm1
movss 0x7a5c(%rip), %xmm2     # 0x7a588
addss %xmm2, %xmm1
cvttss2si %xmm1, %edx
movl $0xff, %eax
cmpl %eax, %edx
cmovgel %eax, %edx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
movb %dl, 0x14(%rbx)
movss 0x8(%rcx), %xmm1
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
cvttss2si %xmm1, %edx
cmpl %eax, %edx
cmovgel %eax, %edx
testl %edx, %edx
cmovlel %esi, %edx
movb %dl, 0x15(%rbx)
mulss 0xc(%rcx), %xmm0
addss %xmm2, %xmm0
cvttss2si %xmm0, %ecx
cmpl %eax, %ecx
cmovll %ecx, %eax
testl %eax, %eax
cmovlel %esi, %eax
movb %al, 0x16(%rbx)
movl $0x7fffffff, 0x38(%rbx) # imm = 0x7FFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x200c0(%rip), %rsi     # 0x92c60
callq 0x72be4
movl 0x34(%rbx), %eax
cmpl 0x38(%rbx), %eax
jge 0x72bd9
movq 0x8(%rbx), %rdi
leaq 0x30(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x72196
leaq 0x18(%rbx), %rdi
leaq 0x24(%rbx), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x71c14
movl 0x34(%rbx), %eax
movl %eax, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1ff90(%rip), %rsi     # 0x92c80
callq 0x72be4
movl 0x34(%rbx), %eax
cmpl 0x38(%rbx), %eax
jge 0x72d29
movq 0x8(%rbx), %rdi
leaq 0x30(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x72196
leaq 0x18(%rbx), %rdi
leaq 0x24(%rbx), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x71d52
movl 0x34(%rbx), %eax
movl %eax, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/decimal.c
// Function: SH_Decimal__init
SH_Decimal*
SH_Decimal__init(sh_float_t value, int* err) {
	SH_Decimal* obj;
	sh_bool_t n; /*negative?*/
	sh_int_t i;  /*(abs) int val*/
	uint16_t f;  /*fraction part*/

	__cascade(err, (SH_Decimal*)0);

	i = (sh_int_t)value;
	if (i < 0) {
		i = -i;
		n = SH_TRUE;
	} else {
		n = SH_FALSE;
	}

	if (i > SH_INT_C(999999999999)) {
		__raise(err, SH_E_DECIMAL_OUT_OF_BOUNDS);
		return (SH_Decimal*)0;
	}

	/* FIXME: wrong round (to infinity, should be to even) */
	f = (uint16_t)(
			(uint64_t)(
				(sh_float_t)fabs((double)(value * FFACTOR)) + SH_FLOAT_C(0.5)
			) % IFACTOR
		);

	obj = (SH_Decimal*)malloc(sizeof(SH_Decimal));
	if ((SH_Decimal*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Decimal*)0;
	}

	obj->value = (n ? SH_FLOAT_C(-1.0) : SH_FLOAT_C(1.0)) * ((sh_float_t)i + ((sh_float_t)f / FFACTOR));
	obj->_neg = n;
	obj->_int = i;
	obj->_frac = f;

	__clear(err);
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x115a
cmpl $0x0, (%rbx)
jne 0x118c
cvttsd2si %xmm0, %r15
movq %r15, %r14
negq %r14
cmovsq %r15, %r14
movq %r14, %rax
shrq $0xc, %rax
cmpq $0xe8d4a50, %rax        # imm = 0xE8D4A50
jbe 0x1193
movl $0x120001, %eax         # imm = 0x120001
jmp 0x1256
cvttsd2si %xmm0, %r15
movq %r15, %r14
negq %r14
cmovsq %r15, %r14
movq %r14, %rax
shrq $0xc, %rax
cmpq $0xe8d4a50, %rax        # imm = 0xE8D4A50
ja 0x118c
movapd %xmm0, (%rsp)
movl $0x20, %edi
callq 0x1040
testq %rax, %rax
jne 0x11ab
xorl %ecx, %ecx
jmp 0x125a
movapd %xmm0, (%rsp)
movl $0x20, %edi
callq 0x1040
testq %rax, %rax
je 0x1251
movq %rax, %rcx
movsd 0xe4a(%rip), %xmm0      # 0x2000
movapd (%rsp), %xmm1
mulsd %xmm0, %xmm1
andpd 0xe59(%rip), %xmm1      # 0x2020
addsd 0xe39(%rip), %xmm1      # 0x2008
cvttsd2si %xmm1, %rax
movq %r15, %rsi
movq %rax, %rdx
subsd 0xe2e(%rip), %xmm1      # 0x2010
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rdi
andq %rdx, %rdi
orq %rax, %rdi
movq %rdi, %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
mulq %rdx
shrl $0x4, %edx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
cvtsi2sd %r14, %xmm2
subl %eax, %edi
movswl %di, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
sarq $0x3f, %rsi
divsd %xmm0, %xmm1
addsd %xmm2, %xmm1
testq %r15, %r15
jns 0x1238
xorpd 0xdf8(%rip), %xmm1      # 0x2030
xorl %eax, %eax
movsd %xmm1, (%rcx)
movb %sil, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movw %di, 0x18(%rcx)
testq %rbx, %rbx
jne 0x1258
jmp 0x125a
movl $0x80000001, %eax       # imm = 0x80000001
xorl %ecx, %ecx
movl %eax, (%rbx)
movq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jne 0x3d47
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x128c
movq 0x10(%rbx), %rdi
callq 0x1150
cmpl $0x8, %eax
jb 0x3d5a
leaq 0x7ef(%rip), %rdi       # 0x4528
callq 0x1060
xorl %eax, %eax
callq 0x12ca
jmp 0x3d53
leaq 0x875(%rip), %rdi       # 0x45c3
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3dc2
movl %eax, %ebp
movq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x1080
decl %eax
cltq
movb (%r14,%rax), %r15b
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x310c
cmpb $0x2f, %r15b
jne 0x3d93
testl %eax, %eax
jne 0x3d97
movq 0x18(%rbx), %rsi
leaq 0x7ad(%rip), %rdi       # 0x453e
jmp 0x3db2
testl %eax, %eax
je 0x3da7
leaq 0x7cd(%rip), %rdi       # 0x456b
xorl %eax, %eax
callq 0x1090
jmp 0x3db9
movq 0x18(%rbx), %rsi
leaq 0x7e7(%rip), %rdi       # 0x4599
xorl %eax, %eax
callq 0x1090
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x12ca
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %r14
callq 0x124c
testl %eax, %eax
je 0x1672
movq %rbx, %rdi
callq 0x124c
movl %eax, %ebp
movq %r14, 0x58(%rbx)
movq %rbx, %rdi
callq 0x124c
testl %eax, %eax
jne 0x1656
jmp 0x1674
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1bc6
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
callq 0x124c
movl %eax, %ecx
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
imulq %rcx, %rdx
shrq $0x2a, %rdx
shll $0x9, %edx
leal (%rdx,%rdx,2), %ecx
subl %ecx, %eax
xorl %edx, %edx
movl $0xff, %ecx
cmpl $0x100, %eax            # imm = 0x100
jb 0x1731
cmpl $0x1ff, %eax            # imm = 0x1FF
ja 0x16e2
movl $0x1ff, %ecx            # imm = 0x1FF
subl %eax, %ecx
movl $0xff, %eax
jmp 0x1731
cmpl $0x2ff, %eax            # imm = 0x2FF
ja 0x16fa
movl %eax, %edx
addl $0xfffffe00, %edx       # imm = 0xFFFFFE00
movl $0xff, %eax
xorl %ecx, %ecx
jmp 0x1731
cmpl $0x3ff, %eax            # imm = 0x3FF
ja 0x1713
movl $0x3ff, %esi            # imm = 0x3FF
subl %eax, %esi
movl $0xff, %edx
xorl %ecx, %ecx
movl %esi, %eax
jmp 0x1731
cmpl $0x4ff, %eax            # imm = 0x4FF
ja 0x1728
addl $0xfffffc00, %eax       # imm = 0xFFFFFC00
movl $0xff, %edx
movl %eax, %ecx
jmp 0x172f
movl $0x5ff, %edx            # imm = 0x5FF
subl %eax, %edx
xorl %eax, %eax
shll $0x10, %ecx
orl %edx, %ecx
shll $0x8, %eax
orl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
callq 0x124c
movl %eax, %ecx
movl 0x28f8(%rip), %eax      # 0x4100
movl %eax, %edx
shll $0x7, %edx
shrl $0x19, %eax
movl 0x286a(%rip), %esi      # 0x4080
addl %esi, %eax
xorl %edx, %eax
movl %eax, 0x28e0(%rip)      # 0x4100
movl %esi, %edx
shll $0x7, %edx
shrl $0x19, %esi
addl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
xorl %edx, %esi
movl %esi, 0x284a(%rip)      # 0x4080
xorl %edx, %edx
divl %ecx
movl %edx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x124c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x124c
cmpl $0x7, %ebp
ja 0x186f
movl %ebp, %ecx
leaq (%rcx,%rcx,2), %rcx
movl %eax, %edx
shrl $0x10, %edx
movb %dl, 0x20(%rbx,%rcx)
movb %ah, 0x21(%rbx,%rcx)
movb %al, 0x22(%rbx,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x124c
movl %eax, %ecx
shrl $0x10, %ecx
movl %eax, %edx
shrl $0x8, %edx
movq $-0x3, %rsi
movb %cl, 0x23(%rbx,%rsi)
movb %dl, 0x24(%rbx,%rsi)
movb %al, 0x25(%rbx,%rsi)
addq $0x3, %rsi
cmpq $0x15, %rsi
jb 0x1890
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/libs/reader.c
// Function: reader_push
reader_result_t reader_push(reader_t* reader, uint8_t* data, uint16_t len) {

  // Read the header in an interruptible way if we don't have it all yet.
  while (!reader->body) {
    if (!len--) return READER_NEED_MORE;
    uint8_t byte = *data++;
    uint8_t offset = reader->offset++;
    if (offset == 0) {
      if (byte == '(') continue;
    }
    if (offset == 1) {
      if (byte == ']') continue;
    }
    if (offset == 2) {
      reader->size = byte << 8;
      continue;
    }
    if (offset == 3) {
      reader->size = (reader->size | byte) - 6;
      reader->offset = 0;
      reader->body = malloc(reader->size);
      if (reader->size) break;
    }
    return READER_INVALID_START_BYTES;
  }

  uint16_t bytes_left = reader->size - reader->offset;

  if (len >= bytes_left) {
    memcpy(reader->body + reader->offset, data, bytes_left);
    if (len > bytes_left + 1) {
      if (data[bytes_left] != '[' || data[bytes_left + 1] != ')') {
        return READER_INVALID_END_BYTES;
      }
    }
    // TODO: verify trailing bytes when they are broken to a new packet?
    return READER_DONE;
  }

  memcpy(reader->body + reader->offset, data, len);
  reader->offset += len;
  return READER_NEED_MORE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x19c8
movzwl (%r15), %r12d
movzwl 0x2(%r15), %eax
subl %eax, %r12d
cmpw %r12w, %r14w
jae 0x1a3a
movzwl %ax, %eax
addq %rax, %rdi
movzwl %r14w, %edx
movq %rbx, %rsi
callq 0x1090
addw %r14w, 0x2(%r15)
movl $0x1, %ebp
jmp 0x1a6f
movl $0x1, %ebp
testw %r14w, %r14w
je 0x1a6f
movzwl 0x2(%r15), %eax
movzwl %r14w, %r14d
xorl %r13d, %r13d
leal (%rax,%r13), %ecx
movb (%rbx,%r13), %dl
leal (%rax,%r13), %esi
incl %esi
movw %si, 0x2(%r15)
andw $0xff, %cx
sete %sil
cmpb $0x28, %dl
sete %dil
testb %dil, %sil
jne 0x1a2f
movzbl %dl, %r12d
cmpw $0x1, %cx
jne 0x1a1b
cmpb $0x5d, %r12b
je 0x1a2f
leaq (%rax,%r13), %rcx
cmpb $0x2, %cl
jne 0x1a80
movzwl %r12w, %ecx
shll $0x8, %ecx
movw %cx, (%r15)
incq %r13
cmpw %r13w, %r14w
jne 0x19e3
jmp 0x1a6f
movzwl %r14w, %ebp
movzwl %ax, %eax
addq %rax, %rdi
movzwl %r12w, %r14d
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1090
leaq 0x1(%r14), %rax
cmpl %ebp, %eax
jae 0x1a6d
movl $0x3, %ebp
cmpb $0x5b, (%rbx,%r14)
jne 0x1a6f
cmpb $0x29, (%rbx,%rax)
jne 0x1a6f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %cl, %eax
movl $0x2, %ebp
cmpl $0x3, %eax
jne 0x1a6f
orw (%r15), %r12w
addl $-0x6, %r12d
movw %r12w, (%r15)
movw $0x0, 0x2(%r15)
movzwl %r12w, %edi
movq %rdi, (%rsp)
callq 0x10b0
movq %rax, 0x8(%r15)
cmpw $0x0, (%rsp)
je 0x1a6f
movq %rax, %rdi
subq %r13, %r14
addq $0xffff, %r14           # imm = 0xFFFF
addq %r13, %rbx
incq %rbx
xorl %eax, %eax
jmp 0x199a
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rsi
movl $0x10, %edx
xorl %edi, %edi
callq 0x1070
testq %rax, %rax
js 0x1bb2
leaq 0x25db(%rip), %rbx      # 0x40f0
movq %rsp, %r14
testq %rax, %rax
je 0x1bb7
movzwl %ax, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1974
cmpl $0x1, %eax
jne 0x1b4a
movl $0x10, %edx
xorl %edi, %edi
movq %r14, %rsi
callq 0x1070
testq %rax, %rax
jns 0x1b18
jmp 0x1bb2
testl %eax, %eax
je 0x1b57
movl %eax, %edi
callq 0x10f0
jmp 0x1b34
movq 0x259a(%rip), %rbx      # 0x40f8
leaq 0x80d(%rip), %rdi       # 0x2372
callq 0x1050
movq %rbx, 0x256f(%rip)      # 0x40e0
leaq 0x2510(%rip), %rdi      # 0x4088
callq 0x124c
leaq 0x6b3(%rip), %rdi       # 0x2237
xorl %ebx, %ebx
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq 0x2562(%rip), %rdi      # 0x40f8
callq 0x1030
movq $0x0, 0x2552(%rip) # 0x40f8
movl $0x0, 0x2540(%rip)      # 0x40f0
jmp 0x1bbc
callq 0x112b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/libs/color-control.c
// Function: skip
static void skip(vm_t* vm) {
  opcode_t op = *(vm->pc)++;
  // If the opcode is less than 128, it's a literal unsigned integer
  if (op < 128) return;
  // Everything else needs to be switched based on it's code.
  switch (op) {
    // Handle the larger number literals (these consume 2-5 bytes)
    case UINT8:   vm->pc += 1; return;
    case UINT16:  vm->pc += 2; return;
    case UINT24:  vm->pc += 3; return;
    case UINT32:  vm->pc += 4; return;

    // Operations that don't consume any expressions
    case UPDATE:
    case GET0: case GET1: case GET2: case GET3:
    case GET4: case GET5: case GET6: case GET7:
      return;

    // Operators that consume one expression
    case SET0: case SET1: case SET2: case SET3:
    case SET4: case SET5: case SET6: case SET7:
    case NOT:
    case DELAY:
    case HUE: case RAND: case SRAND:
    case FILL:
      return skip(vm);

    // Operators that consume two expressions
    case ADD: case SUB: case MUL: case DIV: case MOD:
    case LT: case GT: case LTE: case GTE: case EQ: case NEQ:
    case AND: case OR: case WHILE: case IF:
    case PINA: case PINB: case WRITE: case FADE:
      return skip(vm), skip(vm);

    // Consume 3
    case RGB: case MIX:
      return skip(vm), skip(vm), skip(vm);

    // Operators that consume 4 expressions
    case FOR0: case FOR1: case FOR2: case FOR3:
    case FOR4: case FOR5: case FOR6: case FOR7:
      return skip(vm), skip(vm), skip(vm), skip(vm);

    case DO: return skip_do(vm);

    case END:
      vm->on_error(op, "Illegal opcode");
  }
  vm->on_error(op, "Unknown opcode");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x58(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x58(%rdi)
movb (%rax), %dl
testb %dl, %dl
jns 0x1c27
movq %rdi, %rbx
leaq 0x505(%rip), %r15       # 0x20ec
movzbl %dl, %r14d
leal -0x80(%r14), %edx
cmpl $0x39, %edx
ja 0x1c62
movslq (%r15,%rdx,4), %rdx
addq %r15, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x1bc6
movq %rbx, %rdi
callq 0x1bc6
movq %rbx, %rdi
callq 0x1bc6
movq 0x58(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x58(%rbx)
movb (%rax), %dl
testb %dl, %dl
js 0x1be7
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1bc6
movq 0x58(%rbx), %rcx
cmpb $-0x53, (%rcx)
jne 0x1c2d
incq %rcx
movq %rcx, 0x58(%rbx)
jmp 0x1c27
addq $0x3, %rax
jmp 0x1c87
leaq 0x580(%rip), %rsi       # 0x21d4
movl $0xad, %r14d
movl $0xad, %edi
callq *0x10(%rbx)
movq 0x10(%rbx), %rax
leaq 0x576(%rip), %rsi       # 0x21e3
movl %r14d, %edi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
addq $0x4, %rax
jmp 0x1c87
addq $0x2, %rax
jmp 0x1c87
addq $0x5, %rax
movq %rax, 0x58(%rbx)
jmp 0x1c27
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq -0xd(%rip), %rdi        # 0x3cc4
xorl %esi, %esi
xorl %edx, %edx
callq 0x4e20
movq %rax, %rbx
leaq 0x13b6(%rip), %rsi      # 0x509a
movq %rax, %rdi
callq 0x50a0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4ff4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4ffd
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x2608(%rip), %rsi      # 0x6318
leaq 0x28f2(%rip), %rcx      # 0x6609
leaq 0x2608(%rip), %r8       # 0x6326
movl $0x1d, %edx
xorl %eax, %eax
callq 0x25ec
testl %eax, %eax
je 0x3d6c
movq %rbx, %rdi
callq 0x4edc
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x25d3(%rip), %rsi      # 0x6318
leaq 0x28bd(%rip), %rcx      # 0x6609
leaq 0x25df(%rip), %r8       # 0x6332
movl $0x1e, %edx
xorl %eax, %eax
callq 0x25ec
testl %eax, %eax
je 0x3d6c
movq %rbx, %rdi
popq %rbx
jmp 0x5006
callq 0x2e4b
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTMap_test.c
// Function: shuffle
void shuffle(int* array[], int n) {
	for (int i = 0; i < n; i++) {
		int j = i + rand() / (RAND_MAX / (n - i) + 1);
		int* t = array[j];
		array[j] = array[i];
		array[i] = t;
	}
}

// Assembly:
testl %esi, %esi
jle 0x3e27
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
callq 0x22a0
movl %eax, %ecx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
idivl %r14d
movl %eax, %esi
incl %esi
movl %ecx, %eax
cltd
idivl %esi
cltq
addq %r15, %rax
movq (%rbx,%rax,8), %rcx
movq (%rbx,%r15,8), %rdx
movq %rdx, (%rbx,%rax,8)
movq %rcx, (%rbx,%r15,8)
incq %r15
decq %r14
jne 0x3deb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x43e7(%rip)      # 0x60d0
jne 0x1db7
leaq 0x33da(%rip), %rdi      # 0x50d0
callq 0x1060
movl 0x43f7(%rip), %edx      # 0x60f8
cmpl %eax, %edx
setge %al
cmpl $0x6, %edx
setl %cl
orb %al, %cl
jne 0x1db7
addq $-0x5, %rdx
leaq 0x33b6(%rip), %rdi      # 0x50d5
movl $0x20, %esi
callq 0x10a0
movl $0x2d206d72, 0x339d(%rip) # imm = 0x2D206D72
movb $0x66, 0x339a(%rip)     # 0x50d4
movq 0x4397(%rip), %r14      # 0x60d8
testq %r14, %r14
je 0x1dbd
leaq 0x3383(%rip), %r15      # 0x50d0
movq %r15, %rdi
callq 0x1060
movq %rax, %rbx
movq %r14, %rdi
callq 0x1060
leaq (%rbx,%rax), %rdi
addq $0x5, %rdi
callq 0x10e0
movq %rax, %rbx
leaq 0x925(%rip), %rsi       # 0x269c
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1110
cmpb $0x1, 0x4342(%rip)      # 0x60d0
jne 0x1db2
movq %rbx, %rdi
callq 0x1050
cmpb $0x1, 0x4331(%rip)      # 0x60d0
jne 0x1db2
leaq 0x41c(%rip), %rdi       # 0x21c4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
jmp 0x1dc4
popq %rbx
popq %r14
popq %r15
retq
leaq 0x330c(%rip), %rdi      # 0x50d0
popq %rbx
popq %r14
popq %r15
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/yhg926[P]public_kssd/co2mco.c
// Function: llmco2arrmco
gidobj_t** llmco2arrmco(mco_entry_stat_t** llmco)
{
 size_t comp_sz = (1LL << 4*COMPONENT_SZ) ;
 gidobj_t** arrmco = calloc(comp_sz, sizeof(gidobj_t*));
 gidobj_t* current_blkpos_mapin_arrmco;
 gid_arr_llist_t *tmpblk, *tmpptr;
  for(size_t i = 0; i< comp_sz ; i++ ){
  if(llmco[i] == NULL) continue;
  int arr_len = (int)llmco[i]->g_num + 1;
   arrmco[i] = malloc( arr_len * sizeof(gidobj_t) );
  current_blkpos_mapin_arrmco = arrmco[i] + arr_len;
  arrmco[i][0] = llmco[i]->g_num;
  int blk_num = arrmco[i][0] % GID_ARR_SZ == 0 ? arrmco[i][0]/GID_ARR_SZ :arrmco[i][0]/GID_ARR_SZ + 1;
  for(int blk = 0; blk < blk_num; blk++){
   if( blk == 0 ){
    tmpblk = llmco[i]->next;
    if(arrmco[i][0] % GID_ARR_SZ == 0){
     current_blkpos_mapin_arrmco -= GID_ARR_SZ;
     memcpy(current_blkpos_mapin_arrmco, tmpblk->gidobj, GID_ARR_SZ * sizeof(gidobj_t));
    }
    else {
     current_blkpos_mapin_arrmco -= arrmco[i][0] % GID_ARR_SZ ;
     memcpy(current_blkpos_mapin_arrmco, tmpblk->gidobj, (arrmco[i][0] % GID_ARR_SZ) * sizeof(gidobj_t));
    }
    free(llmco[i]);
   }
   else {
    tmpptr = tmpblk;
    tmpblk = tmpblk->next;
    current_blkpos_mapin_arrmco -= GID_ARR_SZ;
        memcpy(current_blkpos_mapin_arrmco, tmpblk->gidobj,GID_ARR_SZ * sizeof(gidobj_t));
    free(tmpptr);
   }
  }
  }
 free(llmco);
 return arrmco;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x10000000, %edi       # imm = 0x10000000
movl $0x8, %esi
callq 0x32a0
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rax
testq %rax, %rax
je 0x43f9
movslq (%rax), %rbx
leaq 0x4(,%rbx,4), %rdi
callq 0x3340
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%rbp,8)
movl %ebx, (%rax)
xorl %r14d, %r14d
testb $0xf, %bl
setne %r14b
movl %ebx, %ecx
shrl $0x4, %ecx
addl %ecx, %r14d
je 0x43f9
incq %rbx
leaq (%rax,%rbx,4), %r15
xorl %ebx, %ebx
testl %ebx, %ebx
je 0x437b
movq 0x40(%r12), %r13
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups 0x30(%r13), %xmm3
movups %xmm3, -0x10(%r15)
movups %xmm2, -0x20(%r15)
movups %xmm1, -0x30(%r15)
movups %xmm0, -0x40(%r15)
addq $-0x40, %r15
jmp 0x43e1
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rax
movq 0x8(%rax), %r13
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rax
movl (%rax), %edx
andq $0xf, %rdx
je 0x43ac
shll $0x2, %edx
subq %rdx, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x32f0
jmp 0x43d8
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups 0x30(%r13), %xmm3
movups %xmm3, -0x10(%r15)
movups %xmm2, -0x20(%r15)
movups %xmm1, -0x30(%r15)
movups %xmm0, -0x40(%r15)
addq $-0x40, %r15
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %r12
movq %r12, %rdi
callq 0x3040
incl %ebx
movq %r13, %r12
cmpl %ebx, %r14d
jne 0x4344
jmp 0x43fc
movq %r12, %r13
incq %rbp
movq %r13, %r12
cmpq $0x10000000, %rbp       # imm = 0x10000000
jne 0x42f6
movq 0x8(%rsp), %rdi
callq 0x3040
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x10c26(%rip), %rsi     # 0x1506a
callq 0x33a0
testq %rax, %rax
je 0x44c7
movq %rax, %r14
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq $0x0, (%rbx,%r13,8)
je 0x449d
incl %r15d
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x3450
movq 0x8(%rsp), %r13
movq (%rbx,%r13,8), %rdi
movl (%rdi), %edx
incl %edx
movl $0x4, %esi
movq %r14, %rcx
callq 0x3450
incq %r13
movq %r13, 0x8(%rsp)
cmpq $0x10000000, %r13       # imm = 0x10000000
jb 0x4464
movq %r14, %rdi
callq 0x3100
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0x10c74(%rip), %rsi     # 0x15149
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x10b77(%rip), %rsi     # 0x15067
callq 0x33a0
testq %rax, %rax
je 0x45b4
movq %rax, %rbx
movl $0x10000000, %edi       # imm = 0x10000000
movl $0x8, %esi
callq 0x32a0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x30c0
cmpq $0x1, %rax
jne 0x459b
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x30c0
movl 0xc(%rsp), %r13d
leal 0x1(%r13), %edi
shlq $0x2, %rdi
callq 0x3340
movl 0x8(%rsp), %ecx
movq %rax, (%r14,%rcx,8)
movl %r13d, (%rax)
leaq 0x4(%rax), %rdi
movl $0x4, %esi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x30c0
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x30c0
cmpq $0x1, %rax
je 0x453a
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0x10ba0(%rip), %rsi     # 0x15162
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x45e1
callq 0x3040
incq %r14
cmpq $0x10000000, %r14       # imm = 0x10000000
jne 0x45d3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x10a4f(%rip), %rsi     # 0x15067
callq 0x33a0
testq %rax, %rax
je 0x46da
movq %rax, %rbx
leaq 0x18(%rsp), %r14
movl $0x20, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x30c0
movsd 0x18(%r14), %xmm1
unpcklps 0x109e0(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x109e8(%rip), %xmm1    # 0x15040
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cvtsi2sdl 0x14(%r14), %xmm2
xorps %xmm1, %xmm1
cvtsi2sdl 0x10(%r14), %xmm1
divsd %xmm2, %xmm0
divsd %xmm1, %xmm0
mulsd 0x1098d(%rip), %xmm0    # 0x15010
movapd %xmm0, (%rsp)
leaq 0x10b0a(%rip), %rdi     # 0x15199
movb $0x1, %al
callq 0x3170
movapd (%rsp), %xmm0
mulsd 0x10975(%rip), %xmm0    # 0x15018
mulsd 0x10975(%rip), %xmm0    # 0x15020
cvttsd2si %xmm0, %rax
incl %eax
leaq (%rax,%rax,8), %rax
shlq $0x1f, %rax
movabsq $0x180000000, %r14      # imm = 0x180000000
addq %rax, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
callq 0x3060
movl (%rax), %edi
leaq 0x10a92(%rip), %rsi     # 0x1517a
movq %r14, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4749
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testl %edi, %edi
jne 0x4756
addq $0xd0, %rsp
popq %rbx
retq
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x17876(%rip), %rbx     # 0x1bff8
movq (%rbx), %rdi
callq 0x33f0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3250
movl $0x1, %edi
callq 0x3440
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/yhg926[P]public_kssd/command_composite.c
// Function: read_abv
int read_abv (composite_opt_t *composite_opt){
 for(int i =0; i<composite_opt->num_remaining_args;i++){
    const char *ext = strrchr(composite_opt->remaining_args[i],'.');
    if(strcmp(ext + 1, binVec_suffix) != 0){
      printf("%dth argument %s is not a .abv file, skipped\n",i,composite_opt->remaining_args[i]);
      continue;
    }
  struct stat st;
    stat(composite_opt->remaining_args[i], &st);
    binVec_t tmp_abv ;
  FILE *abvfh;;
    if(( abvfh = fopen(composite_opt->remaining_args[i],"rb") ) == NULL) err(errno, "read_abv():%s",composite_opt->remaining_args[i]);
  for(int l=0; l< st.st_size; l+=sizeof(binVec_t)) {
     fread(&tmp_abv,sizeof(binVec_t),1,abvfh);
   printf("%d\t%f\n",tmp_abv.ref_idx,tmp_abv.pct);
  }
  fclose(abvfh);
 }
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
cmpl $0x0, 0x314(%rdi)
jle 0x6565
movq %rdi, %rbx
movabsq $0x800000000, %r14      # imm = 0x800000000
leaq 0xee52(%rip), %rbp      # 0x152b8
leaq 0xef53(%rip), %r12      # 0x153c0
xorl %r15d, %r15d
movq %rdi, (%rsp)
movq 0x318(%rbx), %rax
movq (%rax,%r15,8), %r13
movq %r13, %rdi
movl $0x2e, %esi
callq 0x31d0
leaq 0x1(%rax), %rdi
movq %rbp, %rsi
callq 0x32b0
testl %eax, %eax
je 0x64b5
leaq 0xeee1(%rip), %rdi      # 0x15384
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3170
jmp 0x6552
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x32e0
movq 0x318(%rbx), %rax
movq %r15, 0x8(%rsp)
movq (%rax,%r15,8), %rdi
leaq 0xeb8e(%rip), %rsi      # 0x15067
callq 0x33a0
testq %rax, %rax
je 0x657c
movq %rax, %r13
movq 0x48(%rsp), %rbx
movq %r14, %rbp
testq %rbx, %rbx
leaq 0x10(%rsp), %r15
jle 0x6537
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r13, %rcx
callq 0x30c0
movl 0x10(%rsp), %esi
xorps %xmm0, %xmm0
cvtss2sd 0x14(%rsp), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x3170
movq %r14, %rax
sarq $0x20, %rax
addq %rbp, %r14
cmpq %rbx, %rax
jl 0x64fc
movq %r13, %rdi
callq 0x3100
movq (%rsp), %rbx
movq %rbp, %r14
leaq 0xed6b(%rip), %rbp      # 0x152b8
movq 0x8(%rsp), %r15
incq %r15
movslq 0x314(%rbx), %rax
cmpq %rax, %r15
jl 0x6474
movl $0x1, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
movq (%rsp), %rax
movq 0x318(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xee14(%rip), %rsi      # 0x153b2
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O3/yhg926[P]public_kssd/command_composite.c
// Function: parse_composite
static error_t parse_composite(int key, char* arg, struct argp_state* state) {
  struct arg_composite* composite = state->input;
  assert( composite );
  assert( composite->global );
  switch(key)
  {
  case 'b':
  {
   composite_opt.b = 1;
   break;
  }
  case 'i':
  {
    composite_opt.i = 1;
    break;
  }
  case 's':
  {
    composite_opt.s = atoi(arg);
    break;
  }
  case 'd':
  {
   composite_opt.d = 1;
   break;
  }
  case 'p':
  {
   composite_opt.p = atoi(arg);
   break;
  }
  case 'r':
  {
   strcpy(composite_opt.refdir, arg);
   break;
  }
  case 'q':
  {
   strcpy(composite_opt.qrydir, arg);
   break;
  }
  case 'o':
  {
   strcpy(composite_opt.outdir, arg);
   break;
  }
  case ARGP_KEY_ARGS:
  {
   composite_opt.num_remaining_args = state->argc - state->next;
   composite_opt.remaining_args = state->argv + state->next;
   break;
  }
    case ARGP_KEY_NO_ARGS:
    {
   if(state->argc<2)
   {
       printf("\v");
    argp_state_help(state,stdout,ARGP_HELP_SHORT_USAGE);
    printf("\v");
       argp_state_help(state,stdout,ARGP_HELP_LONG);
       printf("\v");
       return EINVAL;
   }
    }
  break;
    default:
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdx), %rax
testq %rax, %rax
je 0x6726
cmpq $0x0, (%rax)
je 0x6745
movl $0x7, %eax
leal -0x62(%rdi), %ecx
cmpl $0x11, %ecx
ja 0x663b
leaq 0xec4d(%rip), %rdx      # 0x15270
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, 0x15c4a(%rip)     # 0x1c280
jmp 0x66c8
movq %rdx, %rbx
cmpl $0x1000002, %edi        # imm = 0x1000002
je 0x66d2
cmpl $0x1000006, %edi        # imm = 0x1000006
jne 0x66ca
movl 0x8(%rbx), %eax
movslq 0x18(%rbx), %rcx
subl %ecx, %eax
movl %eax, 0x15f33(%rip)     # 0x1c594
shlq $0x3, %rcx
addq 0x10(%rbx), %rcx
movq %rcx, 0x15f28(%rip)     # 0x1c598
jmp 0x66c8
leaq 0x15d1b(%rip), %rdi     # 0x1c394
jmp 0x66c3
leaq 0x15c12(%rip), %rdi     # 0x1c294
jmp 0x66c3
movq %rsi, %rdi
callq 0x3410
movl %eax, 0x15bf6(%rip)     # 0x1c288
jmp 0x66c8
movl $0x1, 0x15bee(%rip)     # 0x1c28c
jmp 0x66c8
movq %rsi, %rdi
callq 0x3410
movl %eax, 0x15be2(%rip)     # 0x1c290
jmp 0x66c8
movl $0x1, 0x15bca(%rip)     # 0x1c284
jmp 0x66c8
leaq 0x15dd1(%rip), %rdi     # 0x1c494
callq 0x3080
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
cmpl $0x1, 0x8(%rbx)
jg 0x66ca
movl $0xb, %edi
callq 0x3050
movq 0x158ed(%rip), %r14     # 0x1bfd8
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x30e0
movl $0xb, %edi
callq 0x3050
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x30e0
movl $0xb, %edi
callq 0x3050
movl $0x16, %eax
jmp 0x66ca
leaq 0xebb3(%rip), %rdi      # 0x152e0
leaq 0xef95(%rip), %rsi      # 0x156c9
leaq 0xefa2(%rip), %rcx      # 0x156dd
movl $0x49, %edx
callq 0x3200
leaq 0xefcb(%rip), %rdi      # 0x15717
leaq 0xef76(%rip), %rsi      # 0x156c9
leaq 0xef83(%rip), %rcx      # 0x156dd
movl $0x4a, %edx
callq 0x3200
// File: /workspace/github_c_makefile_star2_O3/yhg926[P]public_kssd/command_dist.c
// Function: test_get_fullpath
const char* test_get_fullpath(const char *parent_path, const char *dstat_f)
{
 struct stat path_stat;
  if( stat(parent_path, &path_stat) < 0 )
  err(errno,"test_get_fullpath()::%s",parent_path);
  if( S_ISDIR(path_stat.st_mode) ){
  char* fullpath = malloc(PATHLEN+1);
  sprintf((char *)fullpath,"%s/%s", parent_path, dstat_f);
  FILE *fp;
  if ( (fp = fopen(fullpath,"rb")) != NULL ){
   fclose(fp);
   return fullpath;
  }
  else{
   free((char*)fullpath);
   return NULL;
  }
 }
 else
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rsi
callq 0x32e0
testl %eax, %eax
js 0x6e04
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x6df1
movl $0x101, %edi            # imm = 0x101
callq 0x3340
movq %rax, %r14
leaq 0xe628(%rip), %rsi      # 0x153e3
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3430
leaq 0xe295(%rip), %rsi      # 0x15067
movq %r14, %rdi
callq 0x33a0
testq %rax, %rax
je 0x6de9
movq %rax, %rdi
callq 0x3100
jmp 0x6df4
movq %r14, %rdi
callq 0x3040
xorl %r14d, %r14d
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0xef3c(%rip), %rsi      # 0x15d4e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O3/yhg926[P]public_kssd/command_dist.c
// Function: dist_organize_refpath
infile_tab_t* dist_organize_refpath( dist_opt_val_t *opt_val){
 struct stat path_stat;
 if( stat(opt_val->refpath, &path_stat) < 0)
  err(errno,"dist_organize_refpath():%s",opt_val->refpath);
 if( S_ISDIR(path_stat.st_mode) || isOK_fmt_infile(opt_val->refpath, acpt_infile_fmt,ACPT_FMT_SZ) ){
  char * tmp_arg[] = {opt_val->refpath};
  return organize_infile_frm_arg(1, tmp_arg,1);
 }
 else if(S_ISREG(path_stat.st_mode))
  return organize_infile_list(opt_val->refpath,1);
 else
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
addq $0x122, %rbx            # imm = 0x122
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x32e0
testl %eax, %eax
js 0x6fbc
movl $0xf000, %ebp           # imm = 0xF000
andl 0x28(%rsp), %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
je 0x6f64
movq %rbx, %rdi
callq 0x3130
movq %rax, %r14
xorl %r13d, %r13d
leaq 0x1718a(%rip), %r12     # 0x1e000
xorl %ecx, %ecx
movq (%r12,%rcx,8), %r15
movq %r15, %rdi
callq 0x3130
movl %r14d, %ecx
subl %eax, %ecx
movslq %ecx, %rdi
addq %rbx, %rdi
movq %r15, %rsi
callq 0x32b0
testb $0x1, %r13b
jne 0x6ea9
movl $0x1, %ecx
movb $0x1, %r13b
testl %eax, %eax
jne 0x6e78
testl %eax, %eax
leaq 0xa0(%rsp), %r14
cmovneq %rbx, %r14
leaq 0x170c2(%rip), %rax     # 0x1df80
movq (%rax), %rdx
leaq 0xe504(%rip), %rsi      # 0x153cc
leaq 0x6(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3430
movq %r14, %rdi
callq 0x3130
leaq (%rax,%r14), %r12
movq %r15, %rdi
callq 0x3130
subq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
testl %eax, %eax
je 0x6f64
movl %ebp, (%rsp)
movq $-0x1, %rbp
leaq 0xe4be(%rip), %r15      # 0x153cc
leaq 0x6(%rsp), %r12
cmpq $0x5, %rbp
je 0x6f90
leaq 0x17060(%rip), %rax     # 0x1df80
movq 0x10(%rax,%rbp,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3430
movq %r14, %rdi
callq 0x3130
leaq (%rax,%r14), %r13
movq %r12, %rdi
callq 0x3130
subq %rax, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x32b0
incq %rbp
testl %eax, %eax
jne 0x6f13
cmpq $0x6, %rbp
movl (%rsp), %eax
jae 0x6f93
leaq 0xa0(%rsp), %rsi
movq %rbx, (%rsi)
movl $0x1, %edi
movl $0x1, %edx
callq 0x11a96
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x6fb8
movq %rbx, %rdi
movl $0x1, %esi
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11633
xorl %eax, %eax
jmp 0x6f7e
callq 0x3060
movl (%rax), %edi
leaq 0xf460(%rip), %rsi      # 0x1642a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O3/yhg926[P]public_kssd/command_dist.c
// Function: get_dim_shuffle
dim_shuffle_t *get_dim_shuffle( dist_opt_val_t *opt_val_in )
{
 char shuf_infile_name_prefix[PATHLEN+9];
  char shuf_infile_name[PATHLEN];
  strcpy(shuf_infile_name, opt_val_in->dr_file);
  if( strcmp( shuf_infile_name, "" ) == 0 )
  {
    srand ( time(NULL) );
    dim_shuffle_stat_t dim_shuffle_stat =
    {
      rand(),
      opt_val_in->k,
      opt_val_in->dr_level + add_len_drlevel2subk(),
      opt_val_in->dr_level,
    };
  struct stat outd;
  if( (stat(opt_val_in->outdir, &outd) != 0 ) || (! S_ISDIR(outd.st_mode) ) )
   mkdir(opt_val_in->outdir,0777);
  sprintf(shuf_infile_name_prefix, "%s/default",opt_val_in->outdir);
    write_dim_shuffle_file( &dim_shuffle_stat,shuf_infile_name_prefix);
    sprintf(shuf_infile_name,"%s.shuf",shuf_infile_name_prefix);
  };
  return read_dim_shuffle_file(shuf_infile_name);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0x3080
cmpb $0x0, (%r14)
jne 0x70a6
xorl %edi, %edi
callq 0x3310
movl %eax, %edi
callq 0x3270
callq 0x34c0
movl %eax, (%rsp)
movl (%rbx), %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rbx), %ebp
callq 0x1129b
addl %ebp, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rbx), %eax
movl %eax, 0xc(%rsp)
addq $0x322, %rbx            # imm = 0x322
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x32e0
testl %eax, %eax
jne 0x7059
movl $0xf000, %eax           # imm = 0xF000
andl 0x28(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x7066
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3090
leaq 0xeb7e(%rip), %rsi      # 0x15beb
leaq 0x1a0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3430
movq %rsp, %rdi
movq %r14, %rsi
callq 0x10f90
leaq 0xeb62(%rip), %rsi      # 0x15bf6
leaq 0xa0(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3430
leaq 0xa0(%rsp), %rdi
callq 0x112a1
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yhg926[P]public_kssd/command_dist.c
// Function: get_hashsz
int get_hashsz(dim_shuffle_t *dim_shuffle_in )
{
 llong ctx_space_sz = 1LLU << 4*( dim_shuffle_in->dim_shuffle_stat.k - dim_shuffle_in->dim_shuffle_stat.drlevel );
  int primer_ind = 4*( dim_shuffle_in->dim_shuffle_stat.k - dim_shuffle_in->dim_shuffle_stat.drlevel ) - CTX_SPC_USE_L - 7;
  if(primer_ind < 0 || primer_ind > 24 ){
    int k_add = primer_ind < 0 ? (1 + (0-primer_ind)/4) : - (1 + ( primer_ind - 24 )/4) ;
    err(errno,"get_hashsz(): primer_ind: %d out of range(0 ~ 24), by formula:\n"
    "int primer_ind = 4*(opt_val->k - dim_shuffle->dim_shuffle_stat.drlevel) - CTX_SPC_USE_L - 7\n"
    "this might caused by too small or too large k\n"
    "kmer length = %d\n"
    "dim reduction level = %d\n"
    "ctx_space size = %llu\n"
    "CTX space usage limit = %lf\n\n"
    "try rerun the program with option -k = %d",
    primer_ind, dim_shuffle_in->dim_shuffle_stat.k, dim_shuffle_in->dim_shuffle_stat.drlevel,ctx_space_sz,
       (double)1/(1 << CTX_SPC_USE_L),dim_shuffle_in->dim_shuffle_stat.k + k_add );
  };
  int hashsize_get = primer[primer_ind];
 return hashsize_get ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rdi), %ebx
movl 0xc(%rdi), %ebp
movl %ebx, %eax
subl %ebp, %eax
leal -0xf(,%rax,4), %r14d
leal -0xa(%rax), %ecx
cmpl $-0x7, %ecx
jbe 0x7100
movl %r14d, %eax
leaq 0x10c22(%rip), %rcx     # 0x17d10
movl (%rcx,%rax,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal (,%rax,4), %ecx
cmpl $0x3, %eax
jg 0x7121
movl $0xc, %r12d
subl %ecx, %r12d
shrl $0x2, %r12d
movl $0x1, %r13d
jmp 0x713b
leal -0x27(%rcx), %eax
leal -0x24(%rcx), %r12d
testl %eax, %eax
cmovnsl %eax, %r12d
sarl $0x2, %r12d
negl %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0x1, %r15d
shlq %cl, %r15
callq 0x3060
movl (%rax), %edi
addl %ebx, %r13d
addl %r12d, %r13d
movl %r13d, (%rsp)
leaq 0xeaa2(%rip), %rsi      # 0x15bfe
movsd 0xe5f4(%rip), %xmm0     # 0x15758
movl %r14d, %edx
movl %ebx, %ecx
movl %ebp, %r8d
movq %r15, %r9
movb $0x1, %al
callq 0x3330