LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/gui.c
// Function: dwipe_update_speedring
void dwipe_update_speedring( dwipe_speedring_t* speedring, u64 speedring_bytes, time_t speedring_now )
{
	if( speedring->timeslast == 0 )
	{
		/* Ignore the first sample and initialize. */
		speedring->timeslast = speedring_now;
		return;
	}

	if( speedring_now - speedring->timeslast < DWIPE_KNOB_SPEEDRING_GRANULARITY )
	{
		/* Avoid jitter caused by frequent updates. */
		return;
	}

	/* Subtract the oldest speed sample from the accumulator. */
	speedring->bytestotal -= speedring->bytes[ speedring->position ];
	speedring->timestotal -= speedring->times[ speedring->position ];

	/* Put the lastest bytes-per-second sample into the ring buffer. */
	speedring->bytes[ speedring->position ] = speedring_bytes - speedring->byteslast;
	speedring->times[ speedring->position ] = speedring_now   - speedring->timeslast;

	/* Add the newest speed sample to the accumulator. */
	speedring->bytestotal += speedring->bytes[ speedring->position ];
	speedring->timestotal += speedring->times[ speedring->position ];

	/* Remember the last sample. */
	speedring->byteslast = speedring_bytes;
	speedring->timeslast = speedring_now;

	if( ++speedring->position >= DWIPE_KNOB_SPEEDRING_SIZE )
	{
		speedring->position = 0;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x1f8(%rax)
jne 0x9ad4
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x1f8(%rax)
jmp 0x9c3d
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
subq 0x1f8(%rcx), %rax
cmpq $0xa, %rax
jge 0x9af0
jmp 0x9c3d
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x200(%rcx), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movq 0xf0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xf0(%rax)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x200(%rcx), %rcx
movq 0x100(%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movq 0x1f0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rax
subq 0xf8(%rax), %rdx
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x200(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rsp), %rdx
movq -0x8(%rsp), %rax
subq 0x1f8(%rax), %rdx
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x200(%rcx), %rcx
movq %rdx, 0x100(%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x200(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
addq 0xf0(%rax), %rcx
movq %rcx, 0xf0(%rax)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x200(%rcx), %rcx
movq 0x100(%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0xf8(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x1f8(%rax)
movq -0x8(%rsp), %rcx
movq 0x200(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x200(%rcx)
cmpq $0x1e, %rax
jb 0x9c3d
movq -0x8(%rsp), %rax
movq $0x0, 0x200(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/method.c
// Function: dwipe_method_label
const char* dwipe_method_label( dwipe_method_t method )
{
/**
 *  Returns a pointer to the name of the method function.
 *
 */

	if( method == &dwipe_dod522022m ) { return dwipe_dod522022m_label; }
	if( method == &dwipe_dodshort   ) { return dwipe_dodshort_label;   }
	if( method == &dwipe_gutmann    ) { return dwipe_gutmann_label;    }
	if( method == &dwipe_ops2       ) { return dwipe_ops2_label;       }
	if( method == &dwipe_random     ) { return dwipe_random_label;     }
	if( method == &dwipe_zero       ) { return dwipe_zero_label;       }

	/* else */
	return dwipe_unknown_label;

}

// Assembly:
movq %rdi, -0x10(%rsp)
leaq 0xc4(%rip), %rax        # 0xb290
cmpq %rax, -0x10(%rsp)
jne 0xb1e4
movq 0x9486(%rip), %rax      # 0x14660
movq %rax, -0x8(%rsp)
jmp 0xb27c
leaq 0x255(%rip), %rax       # 0xb440
cmpq %rax, -0x10(%rsp)
jne 0xb200
movq 0x946f(%rip), %rax      # 0x14668
movq %rax, -0x8(%rsp)
jmp 0xb27c
leaq 0x339(%rip), %rax       # 0xb540
cmpq %rax, -0x10(%rsp)
jne 0xb21c
movq 0x945b(%rip), %rax      # 0x14670
movq %rax, -0x8(%rsp)
jmp 0xb27c
leaq 0x54d(%rip), %rax       # 0xb770
cmpq %rax, -0x10(%rsp)
jne 0xb238
movq 0x9447(%rip), %rax      # 0x14678
movq %rax, -0x8(%rsp)
jmp 0xb27c
leaq 0xa11(%rip), %rax       # 0xbc50
cmpq %rax, -0x10(%rsp)
jne 0xb254
movq 0x9433(%rip), %rax      # 0x14680
movq %rax, -0x8(%rsp)
jmp 0xb27c
leaq 0xa45(%rip), %rax       # 0xbca0
cmpq %rax, -0x10(%rsp)
jne 0xb270
movq 0x941f(%rip), %rax      # 0x14688
movq %rax, -0x8(%rsp)
jmp 0xb27c
movq 0x9419(%rip), %rax      # 0x14690
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/method.c
// Function: dwipe_dod522022m
int dwipe_dod522022m( DWIPE_METHOD_SIGNATURE )
{
/**
 * United States Department of Defense 5220.22-M standard wipe.
 * 
 */

	/* A result holder. */
	int r;

	/* Random characters. (Elements 2 and 6 are unused.) */
	char dod [7];

	dwipe_pattern_t patterns [] =
	{
		{  1, &dod[0] }, /* Pass 1: A random character.               */
		{  1, &dod[1] }, /* Pass 2: The bitwise complement of pass 1. */
		{ -1, ""      }, /* Pass 3: A random stream.                  */
		{  1, &dod[3] }, /* Pass 4: A random character.               */
		{  1, &dod[4] }, /* Pass 5: A random character.               */
		{  1, &dod[5] }, /* Pass 6: The bitwise complement of pass 5. */
		{ -1, ""      }, /* Pass 7: A random stream.                  */
		{  0, NULL   }
	};

	/* Load the array with random characters. */
	r = read( c->entropy_fd, &dod, sizeof( dod ) );

	/* NOTE: Only the random data in dod[0], dod[3], and dod[4] is actually used. */

	/* Check the result. */
	if( r != sizeof( dod ) )
	{
		r = errno;
		dwipe_perror( r, __FUNCTION__, "read" );
		dwipe_log( DWIPE_LOG_FATAL, "Unable to seed the %s method.", dwipe_dod522022m_label );

		/* Ensure a negative return. */
		if( r < 0 ) { return  r; }
		else        { return -1; }

	}

	/* Pass 2 is the bitwise complement of Pass 1. */
	dod[1] = ~ dod[0];

	/* Pass 4 is the bitwise complement of Pass 3. */
	dod[5] = ~ dod[4];

	/* Run the DoD 5220.22-M method. */
	return dwipe_runmethod( c, patterns );

}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movl $0x1, (%rsp)
leaq 0x8d(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
leaq 0x8d(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
leaq 0x66a8(%rip), %rax      # 0x11983
movq %rax, 0x28(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x8d(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x38(%rsp)
movl $0x1, 0x40(%rsp)
leaq 0x8d(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x48(%rsp)
movl $0x1, 0x50(%rsp)
leaq 0x8d(%rsp), %rax
addq $0x5, %rax
movq %rax, 0x58(%rsp)
movl $0xffffffff, 0x60(%rsp) # imm = 0xFFFFFFFF
leaq 0x6649(%rip), %rax      # 0x11983
movq %rax, 0x68(%rsp)
movl $0x0, 0x70(%rsp)
movq $0x0, 0x78(%rsp)
movq 0x98(%rsp), %rax
movl 0x2d8(%rax), %edi
leaq 0x8d(%rsp), %rsi
movl $0x7, %edx
callq 0x3230
movl %eax, 0x94(%rsp)
movslq 0x94(%rsp), %rax
cmpq $0x7, %rax
je 0xb3ee
callq 0x3070
movl (%rax), %eax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %edi
leaq 0x606d(%rip), %rsi      # 0x1140e
leaq 0x6077(%rip), %rdx      # 0x1141f
callq 0xb160
movq 0x92ac(%rip), %rdx      # 0x14660
movl $0x6, %edi
leaq 0x6064(%rip), %rsi      # 0x11424
movb $0x0, %al
callq 0xade0
cmpl $0x0, 0x94(%rsp)
jge 0xb3e1
movl 0x94(%rsp), %eax
movl %eax, 0xa4(%rsp)
jmp 0xb429
movl $0xffffffff, 0xa4(%rsp) # imm = 0xFFFFFFFF
jmp 0xb429
movsbl 0x8d(%rsp), %eax
xorl $-0x1, %eax
movb %al, 0x8e(%rsp)
movsbl 0x91(%rsp), %eax
xorl $-0x1, %eax
movb %al, 0x92(%rsp)
movq 0x98(%rsp), %rdi
movq %rsp, %rsi
callq 0xbcd0
movl %eax, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/method.c
// Function: dwipe_dodshort
int dwipe_dodshort( DWIPE_METHOD_SIGNATURE )
{
/**
 * United States Department of Defense 5220.22-M short wipe.
 * This method is comprised of passes 1,2,7 from the standard wipe.
 * 
 */

	/* A result holder. */
	int r;

	/* Random characters. (Element 3 is unused.) */
	char dod [3];

	dwipe_pattern_t patterns [] =
	{
		{  1, &dod[0] }, /* Pass 1: A random character.               */
		{  1, &dod[1] }, /* Pass 2: The bitwise complement of pass 1. */
		{ -1, ""      }, /* Pass 3: A random stream.                  */
		{  0, NULL   }
	};

	/* Load the array with random characters. */
	r = read( c->entropy_fd, &dod, sizeof( dod ) );

	/* NOTE: Only the random data in dod[0] is actually used. */

	/* Check the result. */
	if( r != sizeof( dod ) )
	{
		r = errno;
		dwipe_perror( r, __FUNCTION__, "read" );
		dwipe_log( DWIPE_LOG_FATAL, "Unable to seed the %s method.", dwipe_dodshort_label );

		/* Ensure a negative return. */
		if( r < 0 ) { return  r; }
		else        { return -1; }

	}

	/* Pass 2 is the bitwise complement of Pass 1. */
	dod[1] = ~ dod[0];

	/* Run the DoD 5220.022-M short method. */
	return dwipe_runmethod( c, patterns );

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl $0x1, (%rsp)
leaq 0x41(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
leaq 0x41(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
leaq 0x6504(%rip), %rax      # 0x11983
movq %rax, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x48(%rsp), %rax
movl 0x2d8(%rax), %edi
leaq 0x41(%rsp), %rsi
movl $0x3, %edx
callq 0x3230
movl %eax, 0x44(%rsp)
movslq 0x44(%rsp), %rax
cmpq $0x3, %rax
je 0xb515
callq 0x3070
movl (%rax), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %edi
leaq 0x5f6e(%rip), %rsi      # 0x11442
leaq 0x5f44(%rip), %rdx      # 0x1141f
callq 0xb160
movq 0x9181(%rip), %rdx      # 0x14668
movl $0x6, %edi
leaq 0x5f31(%rip), %rsi      # 0x11424
movb $0x0, %al
callq 0xade0
cmpl $0x0, 0x44(%rsp)
jge 0xb50b
movl 0x44(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xb532
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0xb532
movsbl 0x41(%rsp), %eax
xorl $-0x1, %eax
movb %al, 0x42(%rsp)
movq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0xbcd0
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/mt19937ar-cok.c
// Function: init_genrand
void init_genrand( twister_state_t* state, unsigned long s)
{
	int j;
	state->array[0]= s & 0xffffffffUL;
	for( j = 1; j < N; j++ )
	{
		state->array[j] = (1812433253UL * (state->array[j-1] ^ (state->array[j-1] >> 30)) + j); 
		state->array[j] &= 0xffffffffUL;  /* for >32 bit machines */
	}
	state->left = 1;
	state->initf = 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, -0x14(%rsp)
cmpl $0x270, -0x14(%rsp)     # imm = 0x270
jge 0xc836
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
movl -0x14(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x1e, %rcx
xorq %rcx, %rax
imulq $0x6c078965, %rax, %rdx # imm = 0x6C078965
movslq -0x14(%rsp), %rax
addq %rax, %rdx
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movabsq $0xffffffff, %rdx       # imm = 0xFFFFFFFF
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xc7b9
movq -0x8(%rsp), %rax
movl $0x1, 0x1380(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x1384(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/mt19937ar-cok.c
// Function: twister_genrand_int32
unsigned long twister_genrand_int32( twister_state_t* state )
{
    unsigned long y;

    if ( --state->left == 0 ) { next_state( state ); }
    y = *state->next++;

    /* Tempering */
    y ^= (y >> 11);
    y ^= (y << 7) & 0x9d2c5680UL;
    y ^= (y << 15) & 0xefc60000UL;
    y ^= (y >> 18);

    return y;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1380(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x1380(%rcx)
cmpl $0x0, %eax
jne 0xcadc
movq 0x10(%rsp), %rdi
callq 0xcb70
movq 0x10(%rsp), %rcx
movq 0x1388(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x1388(%rcx)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0xb, %rax
xorq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shlq $0x7, %rax
movabsq $0x9d2c5680, %rcx       # imm = 0x9D2C5680
andq %rcx, %rax
xorq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shlq $0xf, %rax
movabsq $0xefc60000, %rcx       # imm = 0xEFC60000
andq %rcx, %rax
xorq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0x12, %rax
xorq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/mt19937ar-cok.c
// Function: next_state
static void next_state( twister_state_t* state )
{
    unsigned long *p = state->array;
    int j;

    if( state->initf == 0) { init_genrand( state, 5489UL ); }
    state->left = N;
    state->next = state->array;
    for( j = N - M + 1; --j; p++ ) { *p = p[M]   ^ TWIST(p[0], p[1]); }
    for( j = M; --j; p++ )         { *p = p[M-N] ^ TWIST(p[0], p[1]); }
    *p = p[M-N] ^ TWIST(p[0], state->array[0]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x1384(%rax)
jne 0xcba0
movq 0x10(%rsp), %rdi
movl $0x1571, %esi           # imm = 0x1571
callq 0xc790
movq 0x10(%rsp), %rax
movl $0x270, 0x1380(%rax)    # imm = 0x270
movq 0x10(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1388(%rax)
movl $0xe4, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
je 0xcc46
movq 0x8(%rsp), %rax
movq 0xc68(%rax), %rcx
movq 0x8(%rsp), %rdx
movabsq $0x80000000, %rax       # imm = 0x80000000
andq (%rdx), %rax
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdx
andq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
orq %rdx, %rax
shrq %rax
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdi
andq $0x1, %rdi
xorl %edx, %edx
movl $0x9908b0df, %esi       # imm = 0x9908B0DF
cmpq $0x0, %rdi
cmovneq %rsi, %rdx
xorq %rdx, %rax
xorq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0xcbc8
movl $0x18d, 0x4(%rsp)       # imm = 0x18D
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
je 0xcccc
movq 0x8(%rsp), %rax
movq -0x718(%rax), %rcx
movq 0x8(%rsp), %rdx
movabsq $0x80000000, %rax       # imm = 0x80000000
andq (%rdx), %rax
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdx
andq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
orq %rdx, %rax
shrq %rax
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdi
andq $0x1, %rdi
xorl %edx, %edx
movl $0x9908b0df, %esi       # imm = 0x9908B0DF
cmpq $0x0, %rdi
cmovneq %rsi, %rdx
xorq %rdx, %rax
xorq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0xcc4e
movq 0x8(%rsp), %rax
movq -0x718(%rax), %rcx
movq 0x8(%rsp), %rdx
movabsq $0x80000000, %rax       # imm = 0x80000000
andq (%rdx), %rax
movq 0x10(%rsp), %rdx
movq (%rdx), %rdx
andq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
orq %rdx, %rax
shrq %rax
movq 0x10(%rsp), %rdx
movq (%rdx), %rdi
andq $0x1, %rdi
xorl %edx, %edx
movl $0x9908b0df, %esi       # imm = 0x9908B0DF
cmpq $0x0, %rdi
cmovneq %rsi, %rdx
xorq %rdx, %rax
xorq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/prng.c
// Function: dwipe_twister_init
int dwipe_twister_init( DWIPE_PRNG_INIT_SIGNATURE )
{
	if( *state == NULL )
	{
		/* This is the first time that we have been called. */
		*state = malloc( sizeof( twister_state_t ) );
	}
	twister_init( (twister_state_t*)*state, (u32*)( seed->s ), seed->length / sizeof( u32 ) );
	return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xe91e
movl $0x1390, %edi           # imm = 0x1390
callq 0x32f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
shrq $0x3, %rdx
callq 0xc860
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/prng.c
// Function: dwipe_twister_read
int dwipe_twister_read( DWIPE_PRNG_READ_SIGNATURE )
{
	u32 ii;
	u32 words = count / sizeof( u32 );
	u32 remain = count % sizeof( u32 );

	/* Twister returns 4-bytes per call, so cast the buffer into words. */
	for( ii = 0; ii < words; ++ii )
	{
		((u32*)buffer)[ii] = twister_genrand_int32( (twister_state_t*)*state );
	}

	/* Fill the buffer tail if the count is not evenly divided by the size of u32. */
	for( ii = 1; ii <= remain; ++ii )
	{
		/* Notice how three bytes are discarded by doing this. */
		((u8*)buffer)[count-ii] = twister_genrand_int32( (twister_state_t*)*state );
	}
	 
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
shrq $0x3, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
andq $0x7, %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0xe9c2
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0xcab0
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xe988
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0xea08
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0xcab0
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
subq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xe9cb
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/prng.c
// Function: dwipe_isaac_init
int dwipe_isaac_init( DWIPE_PRNG_INIT_SIGNATURE )
{
	int count;
	randctx* isaac_state = *state;

	if( *state == NULL )
	{
		/* This is the first time that we have been called. */
		*state = malloc( sizeof( randctx ) );
		isaac_state = *state;

		/* Check the memory allocation. */
		if( isaac_state == 0 )
		{
				dwipe_perror( errno, __FUNCTION__, "malloc" );
				dwipe_log( DWIPE_LOG_FATAL, "Unable to allocate memory for the isaac state." );
				return -1;
		}
	}


	/* Take the minimum of the isaac seed size and available entropy. */
	if( sizeof( isaac_state->randrsl ) < seed->length ) 
	{
		count = sizeof( isaac_state->randrsl );	
	}
	else
	{
		memset( isaac_state->randrsl, 0, sizeof( isaac_state->randrsl ) );
		count = seed->length;
	}

	if( count == 0 )
	{
		/* Start ISACC without a seed. */
		randinit( isaac_state, 0 );
	}
	else
	{
		/* Seed the ISAAC state with entropy. */
		memcpy( isaac_state->randrsl, seed->s, count );

		/* The second parameter indicates that randrsl is non-empty. */
		randinit( isaac_state, 1 );
	}

	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xea99
movl $0x1020, %edi           # imm = 0x1020
callq 0x32f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xea97
callq 0x3070
movl (%rax), %edi
leaq 0x3896(%rip), %rsi      # 0x12301
leaq 0x1157(%rip), %rdx      # 0xfbc9
callq 0xb160
movl $0x6, %edi
leaq 0x388f(%rip), %rsi      # 0x12312
movb $0x0, %al
callq 0xade0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xeb1b
jmp 0xea99
movq 0x10(%rsp), %rcx
movl $0x800, %eax            # imm = 0x800
cmpq (%rcx), %rax
jae 0xeab2
movl $0x800, 0xc(%rsp)       # imm = 0x800
jmp 0xead2
movq (%rsp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x31d0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xeae8
movq (%rsp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0xa250
jmp 0xeb13
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movslq 0xc(%rsp), %rdx
callq 0x3290
movq (%rsp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0xa250
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]pre-pe/pre-meta.c
// Function: bseq_read
bseq1_t *bseq_read(kseq_t *ks, int chunk_size, int *n_)
{
	int size = 0, m, n;
	bseq1_t *seqs;
	m = n = 0; seqs = 0;
	while (kseq_read(ks) >= 0) {
		bseq1_t *s;
		if (n >= m) {
			m = m? m<<1 : 256;
			seqs = realloc(seqs, m * sizeof(bseq1_t));
		}
		s = &seqs[n];
		s->name = strdup(ks->name.s);
		s->seq = strdup(ks->seq.s);
		s->qual = ks->qual.l? strdup(ks->qual.s) : 0;
		s->bc_f = 0;
		s->bc_r = 0;
		s->l_seq = ks->seq.l;
		s->dbl_bind = 0;
		s->type = LT_UNKNOWN;
		s->olig_pos_f = 0;
		s->olig_pos_r = 0;
		size += seqs[n++].l_seq;
		if (size >= chunk_size && (n&1) == 0) break;
	}
	*n_ = n;
	return seqs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3200
cmpl $0x0, %eax
jl 0x31ea
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x30cf
cmpl $0x0, -0x20(%rbp)
je 0x30aa
movl -0x20(%rbp), %eax
shll %eax
movl %eax, -0x3c(%rbp)
jmp 0x30b4
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x3c(%rbp)
jmp 0x30b4
movl -0x3c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rsi
shlq $0x6, %rsi
callq 0x21c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2240
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x312f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2240
movq %rax, -0x48(%rbp)
jmp 0x3137
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x3137
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x38(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x31e5
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x31e5
jmp 0x31ea
jmp 0x3080
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]pre-pe/pre-meta.c
// Function: lt_opt_init
static void lt_opt_init(lt_opt_t *opt)
{
	memset(opt, 0, sizeof(lt_opt_t));
	opt->n_threads = 2;
	opt->chunk_size = 10000000;
	opt->max_qual = 50;
	opt->min_seq_len = 40;
	opt->max_ovlp_pen = 2;
	opt->min_ovlp_len = 8;
	opt->max_adap_pen = 1;
	opt->min_adap_len = 3;
	opt->max_olig_pen = 2;
	opt->min_olig_len = 10; // total length = 19
	opt->bc_cut = 1;
	opt->qmask = 20;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x34, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rax
movl $0x989680, 0x4(%rax)    # imm = 0x989680
movq -0x8(%rbp), %rax
movl $0x32, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x28, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0xa, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x14, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]pre-pe/pre-meta.c
// Function: merge_base
static inline int merge_base(int max_qual, int qmask, char fc, char fq, char rc, char rq)
{
	int y;
	if (fc == rc) {
		int q = fq > rq? (fq - 33) + (rq - 33) / 2 : (rq - 33) + (fq - 33) / 2;
		y = toupper(fc) | (33 + (q < max_qual? q : max_qual)) << 8;
	} else {
		if (fq - 33 >= qmask && rq - 33 >= qmask) y = 'N' | 33 << 8;
		else if (fq > rq) y = toupper(fc) | (33 + (fq - rq)) << 8;
		else y = toupper(rc) | (33 + (rq - fq)) << 8;
	}
	return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r8d, -0x24(%rbp)
movl %ecx, %eax
movl -0x24(%rbp), %ecx
movl %eax, -0x20(%rbp)
movl %edx, %eax
movl -0x20(%rbp), %edx
movl %eax, -0x1c(%rbp)
movl %esi, %eax
movl -0x1c(%rbp), %esi
movl %eax, -0x18(%rbp)
movl %edi, %r8d
movl -0x18(%rbp), %edi
movb %r9b, %al
movl %r8d, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movsbl -0x9(%rbp), %eax
movsbl -0xb(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4cd0
movsbl -0xa(%rbp), %eax
movsbl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x4c72
movsbl -0xa(%rbp), %eax
subl $0x21, %eax
movl %eax, -0x2c(%rbp)
movsbl -0xc(%rbp), %eax
subl $0x21, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0x4c95
movsbl -0xc(%rbp), %eax
subl $0x21, %eax
movl %eax, -0x30(%rbp)
movsbl -0xa(%rbp), %eax
subl $0x21, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x2080
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x4cb7
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x4cbd
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl -0x38(%rbp), %ecx
addl $0x21, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d3f
movsbl -0xa(%rbp), %eax
subl $0x21, %eax
cmpl -0x8(%rbp), %eax
jl 0x4cf1
movsbl -0xc(%rbp), %eax
subl $0x21, %eax
cmpl -0x8(%rbp), %eax
jl 0x4cf1
movl $0x214e, -0x10(%rbp)    # imm = 0x214E
jmp 0x4d3d
movsbl -0xa(%rbp), %eax
movsbl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x4d1d
movsbl -0x9(%rbp), %edi
callq 0x2080
movsbl -0xa(%rbp), %ecx
movsbl -0xc(%rbp), %edx
subl %edx, %ecx
addl $0x21, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d3b
movsbl -0xb(%rbp), %edi
callq 0x2080
movsbl -0xc(%rbp), %ecx
movsbl -0xa(%rbp), %edx
subl %edx, %ecx
addl $0x21, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d3d
jmp 0x4d3f
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/Master.cpp
// Function: FindIdle(bool*, int)
int FindIdle(bool* IsIdle, int n_proc){
	int i;
	
	for(i=1;i<n_proc;i++){// all slave processes
		if(IsIdle[i]){
			return i; //index of first idle
		}
	}
	//cout<<"No idle slave.";
	return 0; // no idle process was found, return zero
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0xf8f4
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
testb $0x1, (%rax,%rcx)
je 0xf8e5
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xf8fc
jmp 0xf8e7
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xf8c1
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/Master.cpp
// Function: SumIdle(bool*, int)
int SumIdle(bool* IsIdle, int n_proc){
	int i,tot=0;
	
	for(i=1;i<n_proc;i++){// all slave processes
		if(IsIdle[i]){
			tot++;
		}
	}
	return tot; 
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0xf95d
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
testb $0x1, (%rax,%rcx)
je 0xf94e
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xf950
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xf929
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: IncreaseStarMatrix()
void IncreaseStarMatrix(){
	long i;
	double *temppointer;
	
	for(i=0;i<8;i++){ //reallocating memory for all lines, increasing the number of elements
		temppointer=(double*) realloc(StarMatrix[i], (NStarsAllocated+LineIncreaseUnit)* sizeof(double));
		if(temppointer!=NULL){ //successful allocation
			StarMatrix[i]=temppointer;
		}
		else
		{
			cout<<"Memory allocation failure! Exiting!";
			exit(EXIT_FAILURE);
		}
	}
	NStarsAllocated+=LineIncreaseUnit; //note the number of elements	
}

// Assembly:
subq $0x18, %rsp
movq $0x0, 0x10(%rsp)
cmpq $0x8, 0x10(%rsp)
jge 0xfb42
movq 0x12c1c(%rip), %rax     # 0x226e8
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x12c14(%rip), %rsi     # 0x226f0
addq $0x3e8, %rsi            # imm = 0x3E8
shlq $0x3, %rsi
callq 0x8ae0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xfb10
movq 0x8(%rsp), %rdx
movq 0x12be3(%rip), %rax     # 0x226e8
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xfb2d
movq 0x124b9(%rip), %rdi     # 0x21fd0
leaq 0xc822(%rip), %rsi      # 0x1c340
callq 0x8640
movl $0x1, %edi
callq 0x87c0
jmp 0xfb2f
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xfabd
movq 0x12ba7(%rip), %rax     # 0x226f0
addq $0x3e8, %rax            # imm = 0x3E8
movq %rax, 0x12b9a(%rip)     # 0x226f0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: FreeStarMatrix()
void FreeStarMatrix(){
	long i;
	
	for(i=0;i<8;i++){ 
		free(StarMatrix[i]);
	}
	free(StarMatrix);
	StarMatrix=NULL; //none assigned
	NStarsAllocated=0; //zero size
	NStarsCurrent=0; //zero stars
}

// Assembly:
pushq %rax
movq $0x0, (%rsp)
cmpq $0x8, (%rsp)
jge 0xfb92
movq 0x12b71(%rip), %rax     # 0x226e8
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8780
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0xfb69
movq 0x12b4f(%rip), %rdi     # 0x226e8
callq 0x8780
movq $0x0, 0x12b3f(%rip) # 0x226e8
movq $0x0, 0x12b3c(%rip) # 0x226f0
movq $0x0, 0x12b39(%rip) # 0x226f8
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: IncreaseCoreMatrix(long)
void IncreaseCoreMatrix(long timeindex){
	long i;
	double *temppointer;
	
	for(i=0;i<12;i++){ //reallocating memory for all lines, increasing the number of elements
		temppointer=(double*) realloc(CoreMatrix[timeindex][i], (NCoresAllocated[timeindex]+LineIncreaseUnit)* sizeof(double));
		if(temppointer!=NULL){ //successful allocation
			CoreMatrix[timeindex][i]=temppointer;
		}
		else
		{
			cout<<"Memory allocation failure! Exiting!";
			exit(EXIT_FAILURE);
		}
	}
	NCoresAllocated[timeindex]+=LineIncreaseUnit; //note the number of elements	
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0xc, 0x8(%rsp)
jge 0xfc83
movq 0x12b0b(%rip), %rax     # 0x22700
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x12afa(%rip), %rax     # 0x22708
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x3e8, %rsi            # imm = 0x3E8
shlq $0x3, %rsi
callq 0x8ae0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xfc51
movq (%rsp), %rdx
movq 0x12ac3(%rip), %rax     # 0x22700
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xfc6e
movq 0x12378(%rip), %rdi     # 0x21fd0
leaq 0xc6e1(%rip), %rsi      # 0x1c340
callq 0x8640
movl $0x1, %edi
callq 0x87c0
jmp 0xfc70
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xfbe2
movq 0x12a7e(%rip), %rax     # 0x22708
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x3e8, %rdx            # imm = 0x3E8
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: FreeCoreMatrix()
void FreeCoreMatrix(){
	long i,j;
	
	for(i=0;i<CMFTIMENUM;i++){ 
		for(j=0;j<12;j++){ 
			free(CoreMatrix[i][j]);
		}
		free(CoreMatrix[i]);
		NCoresAllocated[i]=0;
		NCoresCurrent[i]=0;	
	}
	free(NCoresAllocated);
	free(NCoresCurrent);
	free(CoreMatrix);
	CoreMatrix=NULL; //none assigned
}

// Assembly:
subq $0x18, %rsp
movq $0x0, 0x10(%rsp)
cmpq $0x10, 0x10(%rsp)
jge 0xfd58
movq $0x0, 0x8(%rsp)
cmpq $0xc, 0x8(%rsp)
jge 0xfd08
movq 0x12a1f(%rip), %rax     # 0x22700
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8780
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xfcd2
movq 0x129f1(%rip), %rax     # 0x22700
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8780
movq 0x129e4(%rip), %rax     # 0x22708
movq 0x10(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x129d8(%rip), %rax     # 0x22710
movq 0x10(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xfcbd
movq 0x129a9(%rip), %rdi     # 0x22708
callq 0x8780
movq 0x129a5(%rip), %rdi     # 0x22710
callq 0x8780
movq 0x12989(%rip), %rdi     # 0x22700
callq 0x8780
movq $0x0, 0x12979(%rip) # 0x22700
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: SaveAndFreeStarsAndCoresMatrices(bool)
void SaveAndFreeStarsAndCoresMatrices(bool IsEnd){
	long l;
	char filename[100];
	char Corefilename[100]; //file containing the cores at a chosen time
	

	//Save all accumulated star data
	//Save results to file
	ContructFilePath("Stars.txt", "Output", filename); //file where data about stars should go
	if(NStarsCurrent>0){
		SaveStarMatrix(filename, IsEnd);
		FreeStarMatrix(); //free memory
	}
	//Save accumulated core data
	ContructFilePath("Clouds.txt", "Output", filename); //file where data about clouds should go
	for ( l = 0; l < CMFTIMENUM; l++ ){ //check all CMF times 
		CMFFileName(Corefilename, filename, CMFTimes[l]);
		if(NCoresCurrent[l]>0){
			SaveCoreMatrix(l,Corefilename,IsEnd);
		}
	}
	FreeCoreMatrix(); //free memory
	
}

// Assembly:
subq $0xe8, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
leaq 0x70(%rsp), %rdx
leaq 0xc5b5(%rip), %rdi      # 0x1c364
leaq 0xc3d2(%rip), %rsi      # 0x1c188
callq 0x173f0
cmpq $0x0, 0x12935(%rip)     # 0x226f8
jle 0xfde0
leaq 0x70(%rsp), %rdi
movb 0xe7(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xfe90
callq 0xfb60
leaq 0x70(%rsp), %rdx
leaq 0xc582(%rip), %rdi      # 0x1c36e
leaq 0xc395(%rip), %rsi      # 0x1c188
callq 0x173f0
movq $0x0, 0xd8(%rsp)
cmpq $0x10, 0xd8(%rsp)
jge 0xfe7a
movq %rsp, %rdi
leaq 0x70(%rsp), %rsi
movq 0xd8(%rsp), %rcx
leaq 0xc57a(%rip), %rax      # 0x1c3a0
movsd (%rax,%rcx,8), %xmm0
callq 0x10070
movq 0x128d9(%rip), %rax     # 0x22710
movq 0xd8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jle 0xfe62
movq 0xd8(%rsp), %rdi
movq %rsp, %rsi
movb 0xe7(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x10140
jmp 0xfe64
movq 0xd8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
jmp 0xfe04
callq 0xfcb0
addq $0xe8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: SaveStarMatrix(char*, bool)
void SaveStarMatrix(char* filename, bool IsEnd){
	long i,j;
	ofstream myfile; //Output file handle
    //Open file
    myfile.open(filename,ios::app);
    //Save parameters of stars
    for(i=0;i<NStarsCurrent;i++){ 
		for(j=0;j<8;j++){
			if(j<7){
				myfile<<StarMatrix[j][i]<<"\t";
			}
			else{
				myfile<<StarMatrix[j][i]<<"\n";
			}
     	}
     }
     if(IsEnd){
     	myfile <<"END"<<"\n"; //mark end for this parent cloud in file
	 }
     myfile.flush(); //finish writing
     myfile.close(); //close file	
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movb %sil, %al
movq %rdi, 0x250(%rsp)
andb $0x1, %al
movb %al, 0x24f(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x8b80
movq 0x20(%rsp), %rdi
movq 0x250(%rsp), %rsi
movl $0x1, %edx
callq 0x8060
jmp 0xfed3
movq $0x0, 0x240(%rsp)
movq 0x240(%rsp), %rax
cmpq 0x1280a(%rip), %rax     # 0x226f8
jge 0xfff9
movq $0x0, 0x238(%rsp)
cmpq $0x8, 0x238(%rsp)
jge 0xffde
cmpq $0x7, 0x238(%rsp)
jge 0xff7d
movq 0x127c7(%rip), %rax     # 0x226e8
movq 0x238(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x240(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x38(%rsp), %rdi
callq 0x8ce0
movq %rax, 0x18(%rsp)
jmp 0xff4b
movq 0x18(%rsp), %rdi
leaq 0xc422(%rip), %rsi      # 0x1c379
callq 0x8640
jmp 0xff5e
jmp 0xffc3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x89c0
jmp 0x1005a
movq 0x12764(%rip), %rax     # 0x226e8
movq 0x238(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x240(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x38(%rsp), %rdi
callq 0x8ce0
movq %rax, 0x10(%rsp)
jmp 0xffae
movq 0x10(%rsp), %rdi
leaq 0xc36f(%rip), %rsi      # 0x1c329
callq 0x8640
jmp 0xffc1
jmp 0xffc3
jmp 0xffc5
movq 0x238(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x238(%rsp)
jmp 0xff00
jmp 0xffe0
movq 0x240(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x240(%rsp)
jmp 0xfedf
testb $0x1, 0x24f(%rsp)
je 0x10030
leaq 0xc371(%rip), %rsi      # 0x1c37b
leaq 0x38(%rsp), %rdi
callq 0x8640
movq %rax, 0x8(%rsp)
jmp 0x1001b
movq 0x8(%rsp), %rdi
leaq 0xc302(%rip), %rsi      # 0x1c329
callq 0x8640
jmp 0x1002e
jmp 0x10030
leaq 0x38(%rsp), %rdi
callq 0x83e0
jmp 0x1003c
leaq 0x38(%rsp), %rdi
callq 0x8960
jmp 0x10048
leaq 0x38(%rsp), %rdi
callq 0x89c0
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x30(%rsp), %rdi
callq 0x8be0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: CMFFileName(char*, char*, double)
void CMFFileName(char* fullname, char* filename, double CMFTime)
{
	char ending[100];
	char beginning[100];
	char* chpointer;

	//find file extension at the end of the string
	chpointer=strchr(filename,'x');
	//make a copy of the filename without extension
	strncpy(beginning, filename, chpointer-filename-2);
	beginning[chpointer-filename-1]=0;
	sprintf( ending, "_cores_t%g.txt", CMFTime);
	fullname[0]=0; //set it as empty string
	strcat (fullname,beginning);
	strcat (fullname,ending);	
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movsd %xmm0, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
movl $0x78, %esi
callq 0x8210
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0xf8(%rsp), %rax
subq %rax, %rdx
subq $0x2, %rdx
callq 0x82b0
movq 0x8(%rsp), %rax
movq 0xf8(%rsp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movb $0x0, 0x10(%rsp,%rax)
leaq 0x80(%rsp), %rdi
movsd 0xf0(%rsp), %xmm0
leaq 0xc290(%rip), %rsi      # 0x1c38e
movb $0x1, %al
callq 0x8110
movq 0x100(%rsp), %rax
movb $0x0, (%rax)
movq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8bf0
movq 0x100(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x8bf0
addq $0x108, %rsp            # imm = 0x108
retq
nop
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: SaveCoreMatrix(long, char*, bool)
void SaveCoreMatrix(long timeindex, char* filename, bool IsEnd){
	long i,j;
	ofstream myfile; //Output file handle
    //Open file
    myfile.open(filename,ios::app);
    //Save parameters of cores for this obs. time
    for(i=0;i<NCoresCurrent[timeindex];i++){ 
		for(j=0;j<12;j++){
			if(j<11){
				myfile<<CoreMatrix[timeindex][j][i]<<"\t";
			}
			else{
				myfile<<CoreMatrix[timeindex][j][i]<<"\n";
			}
     	}
     }
     if(IsEnd){
     	myfile <<"END"<<"\n"; //mark end for this parent cloud in file
	 }
     myfile.flush(); //finish writing
     myfile.close(); //close file	
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movb %dl, %al
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
andb $0x1, %al
movb %al, 0x247(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8b80
movq 0x18(%rsp), %rdi
movq 0x248(%rsp), %rsi
movl $0x1, %edx
callq 0x8060
jmp 0x1018a
movq $0x0, 0x238(%rsp)
movq 0x238(%rsp), %rax
movq 0x1256b(%rip), %rcx     # 0x22710
movq 0x250(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x102d4
movq $0x0, 0x230(%rsp)
cmpq $0xc, 0x230(%rsp)
jge 0x102b9
cmpq $0xb, 0x230(%rsp)
jge 0x1024c
movq 0x1251c(%rip), %rax     # 0x22700
movq 0x250(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x230(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x238(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x30(%rsp), %rdi
callq 0x8ce0
movq %rax, 0x10(%rsp)
jmp 0x1021a
movq 0x10(%rsp), %rdi
leaq 0xc153(%rip), %rsi      # 0x1c379
callq 0x8640
jmp 0x1022d
jmp 0x1029e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x89c0
jmp 0x10333
movq 0x124ad(%rip), %rax     # 0x22700
movq 0x250(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x230(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x238(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x30(%rsp), %rdi
callq 0x8ce0
movq %rax, 0x8(%rsp)
jmp 0x10289
movq 0x8(%rsp), %rdi
leaq 0xc094(%rip), %rsi      # 0x1c329
callq 0x8640
jmp 0x1029c
jmp 0x1029e
jmp 0x102a0
movq 0x230(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x230(%rsp)
jmp 0x101c3
jmp 0x102bb
movq 0x238(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x238(%rsp)
jmp 0x10196
testb $0x1, 0x247(%rsp)
je 0x10309
leaq 0xc096(%rip), %rsi      # 0x1c37b
leaq 0x30(%rsp), %rdi
callq 0x8640
movq %rax, (%rsp)
jmp 0x102f5
movq (%rsp), %rdi
leaq 0xc029(%rip), %rsi      # 0x1c329
callq 0x8640
jmp 0x10307
jmp 0x10309
leaq 0x30(%rsp), %rdi
callq 0x83e0
jmp 0x10315
leaq 0x30(%rsp), %rdi
callq 0x8960
jmp 0x10321
leaq 0x30(%rsp), %rdi
callq 0x89c0
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x28(%rsp), %rdi
callq 0x8be0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: TooLargeStarsAndCoresMatrices()
bool TooLargeStarsAndCoresMatrices(){
	long TotalAlloc=NStarsAllocated*8; //stars, 8 data items per star
	long l;
	
	for ( l = 0; l < CMFTIMENUM; l++ ){ //check all CMF times
		TotalAlloc+=NCoresAllocated[l]*12; //12 numbers per core
	}	
	if(TotalAlloc<MaxAllocated){
		return false;
	}
	else
	{
		return true;
	}	
}

// Assembly:
movq 0x123a9(%rip), %rax     # 0x226f0
shlq $0x3, %rax
movq %rax, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
cmpq $0x10, -0x18(%rsp)
jge 0x1038c
movq 0x123a0(%rip), %rax     # 0x22708
movq -0x18(%rsp), %rcx
imulq $0xc, (%rax,%rcx,8), %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x10359
cvtsi2sdq -0x10(%rsp), %xmm1
movsd 0xbf9d(%rip), %xmm0     # 0x1c338
ucomisd %xmm1, %xmm0
jbe 0x103a8
movb $0x0, -0x1(%rsp)
jmp 0x103ad
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: AssignStarMatrixValues(double, double, double, double, double, double, double, double)
void AssignStarMatrixValues(double Mass, double X0, double Y0, double Z0, double RelativeVelocityX, double RelativeVelocityY, double RelativeVelocityZ, double tcurrent){
	StarMatrix[0][NStarsCurrent]=Mass;
	StarMatrix[1][NStarsCurrent]=X0;
	StarMatrix[2][NStarsCurrent]=Y0;
	StarMatrix[3][NStarsCurrent]=Z0;
	StarMatrix[4][NStarsCurrent]=RelativeVelocityX;
	StarMatrix[5][NStarsCurrent]=RelativeVelocityY;
	StarMatrix[6][NStarsCurrent]=RelativeVelocityZ;
	StarMatrix[7][NStarsCurrent]=tcurrent;
	NStarsCurrent++; //one more star has been added
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
movsd %xmm2, -0x18(%rsp)
movsd %xmm3, -0x20(%rsp)
movsd %xmm4, -0x28(%rsp)
movsd %xmm5, -0x30(%rsp)
movsd %xmm6, -0x38(%rsp)
movsd %xmm7, -0x40(%rsp)
movsd -0x8(%rsp), %xmm0
movq 0x1205b(%rip), %rax     # 0x226e8
movq (%rax), %rax
movq 0x12061(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movsd -0x10(%rsp), %xmm0
movq 0x1203f(%rip), %rax     # 0x226e8
movq 0x8(%rax), %rax
movq 0x12044(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movsd -0x18(%rsp), %xmm0
movq 0x12022(%rip), %rax     # 0x226e8
movq 0x10(%rax), %rax
movq 0x12027(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movsd -0x20(%rsp), %xmm0
movq 0x12005(%rip), %rax     # 0x226e8
movq 0x18(%rax), %rax
movq 0x1200a(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movsd -0x28(%rsp), %xmm0
movq 0x11fe8(%rip), %rax     # 0x226e8
movq 0x20(%rax), %rax
movq 0x11fed(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movsd -0x30(%rsp), %xmm0
movq 0x11fcb(%rip), %rax     # 0x226e8
movq 0x28(%rax), %rax
movq 0x11fd0(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movsd -0x38(%rsp), %xmm0
movq 0x11fae(%rip), %rax     # 0x226e8
movq 0x30(%rax), %rax
movq 0x11fb3(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movsd -0x40(%rsp), %xmm0
movq 0x11f91(%rip), %rax     # 0x226e8
movq 0x38(%rax), %rax
movq 0x11f96(%rip), %rcx     # 0x226f8
movsd %xmm0, (%rax,%rcx,8)
movq 0x11f8a(%rip), %rax     # 0x226f8
addq $0x1, %rax
movq %rax, 0x11f7f(%rip)     # 0x226f8
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: InitStarsAndCores()
void InitStarsAndCores()
{
	
	long i;
	
	//Init global counting variables
	NStarsAllocated=0;
	NStarsCurrent=0;
	NCoresAllocated=(long*)calloc(CMFTIMENUM, sizeof (long));
	NCoresCurrent=(long*)calloc(CMFTIMENUM, sizeof (long));
	StarMatrix=(double**)calloc(8,sizeof(double*));
	CoreMatrix=(double***)calloc(CMFTIMENUM,sizeof(double**));
	for(i=0;i<CMFTIMENUM;i++){
		CoreMatrix[i]=(double**)calloc(12,sizeof(double*));
	}

}

// Assembly:
pushq %rax
movq $0x0, 0x11cc4(%rip) # 0x226f0
movq $0x0, 0x11cc1(%rip) # 0x226f8
movl $0x10, %edi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x11cbb(%rip)     # 0x22708
movl $0x10, %edi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x11cad(%rip)     # 0x22710
movl $0x8, %esi
movq %rsi, %rdi
callq 0x83b0
movq %rax, 0x11c71(%rip)     # 0x226e8
movl $0x10, %edi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x11c73(%rip)     # 0x22700
movq $0x0, (%rsp)
cmpq $0x10, (%rsp)
jge 0x10acb
movl $0xc, %edi
movl $0x8, %esi
callq 0x83b0
movq %rax, %rdx
movq 0x11c4b(%rip), %rax     # 0x22700
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x10a95
popq %rax
retq
nopl (%rax)