LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sTeeLM[P]dwipe/device.c
// Function: dwipe_device_strsize
void dwipe_device_strsize(char * buffer, int buflen, loff_t size)
{
    long double real = size;
    long double real1 = size;
    if(real > 1024*1024*1024*1024.0 ) { /* 1TiB */
        real /= 1024*1024*1024*1024.0;
        real1 /= 1000*1000*1000*1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf TiB(%.2Lf TB)", real, real1);
    } else if(real > 1024*1024*1024.0 ) { /* 1GiB */
        real /= 1024*1024*1024.0;
        real1 /= 1000*1000*1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf GiB(%.2Lf GB)", real, real1);
    } else if(real > 1024*1024.0 ) { /* 1MiB */
        real /= 1024*1024.0;
        real1 /= 1000*1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf MiB(%.2Lf KB)", real, real1);
    } else if(real > 1024*1024.0 ) { /* 1KiB */
        real /= 1024.0;
        real1 /= 1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf KiB(%.2Lf KB)", real, real1);
    } else {
        snprintf(buffer, buflen, "Size: %.2Lf B", real);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
fildll 0x20(%rsp)
movabsq $0x10000000001, %rax    # imm = 0x10000000001
cmpq %rax, %rdx
jl 0x35bb
fld %st(0)
fmuls 0x6a74(%rip)            # 0xa014
fxch %st(1)
fdivl 0x6a70(%rip)            # 0xa018
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x71ff(%rip), %rdx      # 0xa7b8
jmp 0x3620
cmpq $0x40000001, %rdx       # imm = 0x40000001
jl 0x35e7
fld %st(0)
fmuls 0x6a40(%rip)            # 0xa00c
fxch %st(1)
fdivs 0x6a3c(%rip)            # 0xa010
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x71ed(%rip), %rdx      # 0xa7d2
jmp 0x3620
cmpq $0x100001, %rdx         # imm = 0x100001
jl 0x3613
fld %st(0)
fmuls 0x6a0c(%rip)            # 0xa004
fxch %st(1)
fdivs 0x6a08(%rip)            # 0xa008
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x71db(%rip), %rdx      # 0xa7ec
jmp 0x3620
movslq %esi, %rsi
fstpt (%rsp)
leaq 0x71e6(%rip), %rdx      # 0xa806
xorl %eax, %eax
callq 0x3180
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/sTeeLM[P]dwipe/gui.c
// Function: dwipe_gui_load
void
dwipe_gui_load( void )
{
/**
 * Prints the system load average to the statistics window.
 *
 * @modifies stat_window      Prints the system load average to the statistics window.
 *
 */

	/* A file handle for the stat file. */
	FILE* dwipe_fp;

	/* The one, five, and fifteen minute load averages. */
	float load_01;
	float load_05;
	float load_15;


	/* Open the loadavg file. */
	dwipe_fp = fopen( DWIPE_KNOB_LOADAVG, "r" );

	/* Print the label. */
	mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_LOAD_X, "Load Averages:" );

	if( dwipe_fp )
	{
		/* The load averages are the first three numbers in the file. */
		if( 3 == fscanf( dwipe_fp, "%f %f %f", &load_01, &load_05, &load_15 ) )
		{
			/* Print the load average. */
			mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_TAB,
			  "%04.2f %04.2f %04.2f", load_01, load_05, load_15 );
		}

		else
		{
			/* Print an error. */
			mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_TAB, "(fscanf error %i)", errno );
		}

		/* Close the loadavg file. */
		fclose( dwipe_fp );
	}

	else
	{
		mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_TAB, "(fopen error %i)", errno );
	}

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x5c5d(%rip), %rdi      # 0xc0a7
leaq 0x3c4c(%rip), %rsi      # 0xa09d
callq 0x3290
movq %rax, %rbx
movq 0xa3c0(%rip), %rdi      # 0x10820
leaq 0x5c4e(%rip), %rcx      # 0xc0b5
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x31c0
testq %rbx, %rbx
je 0x64d0
leaq 0x5c44(%rip), %rsi      # 0xc0c4
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30e0
movq 0xa380(%rip), %r14      # 0x10820
cmpl $0x3, %eax
jne 0x64fd
cvtss2sd 0x14(%rsp), %xmm0
cvtss2sd 0x10(%rsp), %xmm1
cvtss2sd 0xc(%rsp), %xmm2
leaq 0x5c0f(%rip), %rcx      # 0xc0cd
pushq $0x3
popq %rsi
pushq $0x10
popq %rdx
movq %r14, %rdi
movb $0x3, %al
callq 0x31c0
jmp 0x651c
movq 0xa349(%rip), %rbx      # 0x10820
callq 0x3070
movl (%rax), %r8d
leaq 0x5c0e(%rip), %rcx      # 0xc0f4
pushq $0x3
popq %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x31c0
callq 0x3070
movl (%rax), %r8d
leaq 0x5bd6(%rip), %rcx      # 0xc0e2
pushq $0x3
popq %rsi
pushq $0x10
popq %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x31c0
movq %rbx, %rdi
callq 0x3140
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x82(%rip), %rax        # 0x76b9
cmpq %rax, %rdi
je 0x768a
leaq 0x172(%rip), %rax       # 0x77b5
cmpq %rax, %rdi
je 0x7693
leaq 0x218(%rip), %rax       # 0x7867
cmpq %rax, %rdi
je 0x769c
leaq 0x369(%rip), %rax       # 0x79c4
cmpq %rax, %rdi
je 0x76a5
leaq 0x511(%rip), %rax       # 0x7b78
cmpq %rax, %rdi
je 0x76ae
leaq 0x52b(%rip), %rax       # 0x7b9e
cmpq %rax, %rdi
leaq 0x901b(%rip), %rcx      # 0x10698
leaq 0x901c(%rip), %rax      # 0x106a0
cmoveq %rcx, %rax
jmp 0x76b5
leaq 0x8fdf(%rip), %rax      # 0x10670
jmp 0x76b5
leaq 0x8fde(%rip), %rax      # 0x10678
jmp 0x76b5
leaq 0x8fdd(%rip), %rax      # 0x10680
jmp 0x76b5
leaq 0x8fdc(%rip), %rax      # 0x10688
jmp 0x76b5
leaq 0x8fdb(%rip), %rax      # 0x10690
movq (%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x90, %rsp
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
leaq 0x9(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl %eax, 0x20(%rsp)
leaq 0xa(%rsp), %rcx
movq %rcx, 0x28(%rsp)
orl $-0x1, 0x30(%rsp)
movq %rdi, %rbx
leaq 0x52ac(%rip), %rcx      # 0xc99b
movq %rcx, 0x38(%rsp)
movl %eax, 0x40(%rsp)
leaq 0xc(%rsp), %rdx
movq %rdx, 0x48(%rsp)
movl %eax, 0x50(%rsp)
leaq 0xd(%rsp), %rdx
movq %rdx, 0x58(%rsp)
movl %eax, 0x60(%rsp)
leaq 0xe(%rsp), %rax
movq %rax, 0x68(%rsp)
orl $-0x1, 0x70(%rsp)
movq %rcx, 0x78(%rsp)
andl $0x0, 0x80(%rsp)
andq $0x0, 0x88(%rsp)
movl 0x2d8(%rdi), %edi
pushq $0x7
popq %rdx
callq 0x3240
cmpl $0x7, %eax
jne 0x776f
movb 0x9(%rsp), %al
movb 0xd(%rsp), %cl
notb %al
movb %al, 0xa(%rsp)
notb %cl
movb %cl, 0xe(%rsp)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7bb5
jmp 0x77ac
callq 0x3070
movl (%rax), %ebx
leaq 0x4cf9(%rip), %rsi      # 0xc476
leaq 0x4d03(%rip), %rdx      # 0xc487
movl %ebx, %edi
callq 0x7600
movq 0x8ede(%rip), %rdx      # 0x10670
leaq 0x4cf3(%rip), %rsi      # 0xc48c
pushq $0x6
popq %rdi
xorl %eax, %eax
callq 0x73a8
cmpl $-0x1, %ebx
pushq $-0x1
popq %rax
cmovll %ebx, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
leaq 0xd(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl %eax, 0x20(%rsp)
leaq 0xe(%rsp), %rax
movq %rax, 0x28(%rsp)
orl $-0x1, 0x30(%rsp)
leaq 0x51b3(%rip), %rax      # 0xc99b
movq %rax, 0x38(%rsp)
andl $0x0, 0x40(%rsp)
andq $0x0, 0x48(%rsp)
movl 0x2d8(%rdi), %edi
pushq $0x3
popq %rdx
callq 0x3240
cmpl $0x3, %eax
jne 0x7824
movb 0xd(%rsp), %al
notb %al
movb %al, 0xe(%rsp)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7bb5
jmp 0x7861
callq 0x3070
movl (%rax), %ebx
leaq 0x4c78(%rip), %rsi      # 0xc4aa
leaq 0x4c4e(%rip), %rdx      # 0xc487
movl %ebx, %edi
callq 0x7600
movq 0x8e31(%rip), %rdx      # 0x10678
leaq 0x4c3e(%rip), %rsi      # 0xc48c
pushq $0x6
popq %rdi
xorl %eax, %eax
callq 0x73a8
cmpl $-0x1, %ebx
pushq $-0x1
popq %rax
cmovll %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
movq %rax, (%rdi)
pushq $0x1
popq %rcx
cmpq $0x270, %rcx            # imm = 0x270
je 0x820f
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdi,%rcx,8)
incq %rcx
jmp 0x81ec
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1380(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/sTeeLM[P]dwipe/mt19937ar-cok.c
// Function: twister_init
void twister_init( twister_state_t* state, unsigned long init_key[], unsigned long key_length )
{
    int i = 1;
	 int j = 0;
    int k = ( N > key_length ? N : key_length );

    init_genrand( state, 19650218UL );

    for( ; k; k-- )
	 {
		state->array[i] = (state->array[i] ^ ((state->array[i-1] ^ (state->array[i-1] >> 30)) * 1664525UL)) + init_key[j] + j;
		state->array[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
		++i;
		++j;

		if ( i >= N )
		{
			state->array[0] = state->array[N-1];
			i = 1;
		}

		if ( j >= key_length )
		{
			j = 0;
		}
    }

    for( k = N -1; k; k-- )
	 {
		state->array[i] = (state->array[i] ^ ((state->array[i-1] ^ (state->array[i-1] >> 30)) * 1566083941UL)) - i;
		state->array[i] &= 0xffffffffUL;
		++i;

		if ( i >= N )
		{
			state->array[0] = state->array[N-1];
			i = 1;
		}
    }

	state->array[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ 
	state->left = 1;
	state->initf = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x271, %rdx            # imm = 0x271
movl $0x270, %r12d           # imm = 0x270
cmovaeq %rdx, %r12
movl $0x12bd6aa, %esi        # imm = 0x12BD6AA
callq 0x81e4
xorl %ecx, %ecx
pushq $0x1
popq %rdx
movl %edx, %eax
xorl %esi, %esi
subl $0x1, %r12d
jb 0x82ae
movslq %eax, %rdi
movq -0x8(%rbx,%rdi,8), %r8
movq %r8, %r9
shrq $0x1e, %r9
xorl %r8d, %r9d
imull $0x19660d, %r9d, %r8d   # imm = 0x19660D
xorl (%rbx,%rdi,8), %r8d
movslq %esi, %r9
movl (%r15,%r9,8), %r10d
addl %r9d, %r10d
addl %r8d, %r10d
movq %r10, (%rbx,%rdi,8)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x8295
incl %eax
jmp 0x82a1
movq 0x1378(%rbx), %rax
movq %rax, (%rbx)
movl %edx, %eax
incl %esi
movslq %esi, %rsi
cmpq %r14, %rsi
cmovael %ecx, %esi
jmp 0x8256
movl $0xfffffd91, %ecx       # imm = 0xFFFFFD91
pushq $0x1
popq %rdx
testl %ecx, %ecx
je 0x82f7
movslq %eax, %rsi
movq -0x8(%rbx,%rsi,8), %rdi
movq %rdi, %r8
shrq $0x1e, %r8
xorl %edi, %r8d
imull $0x5d588b65, %r8d, %edi # imm = 0x5D588B65
xorl (%rbx,%rsi,8), %edi
subl %esi, %edi
movq %rdi, (%rbx,%rsi,8)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x82e7
incl %eax
jmp 0x82f3
movq 0x1378(%rbx), %rax
movq %rax, (%rbx)
movl %edx, %eax
incl %ecx
jmp 0x82b6
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, (%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1380(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
decl 0x1380(%rdi)
je 0x8334
movq 0x1388(%rbx), %rax
jmp 0x841c
cmpl $0x0, 0x1384(%rbx)
jne 0x834a
movl $0x1571, %esi           # imm = 0x1571
movq %rbx, %rdi
callq 0x81e4
movl $0x9908b0df, %ecx       # imm = 0x9908B0DF
movl $0x270, 0x1380(%rbx)    # imm = 0x270
xorl %eax, %eax
movl $0x80000000, %edx       # imm = 0x80000000
cmpl $0x718, %eax            # imm = 0x718
je 0x83a1
movl (%rbx,%rax), %esi
andl %edx, %esi
movl 0x8(%rbx,%rax), %edi
movl %edi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orl %esi, %r8d
andl $0x1, %edi
negl %edi
movl $0x9908b0df, %esi       # imm = 0x9908B0DF
andl %edi, %esi
xorq 0xc68(%rbx,%rax), %rsi
shrl %r8d
xorq %r8, %rsi
movq %rsi, (%rbx,%rax)
addq $0x8, %rax
jmp 0x8360
addq %rbx, %rax
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
andl $0x80000000, %edi       # imm = 0x80000000
movq -0x718(%rax,%rdx,8), %rsi
cmpl $0x18c, %edx            # imm = 0x18C
je 0x83f3
movl 0x8(%rax,%rdx,8), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %r9d, %edi
shrl %edi
andl $0x1, %r8d
negl %r8d
movl $0x9908b0df, %r9d       # imm = 0x9908B0DF
andl %r8d, %r9d
xorl %edi, %r9d
xorq %rsi, %r9
movq %r9, (%rax,%rdx,8)
incq %rdx
jmp 0x83a6
movl (%rbx), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %r9d, %edi
shrl %edi
andl $0x1, %r8d
negl %r8d
andl %ecx, %r8d
xorl %edi, %r8d
xorq %rsi, %r8
movq %r8, (%rax,%rdx,8)
movq %rbx, %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x1388(%rbx)
movq (%rax), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movl %ecx, %eax
shll $0x7, %eax
andl $0x9d2c5680, %eax       # imm = 0x9D2C5680
xorq %rcx, %rax
movl %eax, %ecx
shll $0xf, %ecx
andl $0xefc60000, %ecx       # imm = 0xEFC60000
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x12, %rax
xorq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sTeeLM[P]dwipe/options.c
// Function: dwipe_options_log
void dwipe_options_log( void )
{
/**
 *  Prints a manifest of options to the log.
 *
 */

	dwipe_log( DWIPE_LOG_NOTICE, "Program options are set as follows..." );

	if( dwipe_options.autonuke )
	{
		dwipe_log( DWIPE_LOG_NOTICE, "  autonuke = %i (on)", dwipe_options.autonuke );
	}

	else
	{
		dwipe_log( DWIPE_LOG_NOTICE, "  autonuke = %i (off)", dwipe_options.autonuke );
	}


	dwipe_log( DWIPE_LOG_NOTICE, "  banner   = %s", dwipe_options.banner );
	dwipe_log( DWIPE_LOG_NOTICE, "  method   = %s", dwipe_method_label( dwipe_options.method ) );
	dwipe_log( DWIPE_LOG_NOTICE, "  rounds   = %i", dwipe_options.rounds );
	dwipe_log( DWIPE_LOG_NOTICE, "  sync     = %i", dwipe_options.sync );
	dwipe_log( DWIPE_LOG_NOTICE, "  exclude  = %s", dwipe_options.exclude == NULL ? "none" :  dwipe_options.exclude);

	switch( dwipe_options.verify )
	{
		case DWIPE_VERIFY_NONE:
			dwipe_log( DWIPE_LOG_NOTICE, "  verify   = %i (off)", dwipe_options.verify );
			break;

		case DWIPE_VERIFY_LAST:
			dwipe_log( DWIPE_LOG_NOTICE, "  verify   = %i (last pass)", dwipe_options.verify );
			break;

		case DWIPE_VERIFY_ALL:
			dwipe_log( DWIPE_LOG_NOTICE, "  verify   = %i (all passes)", dwipe_options.verify );
			break;

		default:
			dwipe_log( DWIPE_LOG_NOTICE, "  verify   = %i", dwipe_options.verify );
			break;
	}

}

// Assembly:
pushq %rbx
leaq 0x433d(%rip), %rsi      # 0xcdf7
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x73a8
movl 0x7d76(%rip), %edx      # 0x10840
testl %edx, %edx
je 0x8ada
leaq 0x4348(%rip), %rsi      # 0xce1d
pushq $0x3
popq %rdi
jmp 0x8ae6
leaq 0x4351(%rip), %rsi      # 0xce32
pushq $0x3
popq %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x73a8
movq 0x7d54(%rip), %rdx      # 0x10848
leaq 0x434d(%rip), %rsi      # 0xce48
pushq $0x3
popq %rbx
movl %ebx, %edi
xorl %eax, %eax
callq 0x73a8
movq 0x7d42(%rip), %rdi      # 0x10850
callq 0x7630
leaq 0x433e(%rip), %rsi      # 0xce58
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x73a8
movl 0x7d34(%rip), %edx      # 0x10860
leaq 0x4335(%rip), %rsi      # 0xce68
movl %ebx, %edi
xorl %eax, %eax
callq 0x73a8
movl 0x7d22(%rip), %edx      # 0x10864
leaq 0x432f(%rip), %rsi      # 0xce78
movl %ebx, %edi
xorl %eax, %eax
callq 0x73a8
movq 0x7d17(%rip), %rax      # 0x10870
testq %rax, %rax
leaq 0x4335(%rip), %rdx      # 0xce98
cmovneq %rax, %rdx
leaq 0x431a(%rip), %rsi      # 0xce88
movl %ebx, %edi
xorl %eax, %eax
callq 0x73a8
movl 0x7ceb(%rip), %edx      # 0x10868
cmpl $0x2, %edx
je 0x8ba7
cmpl $0x1, %edx
je 0x8b99
testl %edx, %edx
jne 0x8bb6
leaq 0x430b(%rip), %rsi      # 0xce9d
pushq $0x3
popq %rdi
xorl %edx, %edx
jmp 0x8bc0
leaq 0x4313(%rip), %rsi      # 0xceb3
pushq $0x3
popq %rdi
pushq $0x1
jmp 0x8bb3
leaq 0x4321(%rip), %rsi      # 0xcecf
pushq $0x3
popq %rdi
pushq $0x2
popq %rdx
jmp 0x8bc0
leaq 0x432f(%rip), %rsi      # 0xceec
pushq $0x3
popq %rdi
xorl %eax, %eax
popq %rbx
jmp 0x73a8
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x97b6
movl $0x1390, %edi           # imm = 0x1390
callq 0x3300
movq %rax, %rdi
movq %rax, (%r14)
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
shrq $0x3, %rdx
callq 0x8221
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r12
shrq $0x3, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x9802
movq (%rbx), %rdi
callq 0x831c
movq %rax, (%r15,%r13,8)
incq %r13
jmp 0x97ec
movl %r14d, %r12d
andl $0x7, %r12d
negq %r12
addq %r15, %r14
decq %r14
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x982b
movq (%rbx), %rdi
callq 0x831c
movb %al, (%r14,%r15)
decq %r15
jmp 0x9815
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rbx
testq %rbx, %rbx
jne 0x9861
movq %rdi, %r15
movl $0x1020, %edi           # imm = 0x1020
callq 0x3300
movq %rax, %rbx
movq %rax, (%r15)
testq %rax, %rax
je 0x98bc
movl $0x800, %eax            # imm = 0x800
cmpq $0x800, (%r14)          # imm = 0x800
ja 0x9889
leaq 0x8(%rbx), %rdi
xorl %ebp, %ebp
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x31d0
movl (%r14), %eax
testq %rax, %rax
je 0x98b5
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
movslq %eax, %rdx
callq 0x32a0
xorl %ebp, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x701f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x98a1
callq 0x3070
movl (%rax), %edi
leaq 0x3a4f(%rip), %rsi      # 0xd319
leaq 0x12df(%rip), %rdx      # 0xabb0
callq 0x7600
leaq 0x3a4d(%rip), %rsi      # 0xd32a
pushq $0x6
popq %rdi
xorl %eax, %eax
callq 0x73a8
pushq $-0x1
popq %rbp
jmp 0x98a8
// File: /workspace/github_c_makefile_star2_O2/lh3[P]pre-pe/pre-meta.c
// Function: trim_olig
static inline void trim_olig(bseq1_t *s, const char *adap, int is_5, int min_len, int max_pen, int *trim_pos, char *trim_seq, int if_output)
{
	int n_hits, l_adap;
	uint64_t hits[16];
	l_adap = strlen(adap);
	if (is_5) n_hits = lt_ue_rev(s->l_seq, s->seq, s->qual, l_adap, adap, 0, max_pen, min_len, 16, hits);
	else n_hits = lt_ue_for(s->l_seq, s->seq, s->qual, l_adap, adap, 0, max_pen, min_len, 16, hits);
	if (n_hits > 0) {
		int len = s->l_seq - (hits[n_hits-1]>>32); // trim the longest hit
		if (is_5) {
			if (len > min_len) { // trim
				if (if_output) {
					strncpy(trim_seq, s->seq, len);
					trim_seq[len] = 0;
					*trim_pos = len;
				}
				trim_bseq_5(s, len); 
			} else {
				memset(s->qual, 33+1, len); // reduce baseQ
			}
		} else {
			if (len > min_len) {  // trim
				s->l_seq -= len, s->seq[s->l_seq] = s->qual[s->l_seq] = 0;
			} else {
				memset(s->qual + (s->l_seq - len), 33+1, len); // reduce baseQ
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, 0x28(%rsp)
movl %r8d, %r14d
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl 0xf8(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rsi, %rdi
callq 0x20c0
movl (%rbx), %ebp
movl %ebp, 0x10(%rsp)
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
testl %r12d, %r12d
movq %rdx, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x30(%rsp), %r10
movl %ebp, %edi
movl %eax, %ecx
movq %r15, %r8
je 0x38d6
xorl %r9d, %r9d
pushq %r10
pushq $0x10
pushq %r13
pushq %r14
callq 0x2a0b
jmp 0x38e6
xorl %r9d, %r9d
pushq %r10
pushq $0x10
pushq %r13
pushq %r14
callq 0x292f
addq $0x20, %rsp
testl %eax, %eax
jle 0x398f
decl %eax
movq 0x30(%rsp,%rax,8), %rcx
movq %rcx, %rax
shrq $0x20, %rax
subl %eax, %ebp
testl %r12d, %r12d
je 0x3956
cmpl %r13d, %ebp
jle 0x39a1
cmpl $0x0, 0x14(%rsp)
je 0x393b
movslq %ebp, %r14
movq 0x20(%rsp), %r15
movq %r15, %rdi
movq 0x18(%rsp), %rsi
movq %r14, %rdx
callq 0x2070
movb $0x0, (%r15,%r14)
movq 0x28(%rsp), %rax
movl %ebp, (%rax)
movq %rbx, %rdi
movl %ebp, %esi
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x370d
cmpl %r13d, %ebp
jle 0x39ae
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl 0x10(%rsp), %edx
andl $0x80000000, %edx       # imm = 0x80000000
orl %ecx, %edx
movl %edx, (%rbx)
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andq %rcx, %rax
xorl %edx, %edx
movq 0x8(%rsp), %rsi
movb %dl, (%rsi,%rax)
movq 0x18(%rbx), %rax
movl (%rbx), %esi
andq %rcx, %rsi
movb %dl, (%rax,%rsi)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %rdx
pushq $0x22
popq %rsi
movq 0x8(%rsp), %rdi
jmp 0x39c0
sarq $0x20, %rcx
movq 0x8(%rsp), %rdi
addq %rcx, %rdi
movslq %ebp, %rdx
pushq $0x22
popq %rsi
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
cmpb %r15b, %r13b
jne 0x3a3f
movl %edi, %ebp
movzbl %r12b, %eax
movzbl %r14b, %ecx
cmpb %r14b, %r12b
movl %ecx, %edx
cmovgl %eax, %edx
cmovll %eax, %ecx
movsbl %dl, %esi
movsbl %cl, %eax
addl $-0x21, %eax
movw $0x2, %cx
cwtd
idivw %cx
cwtl
leal (%rsi,%rax), %ebx
addl $-0x21, %ebx
callq 0x2030
movq (%rax), %rax
movsbq %r13b, %rcx
cmpl %ebp, %ebx
cmovll %ebx, %ebp
shll $0x8, %ebp
addl $0x2100, %ebp           # imm = 0x2100
orl (%rax,%rcx,4), %ebp
jmp 0x3aa8
movl %r13d, 0x4(%rsp)
movsbl %r12b, %r13d
leal -0x21(%r13), %eax
cmpl %esi, %eax
setl %al
movsbl %r14b, %ebx
leal -0x21(%rbx), %ecx
cmpl %esi, %ecx
setl %cl
orb %al, %cl
movl $0x214e, %ebp           # imm = 0x214E
cmpb $0x1, %cl
jne 0x3aa8
callq 0x2030
movq (%rax), %rax
cmpb %r14b, %r12b
jle 0x3a93
movsbq 0x4(%rsp), %rcx
subl %ebx, %r13d
shll $0x8, %r13d
addl $0x2100, %r13d          # imm = 0x2100
orl (%rax,%rcx,4), %r13d
movl %r13d, %ebp
jmp 0x3aa8
movsbq %r15b, %rcx
subl %r13d, %ebx
shll $0x8, %ebx
addl $0x2100, %ebx           # imm = 0x2100
orl (%rax,%rcx,4), %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %esi, %rcx
xorl %eax, %eax
pushq $0x1
popq %rdx
cmpq %rcx, %rdx
jge 0x341d
movzbl (%rdi,%rdx), %esi
addl %esi, %eax
incq %rdx
jmp 0x340d
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
xorl %ebx, %ebx
cmpq $0x8, %rbx
je 0x3535
movq 0xbd00(%rip), %rax      # 0xf208
movq (%rax,%rbx,8), %rdi
movq 0xbcfd(%rip), %rax      # 0xf210
leaq 0x1f40(,%rax,8), %rsi
callq 0x2320
testq %rax, %rax
je 0x3542
movq 0xbcdc(%rip), %rcx      # 0xf208
movq %rax, (%rcx,%rbx,8)
incq %rbx
jmp 0x34fb
addq $0x3e8, 0xbcd0(%rip) # imm = 0x3E8
popq %rbx
retq
movq 0xba87(%rip), %rdi      # 0xefd0
leaq 0x7cf7(%rip), %rsi      # 0xb247
callq 0x21b0
pushq $0x1
popq %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
xorl %ebx, %ebx
movq 0xbca1(%rip), %rdi      # 0xf208
cmpq $0x8, %rbx
je 0x357b
movq (%rdi,%rbx,8), %rdi
callq 0x2210
incq %rbx
jmp 0x3560
callq 0x2210
andq $0x0, 0xbc80(%rip)      # 0xf208
andq $0x0, 0xbc80(%rip)      # 0xf210
andq $0x0, 0xbc80(%rip)      # 0xf218
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0xc, %r14
je 0x35ea
movq 0xbc6f(%rip), %rax      # 0xf220
movq (%rax,%rbx,8), %rax
movq (%rax,%r14,8), %rdi
movq 0xbc68(%rip), %rax      # 0xf228
movq (%rax,%rbx,8), %rax
leaq 0x1f40(,%rax,8), %rsi
callq 0x2320
testq %rax, %rax
je 0x3601
movq 0xbc43(%rip), %rcx      # 0xf220
movq (%rcx,%rbx,8), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0x35a4
movq 0xbc37(%rip), %rax      # 0xf228
addq $0x3e8, (%rax,%rbx,8)   # imm = 0x3E8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xb9c8(%rip), %rdi      # 0xefd0
leaq 0x7c38(%rip), %rsi      # 0xb247
callq 0x21b0
pushq $0x1
popq %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq $0x10, %rbx
je 0x366c
xorl %r14d, %r14d
movq 0xbbee(%rip), %rax      # 0xf220
movq (%rax,%rbx,8), %rdi
cmpq $0xc, %r14
je 0x364a
movq (%rdi,%r14,8), %rdi
callq 0x2210
incq %r14
jmp 0x362b
callq 0x2210
movq 0xbbd2(%rip), %rax      # 0xf228
andq $0x0, (%rax,%rbx,8)
movq 0xbbce(%rip), %rax      # 0xf230
andq $0x0, (%rax,%rbx,8)
incq %rbx
jmp 0x3622
movq 0xbbb5(%rip), %rdi      # 0xf228
callq 0x2210
movq 0xbbb1(%rip), %rdi      # 0xf230
callq 0x2210
movq 0xbb95(%rip), %rdi      # 0xf220
callq 0x2210
andq $0x0, 0xbb88(%rip)      # 0xf220
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %edi, %ebx
leaq 0x7bb2(%rip), %rdi      # 0xb26b
leaq 0x79d8(%rip), %rsi      # 0xb098
movq %rsp, %rdx
callq 0x7a31
cmpq $0x0, 0xbb48(%rip)      # 0xf218
movzbl %bl, %ebx
jle 0x36e4
movq %rsp, %rdi
movl %ebx, %esi
callq 0x375d
callq 0x355d
leaq 0x7b8a(%rip), %rdi      # 0xb275
leaq 0x79a6(%rip), %rsi      # 0xb098
movq %rsp, %r14
movq %r14, %rdx
callq 0x7a31
leaq 0x7bac(%rip), %r13      # 0xb2b0
xorl %r15d, %r15d
leaq 0x70(%rsp), %r12
cmpq $0x10, %r15
je 0x3747
movsd (%r13), %xmm0
movq %r12, %rdi
movq %r14, %rsi
callq 0x3872
movq 0xbb06(%rip), %rax      # 0xf230
cmpq $0x0, (%rax,%r15,8)
jle 0x373e
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x3901
incq %r15
addq $0x8, %r13
jmp 0x370c
callq 0x361c
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2340
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2040
xorl %r15d, %r15d
leaq 0x7aa1(%rip), %r12      # 0xb239
leaq 0x8(%rsp), %r14
leaq 0x7adc(%rip), %r13      # 0xb280
cmpq 0xba6d(%rip), %r15      # 0xf218
jge 0x3807
xorl %ebp, %ebp
cmpq $0x7, %rbp
je 0x37d9
cmpq $0x8, %rbp
je 0x3802
movq 0xba46(%rip), %rax      # 0xf208
movq (%rax,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
callq 0x2310
movq %r13, %rsi
jmp 0x37f5
movq 0xba28(%rip), %rax      # 0xf208
movq 0x38(%rax), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
callq 0x2310
movq %r12, %rsi
movq %rax, %rdi
callq 0x21b0
incq %rbp
jmp 0x37af
incq %r15
jmp 0x37a4
testb %bl, %bl
je 0x382b
leaq 0x7a70(%rip), %rsi      # 0xb282
leaq 0x8(%rsp), %rdi
callq 0x21b0
leaq 0x7a16(%rip), %rsi      # 0xb239
movq %rax, %rdi
callq 0x21b0
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x2280
leaq 0x8(%rsp), %rdi
callq 0x22a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x385d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x20a0
movq %rax, %r15
subq %r14, %r15
leaq -0x2(%r15), %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x20d0
xorl %ebp, %ebp
movb %bpl, -0x1(%r15,%r12)
leaq 0x79d5(%rip), %rsi      # 0xb295
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2060
movb %bpl, (%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2370
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %edx, 0x4(%rsp)
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2340
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2040
xorl %r12d, %r12d
leaq 0x78f8(%rip), %r13      # 0xb239
leaq 0x8(%rsp), %r15
leaq 0x7933(%rip), %rbp      # 0xb280
movq 0xb8dc(%rip), %rax      # 0xf230
cmpq (%rax,%r14,8), %r12
jge 0x39bc
xorl %ebx, %ebx
cmpq $0xb, %rbx
je 0x398a
cmpq $0xc, %rbx
je 0x39b7
movq 0xb8b1(%rip), %rax      # 0xf220
movq (%rax,%r14,8), %rax
movq (%rax,%rbx,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r15, %rdi
callq 0x2310
movq %rbp, %rsi
jmp 0x39aa
movq 0xb88f(%rip), %rax      # 0xf220
movq (%rax,%r14,8), %rax
movq 0x58(%rax), %rax
movsd (%rax,%r12,8), %xmm0
movq %r15, %rdi
callq 0x2310
movq %r13, %rsi
movq %rax, %rdi
callq 0x21b0
incq %rbx
jmp 0x395c
incq %r12
jmp 0x394d
cmpb $0x0, 0x4(%rsp)
je 0x39e3
leaq 0x78b8(%rip), %rsi      # 0xb282
leaq 0x8(%rsp), %rdi
callq 0x21b0
leaq 0x785e(%rip), %rsi      # 0xb239
movq %rax, %rdi
callq 0x21b0
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x2280
leaq 0x8(%rsp), %rdi
callq 0x22a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a15
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_c_makefile_star2_O2/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: SaveFields(densitystruct_s*, long)
void SaveFields(struct densitystruct_s* fieldstruct, long ObjectTimeindex){
	long i;
	char filename[200],protofilename[200];
	ofstream myfile; //Output file handle
	
	sprintf(protofilename, "fields_t%g.txt", CMFTimes[ObjectTimeindex]);
	ContructFilePath(protofilename, "Output", filename); //file where data about fields should go
	
    //Open file
    myfile.open(filename,ios::app);
	#if (ExtraVerboseOutput==true)
	cout<<"Fields output file "<< filename<<"\n";
	#endif
    //Save field data
    for ( i = 0; i < NgridTotal; i++ ){
		myfile<<fieldstruct[0].xcoord[i]<<"\t"<<fieldstruct[0].ycoord[i]<<"\t"<<fieldstruct[0].zcoord[i]<<"\t"<<fieldstruct[0].rho_field[i]<<"\t"<<fieldstruct[0].T_field[i]<<"\t"<<fieldstruct[0].volume<<"\n";
     }
     myfile.flush(); //finish writing
     myfile.close(); //close file	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3a0, %rsp            # imm = 0x3A0
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x2340
leaq 0x7830(%rip), %rax      # 0xb2b0
movsd (%rax,%r14,8), %xmm0
leaq 0x77f9(%rip), %rsi      # 0xb286
leaq 0x2d0(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x2060
leaq 0x75f2(%rip), %rsi      # 0xb098
leaq 0x200(%rsp), %rdx
movq %r14, %rdi
callq 0x7a31
movq %rsp, %rdi
leaq 0x200(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x2040
movq $-0x40000, %r13         # imm = 0xFFFC0000
movq %rsp, %r14
leaq 0x77a6(%rip), %r15      # 0xb280
leaq 0x7758(%rip), %r12      # 0xb239
testq %r13, %r13
je 0x3b9f
movsd 0xc0000(%rbx,%r13), %xmm0
movq %r14, %rdi
callq 0x2310
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movsd 0x100000(%rbx,%r13), %xmm0
movq %rax, %rdi
callq 0x2310
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movsd 0x140000(%rbx,%r13), %xmm0
movq %rax, %rdi
callq 0x2310
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movsd 0x40000(%rbx,%r13), %xmm0
movq %rax, %rdi
callq 0x2310
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movsd 0x80000(%rbx,%r13), %xmm0
movq %rax, %rdi
callq 0x2310
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movsd 0x140000(%rbx), %xmm0
movq %rax, %rdi
callq 0x2310
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
addq $0x8, %r13
jmp 0x3ae1
movq %rsp, %rdi
callq 0x2100
movq %rsp, %rdi
callq 0x2280
movq %rsp, %rdi
callq 0x22a0
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3bca
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0xb624(%rip), %rax      # 0xf208
movq (%rax), %rcx
movq 0xb62a(%rip), %rdx      # 0xf218
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movsd %xmm1, (%rcx,%rdx,8)
movq 0x10(%rax), %rcx
movsd %xmm2, (%rcx,%rdx,8)
movq 0x18(%rax), %rcx
movsd %xmm3, (%rcx,%rdx,8)
movq 0x20(%rax), %rcx
movsd %xmm4, (%rcx,%rdx,8)
movq 0x28(%rax), %rcx
movsd %xmm5, (%rcx,%rdx,8)
movq 0x30(%rax), %rcx
movsd %xmm6, (%rcx,%rdx,8)
movq 0x38(%rax), %rax
movsd %xmm7, (%rax,%rdx,8)
incq %rdx
movq %rdx, 0xb5dc(%rip)      # 0xf218
retq
// File: /workspace/github_c_makefile_star2_O2/guszejnovdavid[P]MISFIT/StarsAndCores.cpp
// Function: AssignCoreMatrixValues(long, double, double, double, double, double, double, double, double, double, double, double, double)
void AssignCoreMatrixValues(long timeindex, double MassInit, double Mass, double X0, double Y0, double Z0, double RelativeVelocityX, double RelativeVelocityY, double RelativeVelocityZ, double Machedge, double Temperature, double Radius, double RhoAverage){
	CoreMatrix[timeindex][0][NCoresCurrent[timeindex]]=MassInit;
	CoreMatrix[timeindex][1][NCoresCurrent[timeindex]]=Mass;
	CoreMatrix[timeindex][2][NCoresCurrent[timeindex]]=X0;
	CoreMatrix[timeindex][3][NCoresCurrent[timeindex]]=Y0;
	CoreMatrix[timeindex][4][NCoresCurrent[timeindex]]=Z0;
	CoreMatrix[timeindex][5][NCoresCurrent[timeindex]]=RelativeVelocityX;
	CoreMatrix[timeindex][6][NCoresCurrent[timeindex]]=RelativeVelocityY;
	CoreMatrix[timeindex][7][NCoresCurrent[timeindex]]=RelativeVelocityZ;
	CoreMatrix[timeindex][8][NCoresCurrent[timeindex]]=Machedge;
	CoreMatrix[timeindex][9][NCoresCurrent[timeindex]]=Temperature;
	CoreMatrix[timeindex][10][NCoresCurrent[timeindex]]=Radius;
	CoreMatrix[timeindex][11][NCoresCurrent[timeindex]]=RhoAverage;
	NCoresCurrent[timeindex]++; //one more star has been added
}

// Assembly:
movsd 0x20(%rsp), %xmm8
movsd 0x18(%rsp), %xmm9
movsd 0x10(%rsp), %xmm10
movsd 0x8(%rsp), %xmm11
movq 0xb5c0(%rip), %rax      # 0xf220
movq (%rax,%rdi,8), %rax
movq (%rax), %rcx
movq 0xb5c2(%rip), %rdx      # 0xf230
movq (%rdx,%rdi,8), %rsi
movsd %xmm0, (%rcx,%rsi,8)
movq 0x8(%rax), %rcx
movsd %xmm1, (%rcx,%rsi,8)
movq 0x10(%rax), %rcx
movsd %xmm2, (%rcx,%rsi,8)
movq 0x18(%rax), %rcx
movsd %xmm3, (%rcx,%rsi,8)
movq 0x20(%rax), %rcx
movsd %xmm4, (%rcx,%rsi,8)
movq 0x28(%rax), %rcx
movsd %xmm5, (%rcx,%rsi,8)
movq 0x30(%rax), %rcx
movsd %xmm6, (%rcx,%rsi,8)
movq 0x38(%rax), %rcx
movsd %xmm7, (%rcx,%rsi,8)
movq 0x40(%rax), %rcx
movsd %xmm11, (%rcx,%rsi,8)
movq 0x48(%rax), %rcx
movsd %xmm10, (%rcx,%rsi,8)
movq 0x50(%rax), %rcx
movsd %xmm9, (%rcx,%rsi,8)
movq 0x58(%rax), %rax
movsd %xmm8, (%rax,%rsi,8)
incq %rsi
movq %rsi, (%rdx,%rdi,8)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
andq $0x0, 0xb51d(%rip)      # 0xf210
andq $0x0, 0xb51d(%rip)      # 0xf218
pushq $0x10
popq %r14
pushq $0x8
popq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, 0xb514(%rip)      # 0xf228
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, 0xb50a(%rip)      # 0xf230
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, 0xb4d0(%rip)      # 0xf208
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, 0xb4d6(%rip)      # 0xf220
xorl %r15d, %r15d
pushq $0xc
popq %r14
cmpq $0x10, %r15
je 0x3d72
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0xb4b7(%rip), %rcx      # 0xf220
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x3d51
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/guszejnovdavid[P]MISFIT/Heating.c
// Function: RhoTempFieldWithHeating(double, double*, double*, double*, long)
void RhoTempFieldWithHeating(double HeatTemp, double* TField, double* RhoField, double* Rho_T_Field, long N)
// Calculates the rho*T field where heating is taken into account
{
	long i;
	double factor=1.0;
	double HeatTemp4=pow(HeatTemp,4.0);
	#if (R05Heating==true)
	double x,y,z;
	const long Nsq=Ngrid*Ngrid;
	const double Nhalf=(double)(Ngrid-1)/2.0;
	#endif
	
	for(i=0;i<N;i++){
		#if (R05Heating==true)
		x= (double)(i/Nsq)-Nhalf; //x coordinate index
     	y= (double)((i % Nsq)/Ngrid)-Nhalf; //y coordinate index
     	z= (double)(i % Ngrid)-Nhalf; //z coordinate index
     	factor=Nhalf*Nhalf/(x*x+y*y+z*z); // (sqrt(r0/r))^4
     	#endif
		Rho_T_Field[i]=pow(factor*HeatTemp4+pow(TField[i],4.0),0.25)*RhoField[i];
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd 0x7560(%rip), %xmm1     # 0xb348
callq 0x2350
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
testq %rbx, %rbx
cmovleq %r13, %rbx
cmpq %r13, %rbx
je 0x3e39
movsd (%r12,%r13,8), %xmm0
movsd 0x7538(%rip), %xmm1     # 0xb348
callq 0x2350
addsd 0x8(%rsp), %xmm0
movsd 0x752d(%rip), %xmm1     # 0xb350
callq 0x2350
mulsd (%r15,%r13,8), %xmm0
movsd %xmm0, (%r14,%r13,8)
incq %r13
jmp 0x3dfd
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop