LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/libsquish/maths.cpp
// Function: squish::ComputeWeightedCovariance(int, squish::Vec3 const*, float const*)
Sym3x3 ComputeWeightedCovariance( int n, Vec3 const* points, float const* weights )
{
    // compute the centroid
    float total = 0.0f;
    Vec3 centroid( 0.0f );
    for( int i = 0; i < n; ++i )
    {
        total += weights[i];
        centroid += weights[i]*points[i];
    }
    if( total > FLT_EPSILON )
        centroid /= total;

    // accumulate the covariance matrix
    Sym3x3 covariance( 0.0f );
    for( int i = 0; i < n; ++i )
    {
        Vec3 a = points[i] - centroid;
        Vec3 b = weights[i]*a;

        covariance[0] += a.X()*b.X();
        covariance[1] += a.X()*b.Y();
        covariance[2] += a.X()*b.Z();
        covariance[3] += a.Y()*b.Y();
        covariance[4] += a.Y()*b.Z();
        covariance[5] += a.Z()*b.Z();
    }

    // return it
    return covariance;
}

// Assembly:
movq %rdi, %rax
xorps %xmm1, %xmm1
movl %esi, %edi
testl %esi, %esi
jle 0x7051c
leaq 0x8(%rdx), %r8
xorps %xmm2, %xmm2
xorps %xmm3, %xmm3
xorl %r9d, %r9d
xorps %xmm0, %xmm0
movss (%rcx,%r9,4), %xmm4
addss %xmm4, %xmm3
movsd -0x8(%r8), %xmm5
movaps %xmm4, %xmm6
shufps $0x0, %xmm4, %xmm6      # xmm6 = xmm6[0,0],xmm4[0,0]
mulps %xmm5, %xmm6
addps %xmm6, %xmm2
mulss (%r8), %xmm4
addss %xmm4, %xmm0
incq %r9
addq $0xc, %r8
cmpq %r9, %rdi
jne 0x704e8
jmp 0x70525
xorps %xmm0, %xmm0
xorps %xmm3, %xmm3
xorps %xmm2, %xmm2
xorl %r8d, %r8d
ucomiss 0xd461(%rip), %xmm3     # 0x7d990
seta %r9b
movss 0x5a59(%rip), %xmm4     # 0x75f94
divss %xmm3, %xmm4
movups %xmm1, (%rax)
movq $0x0, 0x10(%rax)
jbe 0x70550
mulss %xmm4, %xmm0
testl %esi, %esi
jle 0x70605
movb %r9b, %r8b
movd %r8d, %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
shufps $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
pslld $0x1f, %xmm1
mulps %xmm2, %xmm4
psrad $0x1f, %xmm1
andps %xmm1, %xmm4
andnps %xmm2, %xmm1
orps %xmm4, %xmm1
movups 0x4(%rax), %xmm4
movss 0x14(%rax), %xmm3
addq $0x8, %rdx
xorps %xmm2, %xmm2
xorl %esi, %esi
movsd -0x8(%rdx), %xmm6
subps %xmm1, %xmm6
movss (%rdx), %xmm5
subss %xmm0, %xmm5
movss (%rcx,%rsi,4), %xmm7
movaps %xmm6, %xmm8
mulss %xmm7, %xmm8
movaps %xmm5, %xmm9
shufps $0xd4, %xmm6, %xmm9     # xmm9 = xmm9[0,1],xmm6[1,3]
shufps $0x52, %xmm6, %xmm9     # xmm9 = xmm9[2,0],xmm6[1,1]
mulss %xmm6, %xmm8
unpcklps %xmm6, %xmm6            # xmm6 = xmm6[0,0,1,1]
shufps $0x0, %xmm7, %xmm7      # xmm7 = xmm7[0,0,0,0]
mulps %xmm9, %xmm7
movaps %xmm7, %xmm9
shufps $0x55, %xmm7, %xmm9     # xmm9 = xmm9[1,1],xmm7[1,1]
movlhps %xmm7, %xmm7            # xmm7 = xmm7[0,0]
mulps %xmm6, %xmm7
addps %xmm7, %xmm4
addss %xmm8, %xmm2
mulss %xmm5, %xmm9
addss %xmm9, %xmm3
incq %rsi
addq $0xc, %rdx
cmpq %rsi, %rdi
jne 0x70591
movups %xmm4, 0x4(%rax)
movss %xmm3, 0x14(%rax)
jmp 0x70608
xorps %xmm2, %xmm2
movss %xmm2, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x70260
leaq 0x20dec(%rip), %rax     # 0x91c40
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
movss 0x8451(%rip), %xmm0     # 0x792b4
movss 0x4(%rcx), %xmm1
mulss %xmm0, %xmm1
movss 0x8434(%rip), %xmm2     # 0x792a8
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_O1/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 0x20d78(%rip), %rsi     # 0x91c60
callq 0x70f2c
movl 0x34(%rbx), %eax
cmpl 0x38(%rbx), %eax
jge 0x70f21
movq 0x8(%rbx), %rdi
leaq 0x30(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x704a6
leaq 0x18(%rbx), %rdi
leaq 0x24(%rbx), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x6ff28
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_O1/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 0x20c54(%rip), %rsi     # 0x91c80
callq 0x70f2c
movl 0x34(%rbx), %eax
cmpl 0x38(%rbx), %eax
jge 0x71065
movq 0x8(%rbx), %rdi
leaq 0x30(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x704a6
leaq 0x18(%rbx), %rdi
leaq 0x24(%rbx), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x70066
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_O1/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 0x1139
cmpl $0x0, (%rbx)
je 0x1139
xorl %ecx, %ecx
jmp 0x1228
cvttsd2si %xmm0, %r15
movq %r15, %r14
negq %r14
cmovsq %r15, %r14
movq %r14, %rax
shrq $0xc, %rax
cmpq $0xe8d4a51, %rax        # imm = 0xE8D4A51
jb 0x1161
movl $0x120001, %eax         # imm = 0x120001
jmp 0x121f
movapd %xmm0, (%rsp)
movl $0x20, %edi
callq 0x1040
testq %rax, %rax
je 0x121a
movq %rax, %rcx
movsd 0xe7c(%rip), %xmm0      # 0x2000
movapd (%rsp), %xmm1
mulsd %xmm0, %xmm1
andpd 0xe8b(%rip), %xmm1      # 0x2020
addsd 0xe6b(%rip), %xmm1      # 0x2008
cvttsd2si %xmm1, %rax
movq %r15, %rsi
movq %rax, %rdx
subsd 0xe60(%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 0x1206
xorpd 0xe2a(%rip), %xmm1      # 0x2030
xorl %eax, %eax
movsd %xmm1, (%rcx)
movb %sil, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movw %di, 0x18(%rcx)
jmp 0x1221
movl $0x80000001, %eax       # imm = 0x80000001
xorl %ecx, %ecx
testq %rbx, %rbx
je 0x1228
movl %eax, (%rbx)
movq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e5b
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x128c
movq 0x10(%rbx), %rdi
callq 0x1150
cmpl $0x8, %eax
jb 0x3e6e
leaq 0x6dd(%rip), %rdi       # 0x452a
callq 0x1060
xorl %eax, %eax
callq 0x12ca
jmp 0x3e67
leaq 0x763(%rip), %rdi       # 0x45c5
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3ed6
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 0x31f8
cmpb $0x2f, %r15b
jne 0x3ea7
testl %eax, %eax
jne 0x3eab
movq 0x18(%rbx), %rsi
leaq 0x69b(%rip), %rdi       # 0x4540
jmp 0x3ec6
testl %eax, %eax
je 0x3ebb
leaq 0x6bb(%rip), %rdi       # 0x456d
xorl %eax, %eax
callq 0x1090
jmp 0x3ecd
movq 0x18(%rbx), %rsi
leaq 0x6d5(%rip), %rdi       # 0x459b
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_O1/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 0x165b
movq %rbx, %rdi
callq 0x124c
movl %eax, %ebp
movq %r14, 0x58(%rbx)
movq %rbx, %rdi
callq 0x124c
testl %eax, %eax
jne 0x163f
jmp 0x165d
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1b90
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x171a
cmpl $0x1ff, %eax            # imm = 0x1FF
ja 0x16cb
movl $0x1ff, %ecx            # imm = 0x1FF
subl %eax, %ecx
movl $0xff, %eax
jmp 0x171a
cmpl $0x2ff, %eax            # imm = 0x2FF
ja 0x16e3
movl %eax, %edx
addl $0xfffffe00, %edx       # imm = 0xFFFFFE00
movl $0xff, %eax
xorl %ecx, %ecx
jmp 0x171a
cmpl $0x3ff, %eax            # imm = 0x3FF
ja 0x16fc
movl $0x3ff, %esi            # imm = 0x3FF
subl %eax, %esi
movl $0xff, %edx
xorl %ecx, %ecx
movl %esi, %eax
jmp 0x171a
cmpl $0x4ff, %eax            # imm = 0x4FF
ja 0x1711
addl $0xfffffc00, %eax       # imm = 0xFFFFFC00
movl $0xff, %edx
movl %eax, %ecx
jmp 0x1718
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_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x124c
movzbl %al, %ebp
shll $0x10, %ebp
movq %rbx, %rdi
callq 0x124c
shll $0x8, %eax
movzwl %ax, %r14d
orl %ebp, %r14d
movq %rbx, %rdi
callq 0x124c
movzbl %al, %eax
orl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x124c
movl %eax, %ebp
movq %r14, %rdi
callq 0x124c
movl %eax, %ebx
movq %r14, %rdi
callq 0x124c
movl $0xff, %ecx
andl %ecx, %eax
leal 0x1(%rax), %edx
xorl %ecx, %eax
movl %ebp, %edi
shrl $0x10, %edi
andl %ecx, %edi
imull %eax, %edi
movl %ebx, %esi
shrl $0x10, %esi
andl %ecx, %esi
imull %edx, %esi
addl %edi, %esi
shll $0x8, %esi
andl $0x3ff0000, %esi        # imm = 0x3FF0000
movl %ebp, %edi
shrl $0x8, %edi
andl %ecx, %edi
imull %eax, %edi
movl %ebx, %r8d
shrl $0x8, %r8d
andl %ecx, %r8d
imull %edx, %r8d
addl %edi, %r8d
andl $0x3ff00, %r8d          # imm = 0x3FF00
andl %ecx, %ebp
imull %ebp, %eax
andl %ecx, %ebx
imull %edx, %ebx
addl %ebx, %eax
shrl $0x8, %eax
orl %r8d, %eax
orl %esi, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x290f(%rip), %eax      # 0x4100
movl %eax, %edx
shll $0x7, %edx
shrl $0x19, %eax
movl 0x2881(%rip), %esi      # 0x4080
addl %esi, %eax
xorl %edx, %eax
movl %eax, 0x28f7(%rip)      # 0x4100
movl %esi, %edx
shll $0x7, %edx
shrl $0x19, %esi
addl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
xorl %edx, %esi
movl %esi, 0x2861(%rip)      # 0x4080
xorl %edx, %edx
divl %ecx
movl %edx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1858
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_O1/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 0x1879
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x124c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x124c
movl $0xff, %r8d
andl %r8d, %eax
movl $0x100, %ecx            # imm = 0x100
subl %eax, %ecx
incl %eax
movl %ebp, %r9d
shrl $0x10, %r9d
andl %r8d, %r9d
imull %eax, %r9d
movl %ebp, %esi
shrl $0x8, %esi
andl %r8d, %esi
imull %eax, %esi
movl %ebp, %edi
andl %r8d, %edi
imull %eax, %edi
movq $-0x3, %rax
movzbl 0x23(%rbx,%rax), %edx
imull %ecx, %edx
addl %r9d, %edx
movb %dh, 0x23(%rbx,%rax)
movzbl 0x24(%rbx,%rax), %edx
imull %ecx, %edx
addl %esi, %edx
movb %dh, 0x24(%rbx,%rax)
movzbl 0x25(%rbx,%rax), %edx
imull %ecx, %edx
addl %edi, %edx
movb %dh, 0x25(%rbx,%rax)
addq $0x3, %rax
cmpq $0x15, %rax
jb 0x18e0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x124c
movl %eax, %ebp
movq %r14, %rdi
callq 0x124c
xorl %r15d, %r15d
testl %eax, %eax
setne %r15b
movzbl %bpl, %esi
movl %ebx, %edi
movl %r15d, %edx
callq *0x8(%r14)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movl $0x2, %r15d
testq %rax, %rax
jne 0x1a23
subw $0x1, %bp
jb 0x1a46
movb (%rbx), %dl
movzwl 0x2(%r14), %ecx
movl %ecx, %esi
incl %esi
movw %si, 0x2(%r14)
movl %ecx, %esi
andw $0xff, %si
sete %dil
cmpb $0x28, %dl
sete %r8b
testb %r8b, %dil
jne 0x19db
movzbl %dl, %edx
cmpw $0x1, %si
jne 0x19bf
cmpb $0x5d, %dl
je 0x19db
cmpb $0x3, %cl
je 0x19ea
movzbl %cl, %esi
movl $0x1, %ecx
cmpl $0x2, %esi
jne 0x19e0
movzwl %dx, %ecx
shll $0x8, %ecx
movw %cx, (%r14)
movl $0x2, %ecx
incq %rbx
cmpl $0x2, %ecx
je 0x1977
jmp 0x1a1e
orw (%r14), %dx
addl $-0x6, %edx
movw %dx, (%r14)
movw $0x0, 0x2(%r14)
movzwl %dx, %r12d
movq %r12, %rdi
callq 0x10b0
movq %rax, 0x8(%r14)
xorl %ecx, %ecx
testw %r12w, %r12w
setne %cl
leal 0x1(,%rcx,2), %ecx
jmp 0x19e0
cmpl $0x1, %ecx
je 0x1a82
movl (%r14), %eax
movzwl 0x2(%r14), %edi
subl %edi, %eax
cmpw %ax, %bp
jae 0x1a4e
addq 0x8(%r14), %rdi
movzwl %bp, %edx
movq %rbx, %rsi
callq 0x1090
addw %bp, 0x2(%r14)
movl $0x1, %r15d
jmp 0x1a82
movzwl %bp, %ebp
addq 0x8(%r14), %rdi
movzwl %ax, %r14d
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1090
leaq 0x1(%r14), %rax
cmpl %ebp, %eax
jae 0x1a7f
movl $0x3, %r15d
cmpb $0x5b, (%rbx,%r14)
jne 0x1a82
cmpb $0x29, (%rbx,%rax)
jne 0x1a82
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1030
movq $0x0, 0x8(%rbx)
movl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
movq %rsp, %rbx
leaq 0x262b(%rip), %r14      # 0x40f0
leaq 0x25bc(%rip), %r12      # 0x4088
leaq 0x764(%rip), %r13       # 0x2237
movl $0x10, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1070
testq %rax, %rax
js 0x1b5d
movb $0x1, %r15b
je 0x1b56
movzwl %ax, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x195d
cmpl $0x1, %eax
je 0x1b73
testl %eax, %eax
jne 0x1b6c
movq 0x25ee(%rip), %rbp      # 0x40f8
leaq 0x861(%rip), %rdi       # 0x2372
callq 0x1050
movq %rbp, 0x25c3(%rip)      # 0x40e0
movq %r12, %rdi
callq 0x124c
xorl %ebp, %ebp
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq 0x25be(%rip), %rdi      # 0x40f8
callq 0x1030
movq $0x0, 0x25ae(%rip) # 0x40f8
movl $0x0, 0x259c(%rip)      # 0x40f0
jmp 0x1b76
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1b76
callq 0x112b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movb $0x1, %r15b
jmp 0x1b76
movl %eax, %edi
callq 0x10f0
xorl %r15d, %r15d
testb %r15b, %r15b
je 0x1ad3
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
leaq 0x54d(%rip), %r15       # 0x20ec
movq 0x58(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x58(%rbx)
movzbl (%rax), %r14d
testb %r14b, %r14b
jns 0x1c32
leal -0x80(%r14), %ecx
cmpl $0x39, %ecx
ja 0x1c03
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x1b90
movq %rbx, %rdi
callq 0x1b90
movq %rbx, %rdi
callq 0x1b90
jmp 0x1b9f
movq %rbx, %rdi
callq 0x1b90
movq 0x58(%rbx), %rax
cmpb $-0x53, (%rax)
jne 0x1be0
incq %rax
jmp 0x1c2e
leaq 0x5d7(%rip), %rsi       # 0x21d4
movl %r14d, %edi
callq *0x10(%rbx)
movq 0x10(%rbx), %rax
leaq 0x5d5(%rip), %rsi       # 0x21e3
movl %r14d, %edi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
addq $0x2, %rax
jmp 0x1c2e
addq $0x5, %rax
jmp 0x1c2e
addq $0x3, %rax
jmp 0x1c2e
addq $0x4, %rax
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/simulate.c
// Function: on_update
static void on_update(uint8_t *pixels)
{
  static bool first = true;
  if (first)
  {
    first = false;
  }
  else
  {
    printf("\x1b[5A");
  }
  printf(
      "   \x1b[38;2;%d;%d;%dm◢■■◣\x1b[0m\n"
      " \x1b[38;2;%d;%d;%dm◢■◤\x1b[0m  \x1b[38;2;%d;%d;%dm◥■◣\x1b[0m\n"
      "\x1b[38;2;%d;%d;%dm■■\x1b[0m      \x1b[38;2;%d;%d;%dm■■\x1b[0m\n"
      " \x1b[38;2;%d;%d;%dm◥■◣\x1b[0m  \x1b[38;2;%d;%d;%dm◢■◤\x1b[0m\n"
      "   \x1b[38;2;%d;%d;%dm◥■■◤\x1b[0m\n",
      pixels[0], pixels[1], pixels[2],
      pixels[21], pixels[22], pixels[23],
      pixels[3], pixels[4], pixels[5],
      pixels[18], pixels[19], pixels[20],
      pixels[6], pixels[7], pixels[8],
      pixels[15], pixels[16], pixels[17],
      pixels[9], pixels[10], pixels[11],
      pixels[12], pixels[13], pixels[14]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x24b4(%rip)      # 0x4104
je 0x1c62
leaq 0x5e9(%rip), %rdi       # 0x2242
xorl %eax, %eax
callq 0x1060
jmp 0x1c69
movb $0x1, 0x249b(%rip)      # 0x4104
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edx
movzbl 0x2(%rbx), %ecx
movzbl 0x15(%rbx), %r8d
movzbl 0x16(%rbx), %r9d
movzbl 0x17(%rbx), %eax
movq %rax, 0x50(%rsp)
movzbl 0x3(%rbx), %eax
movq %rax, 0x48(%rsp)
movzbl 0x4(%rbx), %eax
movq %rax, 0x40(%rsp)
movzbl 0x5(%rbx), %eax
movq %rax, 0x38(%rsp)
movzbl 0x12(%rbx), %eax
movq %rax, 0x30(%rsp)
movzbl 0x13(%rbx), %eax
movq %rax, 0x28(%rsp)
movzbl 0x14(%rbx), %eax
movq %rax, 0x20(%rsp)
movzbl 0x6(%rbx), %eax
movq %rax, 0x18(%rsp)
movzbl 0x7(%rbx), %eax
movq %rax, 0x10(%rsp)
movzbl 0x8(%rbx), %eax
movq %rax, 0x8(%rsp)
movzbl 0xf(%rbx), %eax
movq %rax, (%rsp)
movzbl 0x10(%rbx), %r12d
movzbl 0x11(%rbx), %r13d
movzbl 0x9(%rbx), %ebp
movzbl 0xa(%rbx), %r10d
movzbl 0xb(%rbx), %r11d
movzbl 0xc(%rbx), %r14d
movzbl 0xd(%rbx), %r15d
movzbl 0xe(%rbx), %ebx
subq $0x8, %rsp
leaq 0x536(%rip), %rdi       # 0x2247
xorl %eax, %eax
pushq %rbx
pushq %r15
pushq %r14
pushq %r11
pushq %r10
pushq %rbp
pushq %r13
pushq %r12
pushq 0x48(%rsp)
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
pushq 0x88(%rsp)
pushq 0x98(%rsp)
pushq 0xa8(%rsp)
pushq 0xb8(%rsp)
pushq 0xc8(%rsp)
pushq 0xd8(%rsp)
pushq 0xe8(%rsp)
callq 0x1060
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x18, %rsp
movl %edi, %eax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %edi
imull $0x3e8, %edi, %eax      # imm = 0x3E8
movq %rax, 0x8(%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x10a0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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        # 0x3dd1
xorl %esi, %esi
xorl %edx, %edx
callq 0x4f24
movq %rax, %rbx
leaq 0x13ad(%rip), %rsi      # 0x519e
movq %rax, %rdi
callq 0x51a4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x50f8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5101
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x24fb(%rip), %rsi      # 0x6318
leaq 0x27e8(%rip), %rcx      # 0x660c
leaq 0x24fb(%rip), %r8       # 0x6326
movl $0x1d, %edx
xorl %eax, %eax
callq 0x25ec
testl %eax, %eax
je 0x3e79
movq %rbx, %rdi
callq 0x4fe0
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x24c6(%rip), %rsi      # 0x6318
leaq 0x27b3(%rip), %rcx      # 0x660c
leaq 0x24d2(%rip), %r8       # 0x6332
movl $0x1e, %edx
xorl %eax, %eax
callq 0x25ec
testl %eax, %eax
je 0x3e79
movq %rbx, %rdi
popq %rbx
jmp 0x510a
callq 0x2e33
// File: /workspace/github_c_makefile_star2_O1/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 0x3f34
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 0x3ef8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x26d6(%rip), %rbx      # 0x40d0
movq %rbx, %rdi
callq 0x10f0
testq %r14, %r14
je 0x1a20
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1060
movw $0x20, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb 0x43e8(%rip), %bl       # 0x60d0
testb %bl, %bl
jne 0x1db8
leaq 0x33d9(%rip), %rdi      # 0x50d0
callq 0x1060
movl 0x43f6(%rip), %edx      # 0x60f8
cmpl %eax, %edx
setge %al
cmpl $0x6, %edx
setl %cl
orb %al, %cl
jne 0x1db8
addq $-0x5, %rdx
leaq 0x33b5(%rip), %rdi      # 0x50d5
movl $0x20, %esi
callq 0x10a0
movl $0x2d206d72, 0x339c(%rip) # imm = 0x2D206D72
movb $0x66, 0x3399(%rip)     # 0x50d4
movq 0x4396(%rip), %r14      # 0x60d8
testq %r14, %r14
je 0x1dbe
leaq 0x3382(%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 0x924(%rip), %rsi       # 0x269c
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1110
cmpb $0x1, 0x4341(%rip)      # 0x60d0
jne 0x1d99
movq %rbx, %rdi
callq 0x1050
cmpb $0x1, 0x4330(%rip)      # 0x60d0
jne 0x1db3
leaq 0x41b(%rip), %rdi       # 0x21c4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
jmp 0x1df3
popq %rbx
popq %r14
popq %r15
retq
testb %bl, %bl
je 0x1dce
leaq 0x3307(%rip), %rdi      # 0x50d0
callq 0x1050
cmpb $0x1, 0x42fb(%rip)      # 0x60d0
jne 0x1dec
leaq 0x3e6(%rip), %rdi       # 0x21c4
leaq 0x32eb(%rip), %rsi      # 0x50d0
xorl %eax, %eax
callq 0x1080
leaq 0x32dd(%rip), %rdi      # 0x50d0
popq %rbx
popq %r14
popq %r15
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x43e6
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 0x43e6
incq %rbx
leaq (%rax,%rbx,4), %r15
xorl %ebx, %ebx
testl %ebx, %ebx
je 0x4368
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 0x43ce
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 0x4399
shll $0x2, %edx
subq %rdx, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x32f0
jmp 0x43c5
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 0x4331
jmp 0x43e9
movq %r12, %r13
incq %rbp
movq %r13, %r12
cmpq $0x10000000, %rbp       # imm = 0x10000000
jne 0x42e3
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_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x10c3e(%rip), %rsi     # 0x1506a
callq 0x33a0
testq %rax, %rax
je 0x44ab
movq %rax, %r14
movq %rsp, %r12
movq $0x0, (%r12)
xorl %r15d, %r15d
xorl %eax, %eax
cmpq $0x0, (%rbx,%rax,8)
je 0x4481
incl %r15d
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x3450
movq (%rsp), %rax
movq (%rbx,%rax,8), %rdi
movl (%rdi), %edx
incl %edx
movl $0x4, %esi
movq %r14, %rcx
callq 0x3450
movq (%rsp), %rax
incq %rax
movq %rax, (%rsp)
cmpq $0x10000000, %rax       # imm = 0x10000000
jb 0x4449
movq %r14, %rdi
callq 0x3100
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3060
movl (%rax), %edi
leaq 0x10c90(%rip), %rsi     # 0x15149
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/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 0x10b93(%rip), %rsi     # 0x15067
callq 0x33a0
testq %rax, %rax
je 0x4598
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 0x457f
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 0x451e
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 0x10bbc(%rip), %rsi     # 0x15162
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/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 0x45c5
callq 0x3040
incq %r14
cmpq $0x10000000, %r14       # imm = 0x10000000
jne 0x45b7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O1/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 0x10a6b(%rip), %rsi     # 0x15067
callq 0x33a0
testq %rax, %rax
je 0x46be
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 0x109fc(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x10a04(%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 0x109a9(%rip), %xmm0    # 0x15010
movapd %xmm0, (%rsp)
leaq 0x10b26(%rip), %rdi     # 0x15199
movb $0x1, %al
callq 0x3170
movapd (%rsp), %xmm0
mulsd 0x10991(%rip), %xmm0    # 0x15018
mulsd 0x10991(%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 0x10aae(%rip), %rsi     # 0x1517a
movq %r14, %rdx
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/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 0x472d
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 0x473a
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 0x17892(%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_O1/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 0x63a8
movq %rdi, %rbx
movabsq $0x800000000, %r14      # imm = 0x800000000
leaq 0xefbf(%rip), %rbp      # 0x15268
leaq 0xf0c0(%rip), %r12      # 0x15370
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 0x62f8
leaq 0xf04e(%rip), %rdi      # 0x15334
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3170
jmp 0x6395
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x32e0
movq 0x318(%rbx), %rax
movq %r15, 0x8(%rsp)
movq (%rax,%r15,8), %rdi
leaq 0xed4b(%rip), %rsi      # 0x15067
callq 0x33a0
testq %rax, %rax
je 0x63bf
movq %rax, %r13
movq 0x48(%rsp), %rbx
movq %r14, %rbp
testq %rbx, %rbx
leaq 0x10(%rsp), %r15
jle 0x637a
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 0x633f
movq %r13, %rdi
callq 0x3100
movq (%rsp), %rbx
movq %rbp, %r14
leaq 0xeed8(%rip), %rbp      # 0x15268
movq 0x8(%rsp), %r15
incq %r15
movslq 0x314(%rbx), %rax
cmpq %rax, %r15
jl 0x62b7
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 0xef81(%rip), %rsi      # 0x15362
xorl %eax, %eax
callq 0x3330