LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_insert
void rbtree_insert(struct rbtree *t, struct rbtree_head *node)
{
	struct rbtree_head *prev = &t->rbt_nil;
	struct rbtree_head *n = t->rbt_root;

	while (!rbt_is_nil(t, n)) {
		prev = n;
		n = node->key < n->key ? n->left : n->right;
	}

	if (!rbt_is_nil(t, prev)) {
		rbt_set_p(node, prev);
		if (node->key < prev->key)
			prev->left = node;
		else
			prev->right = node;
	} else {
		rbt_set_p(node, &t->rbt_nil);
		t->rbt_root = node;
	}

	rbt_set_color(node, RBT_RED);	/* Color new node in red */
	node->left = &t->rbt_nil;
	node->right = &t->rbt_nil;

	__rbtree_insert_fixup(t, node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rdx
movq (%rdi), %rcx
cmpq %rcx, %rdx
je 0x2f3c
movl 0x18(%r14), %esi
movq %rcx, %rdi
movq %rdi, %rax
xorl %edi, %edi
cmpl 0x18(%rax), %esi
setae %dil
movq 0x8(%rax,%rdi,8), %rdi
cmpq %rdi, %rdx
jne 0x2f01
cmpq %rax, %rdx
je 0x2f3c
movq %rax, %rsi
andq $-0x2, %rsi
movq (%r14), %r15
andl $0x1, %r15d
orq %rsi, %r15
movl 0x18(%r14), %esi
cmpl 0x18(%rax), %esi
jae 0x2f55
addq $0x8, %rax
jmp 0x2f59
movq %rdx, %rax
andq $-0x2, %rax
movq (%r14), %r15
andl $0x1, %r15d
orq %rax, %r15
movq %rbx, %rax
movq %r14, %rcx
jmp 0x2f59
addq $0x10, %rax
movq %r14, (%rax)
movq %r15, %rax
orq $0x1, %rax
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq %rdx, 0x10(%r14)
andq $-0x2, %r15
movq (%r15), %rdx
testb $0x1, %dl
je 0x306c
andq $-0x2, %rdx
movq 0x8(%rdx), %rcx
cmpq %r15, %rcx
je 0x2fdc
testb $0x1, (%rcx)
jne 0x302d
cmpq 0x8(%r15), %r14
jne 0x2fab
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e6d
movq (%r15), %rax
movq %r15, %r14
andq $-0x2, %rax
andb $-0x2, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rax
andq $-0x2, %rax
orq $0x1, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rsi
andq $-0x2, %rsi
movq %rbx, %rdi
callq 0x2df7
jmp 0x3053
movq 0x10(%rdx), %rcx
testb $0x1, (%rcx)
jne 0x302d
cmpq 0x10(%r15), %r14
jne 0x2ffc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2df7
movq (%r15), %rax
movq %r15, %r14
andq $-0x2, %rax
andb $-0x2, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rax
andq $-0x2, %rax
orq $0x1, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rsi
andq $-0x2, %rsi
movq %rbx, %rdi
callq 0x2e6d
jmp 0x3053
movq %rdx, (%r15)
andb $-0x2, (%rcx)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rax
andq $-0x2, %rax
orq $0x1, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %r14
andq $-0x2, %r14
movq (%r14), %rax
movq %rax, %r15
andq $-0x2, %r15
movq (%r15), %rdx
testb $0x1, %dl
jne 0x2f7e
movq (%rbx), %rcx
andb $-0x2, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_lookup
struct rbtree_head *rbtree_lookup(struct rbtree *t, uint32_t key)
{
	struct rbtree_head *n = t->rbt_root;

	while (!rbt_is_nil(t, n)) {
		if (n->key == key)
			return n;
		else if (n->key > key)
			n = n->left;
		else
			n = n->right;
	}

	return &t->rbt_nil;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
addq $0x8, %rax
cmpq %rcx, %rax
je 0x3331
cmpl %esi, 0x18(%rcx)
je 0x332e
setbe %dl
movzbl %dl, %edx
movq 0x8(%rcx,%rdx,8), %rcx
jmp 0x3317
movq %rcx, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: regf_cell_check_sign
int regf_cell_check_sign(const void *base, unsigned off, const char *sign)
{
	const struct regf_cell *cell = base + off;

	if (__regf_cell_check_basic(cell, off, sign))
		return -1;

	return __regf_cell_check_sign(cell, off, sign);
}

// Assembly:
pushq %rax
testb $0x7, %sil
je 0x3398
leaq 0x1b66(%rip), %rdi      # 0x4efc
jmp 0x33ae
movq %rdi, %r9
movl %esi, %eax
addq %rax, %r9
movl (%r9), %ecx
testl %ecx, %ecx
jle 0x33bc
leaq 0x1b74(%rip), %rdi      # 0x4f22
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
je 0x33d5
negl %ecx
testb $0x7, %cl
je 0x33de
leaq 0x1b9c(%rip), %rdi      # 0x4f68
xorl %eax, %eax
callq 0x1339
jmp 0x33b5
leaq 0x1b6d(%rip), %rdi      # 0x4f49
jmp 0x33ae
movzwl 0x4(%r9), %ecx
xorl %eax, %eax
cmpw (%rdx), %cx
je 0x33ba
addq $0x4, %r9
movl %ecx, %eax
shrl $0x8, %eax
movsbl %cl, %ecx
movsbl %al, %r8d
leaq 0x1b94(%rip), %rdi      # 0x4f95
xorl %eax, %eax
callq 0x1339
jmp 0x33b5
// File: /workspace/github_c_makefile_star2_O3/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: regf_cell_check_len
int regf_cell_check_len(const void *base, unsigned off, const char *cell_type,
			unsigned data_min_len)
{
	const struct regf_cell *cell = base + off;

	if (__regf_cell_check_basic(cell, off, cell_type))
		return -1;

	return __regf_cell_check_len(cell, off, cell_type, data_min_len);
}

// Assembly:
pushq %rax
testb $0x7, %sil
je 0x341a
leaq 0x1ae4(%rip), %rdi      # 0x4efc
jmp 0x342d
movl %ecx, %r8d
movl %esi, %eax
movl (%rdi,%rax), %ecx
testl %ecx, %ecx
jle 0x343b
leaq 0x1af5(%rip), %rdi      # 0x4f22
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
je 0x3454
negl %ecx
testb $0x7, %cl
je 0x345d
leaq 0x1b1d(%rip), %rdi      # 0x4f68
xorl %eax, %eax
callq 0x1339
jmp 0x3434
leaq 0x1aee(%rip), %rdi      # 0x4f49
jmp 0x342d
leal 0xb(%r8), %edi
andl $-0x8, %edi
xorl %eax, %eax
cmpl %ecx, %edi
jbe 0x3439
movl %ecx, %ecx
addq $-0x4, %rcx
leaq 0x1b56(%rip), %rdi      # 0x4fcd
xorl %eax, %eax
callq 0x1339
jmp 0x3434
// File: /workspace/github_c_makefile_star2_O3/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: regf_cell_check_sign_len
int regf_cell_check_sign_len(const void *base, unsigned off, const char *sign,
			     unsigned data_min_len)
{
	const struct regf_cell *cell = base + off;

	if (__regf_cell_check_basic(cell, off, sign))
		return -1;

	if (__regf_cell_check_sign(cell, off, sign))
		return -1;

	return __regf_cell_check_len(cell, off, sign, data_min_len);
}

// Assembly:
pushq %rax
testb $0x7, %sil
je 0x3490
leaq 0x1a6e(%rip), %rdi      # 0x4efc
jmp 0x34a9
movl %ecx, %r8d
movq %rdi, %r9
movl %esi, %eax
addq %rax, %r9
movl (%r9), %ecx
testl %ecx, %ecx
jle 0x34b7
leaq 0x1a79(%rip), %rdi      # 0x4f22
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
je 0x34d0
negl %ecx
testb $0x7, %cl
je 0x34d9
leaq 0x1aa1(%rip), %rdi      # 0x4f68
xorl %eax, %eax
callq 0x1339
jmp 0x34b0
leaq 0x1a72(%rip), %rdi      # 0x4f49
jmp 0x34a9
movzwl 0x4(%r9), %eax
cmpw (%rdx), %ax
jne 0x3506
leal 0xb(%r8), %edi
andl $-0x8, %edi
xorl %eax, %eax
cmpl %ecx, %edi
jbe 0x34b5
movl %ecx, %ecx
addq $-0x4, %rcx
leaq 0x1ad0(%rip), %rdi      # 0x4fcd
xorl %eax, %eax
callq 0x1339
jmp 0x34b0
addq $0x4, %r9
movl %eax, %edi
shrl $0x8, %edi
movsbl %al, %ecx
movsbl %dil, %r8d
leaq 0x1a78(%rip), %rdi      # 0x4f95
xorl %eax, %eax
callq 0x1339
jmp 0x34b0
// File: /workspace/github_c_makefile_star2_O3/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 0x388b
fld %st(0)
fmuls 0x77a4(%rip)            # 0xb014
fxch %st(1)
fdivl 0x77a0(%rip)            # 0xb018
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x7f2f(%rip), %rdx      # 0xb7b8
jmp 0x38f0
cmpq $0x40000001, %rdx       # imm = 0x40000001
jl 0x38b7
fld %st(0)
fmuls 0x7770(%rip)            # 0xb00c
fxch %st(1)
fdivs 0x776c(%rip)            # 0xb010
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x7f1d(%rip), %rdx      # 0xb7d2
jmp 0x38f0
cmpq $0x100001, %rdx         # imm = 0x100001
jl 0x38e3
fld %st(0)
fmuls 0x773c(%rip)            # 0xb004
fxch %st(1)
fdivs 0x7738(%rip)            # 0xb008
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x7f0b(%rip), %rdx      # 0xb7ec
jmp 0x38f0
movslq %esi, %rsi
fstpt (%rsp)
leaq 0x7f16(%rip), %rdx      # 0xb806
xorl %eax, %eax
callq 0x3180
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x669f(%rip), %rdi      # 0xd0a7
leaq 0x468e(%rip), %rsi      # 0xb09d
callq 0x3290
movq %rax, %rbx
movq 0xae02(%rip), %rdi      # 0x11820
leaq 0x6690(%rip), %rcx      # 0xd0b5
movl $0x3, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x31c0
testq %rbx, %rbx
je 0x6a96
leaq 0x6682(%rip), %rsi      # 0xd0c4
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30e0
movq 0xadbe(%rip), %r14      # 0x11820
cmpl $0x3, %eax
jne 0x6ac7
cvtss2sd 0x14(%rsp), %xmm0
cvtss2sd 0x10(%rsp), %xmm1
cvtss2sd 0xc(%rsp), %xmm2
leaq 0x664d(%rip), %rcx      # 0xd0cd
movq %r14, %rdi
movl $0x3, %esi
movl $0x10, %edx
movb $0x3, %al
callq 0x31c0
jmp 0x6aea
movq 0xad83(%rip), %rbx      # 0x11820
callq 0x3070
movl (%rax), %r8d
leaq 0x6648(%rip), %rcx      # 0xd0f4
movq %rbx, %rdi
movl $0x3, %esi
movl $0x10, %edx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x31c0
callq 0x3070
movl (%rax), %r8d
leaq 0x660c(%rip), %rcx      # 0xd0e2
movq %r14, %rdi
movl $0x3, %esi
movl $0x10, %edx
xorl %eax, %eax
callq 0x31c0
movq %rbx, %rdi
callq 0x3140
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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        # 0x7d81
cmpq %rax, %rdi
je 0x7d52
leaq 0x188(%rip), %rax       # 0x7e93
cmpq %rax, %rdi
je 0x7d5b
leaq 0x23f(%rip), %rax       # 0x7f56
cmpq %rax, %rdi
je 0x7d64
leaq 0x3ad(%rip), %rax       # 0x80d0
cmpq %rax, %rdi
je 0x7d6d
leaq 0x576(%rip), %rax       # 0x82a5
cmpq %rax, %rdi
je 0x7d76
leaq 0x590(%rip), %rax       # 0x82cb
cmpq %rax, %rdi
leaq 0x9953(%rip), %rcx      # 0x11698
leaq 0x9954(%rip), %rax      # 0x116a0
cmoveq %rcx, %rax
jmp 0x7d7d
leaq 0x9917(%rip), %rax      # 0x11670
jmp 0x7d7d
leaq 0x9916(%rip), %rax      # 0x11678
jmp 0x7d7d
leaq 0x9915(%rip), %rax      # 0x11680
jmp 0x7d7d
leaq 0x9914(%rip), %rax      # 0x11688
jmp 0x7d7d
leaq 0x9913(%rip), %rax      # 0x11690
movq (%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
movl $0x1, %eax
movl %eax, 0x10(%rsp)
leaq 0x9(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl %eax, 0x20(%rsp)
leaq 0xa(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, 0x30(%rsp)
leaq 0x5c0f(%rip), %rcx      # 0xd9cf
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)
movl %ebx, 0x70(%rsp)
movq %rcx, 0x78(%rsp)
movl $0x0, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movl 0x2d8(%rdi), %edi
movl $0x7, %edx
callq 0x3240
cmpl $0x7, %eax
jne 0x7e49
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 %r14, %rdi
callq 0x82e2
movl %eax, %ebx
jmp 0x7e85
callq 0x3070
movl (%rax), %ebp
leaq 0x561f(%rip), %rsi      # 0xd476
leaq 0x5629(%rip), %rdx      # 0xd487
movl %ebp, %edi
callq 0x7cc3
movq 0x9804(%rip), %rdx      # 0x11670
leaq 0x5619(%rip), %rsi      # 0xd48c
movl $0x6, %edi
xorl %eax, %eax
callq 0x7a7c
cmpl $-0x1, %ebp
cmovll %ebp, %ebx
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movl $0x1, %ecx
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
cmpq $0x270, %rcx            # imm = 0x270
jne 0x8a56
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1380(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x271, %rdx            # imm = 0x271
movl $0x270, %ecx            # imm = 0x270
cmovaeq %rdx, %rcx
movq $0x12bd6aa, (%rdi)      # imm = 0x12BD6AA
movl $0x1, %eax
movl $0x12bd6aa, %r8d        # imm = 0x12BD6AA
movq %r8, %r9
shrq $0x1e, %r9
xorl %r8d, %r9d
imull $0x6c078965, %r9d, %r8d # imm = 0x6C078965
addl %eax, %r8d
movq %r8, (%rdi,%rax,8)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x8aab
testl %ecx, %ecx
je 0x8b3e
pushq %r14
pushq %rbx
movl $0x1, %eax
xorl %r8d, %r8d
xorl %r9d, %r9d
movslq %eax, %r10
movq -0x8(%rdi,%r10,8), %r11
movq %r11, %rbx
shrq $0x1e, %rbx
xorl %r11d, %ebx
imull $0x19660d, %ebx, %r11d  # imm = 0x19660D
xorl (%rdi,%r10,8), %r11d
movslq %r9d, %rbx
movl (%rsi,%rbx,8), %r14d
addl %ebx, %r14d
addl %r11d, %r14d
movq %r14, (%rdi,%r10,8)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x8b19
incl %eax
jmp 0x8b28
movq 0x1378(%rdi), %rax
movq %rax, (%rdi)
movl $0x1, %eax
incl %r9d
movslq %r9d, %r9
cmpq %rdx, %r9
cmovael %r8d, %r9d
decl %ecx
jne 0x8ae0
popq %rbx
popq %r14
jmp 0x8b43
movl $0x1, %eax
movl $0xfffffd91, %ecx       # imm = 0xFFFFFD91
movslq %eax, %rdx
movq -0x8(%rdi,%rdx,8), %rsi
movq %rsi, %r8
shrq $0x1e, %r8
xorl %esi, %r8d
imull $0x5d588b65, %r8d, %esi # imm = 0x5D588B65
xorl (%rdi,%rdx,8), %esi
subl %edx, %esi
movq %rsi, (%rdi,%rdx,8)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x8b75
incl %eax
jmp 0x8b84
movq 0x1378(%rdi), %rax
movq %rax, (%rdi)
movl $0x1, %eax
incl %ecx
jne 0x8b48
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, (%rdi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1380(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
decl 0x1380(%rdi)
je 0x8bb6
movq 0x1388(%rdi), %rax
jmp 0x8d0f
cmpl $0x0, 0x1384(%rdi)
je 0x8bc4
movq (%rdi), %rdx
jmp 0x8c04
movq $0x1571, (%rdi)         # imm = 0x1571
movl $0x1, %eax
movl $0x1571, %ecx           # imm = 0x1571
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x8bd5
movl $0x1, 0x1384(%rdi)
movl $0x1571, %edx           # imm = 0x1571
movl $0x9908b0df, %ecx       # imm = 0x9908B0DF
movl $0x270, 0x1380(%rdi)    # imm = 0x270
xorl %eax, %eax
movl %edx, %esi
andl $0x80000000, %esi       # imm = 0x80000000
movq 0x8(%rdi,%rax), %rdx
movl %edx, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orl %esi, %r8d
shrl %r8d
movl %edx, %esi
andl $0x1, %esi
negl %esi
andl %ecx, %esi
xorq 0xc68(%rdi,%rax), %rsi
xorq %r8, %rsi
movq %rsi, (%rdi,%rax)
addq $0x8, %rax
cmpl $0x718, %eax            # imm = 0x718
jne 0x8c15
leaq (%rdi,%rax), %rsi
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movl $0x1, %edx
movaps 0x4cc1(%rip), %xmm1     # 0xd930
movaps 0x4cca(%rip), %xmm2     # 0xd940
movdqa 0x4cd2(%rip), %xmm3     # 0xd950
movdqa %xmm0, %xmm4
movdqu -0x720(%rsi,%rdx,8), %xmm5
movups (%rsi,%rdx,8), %xmm0
shufps $0x4e, %xmm0, %xmm4     # xmm4 = xmm4[2,3],xmm0[0,1]
andps %xmm1, %xmm4
movaps %xmm0, %xmm6
andps %xmm2, %xmm6
orps %xmm4, %xmm6
psrlq $0x1, %xmm6
movaps %xmm0, %xmm4
pslld $0x1f, %xmm4
psrad $0x1f, %xmm4
pand %xmm3, %xmm4
pxor %xmm5, %xmm4
pxor %xmm6, %xmm4
movdqu %xmm4, -0x8(%rsi,%rdx,8)
addq $0x2, %rdx
cmpq $0x18d, %rdx            # imm = 0x18D
jne 0x8c7e
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rdx
andl $0x80000000, %edx       # imm = 0x80000000
movl (%rdi), %esi
movl %esi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orl %edx, %r8d
andl $0x1, %esi
negl %esi
andl %ecx, %esi
xorq 0x548(%rdi,%rax), %rsi
shrl %r8d
xorq %r8, %rsi
movq %rsi, 0xc60(%rdi,%rax)
movq %rdi, %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x1388(%rdi)
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
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x4c97(%rip), %rsi      # 0xde2b
movl $0x3, %edi
xorl %eax, %eax
callq 0x7a7c
movl 0x869a(%rip), %edx      # 0x11840
testl %edx, %edx
je 0x91b8
leaq 0x4ca0(%rip), %rsi      # 0xde51
movl $0x3, %edi
jmp 0x91c6
leaq 0x4ca7(%rip), %rsi      # 0xde66
movl $0x3, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x7a7c
movq 0x8674(%rip), %rdx      # 0x11848
leaq 0x4ca1(%rip), %rsi      # 0xde7c
movl $0x3, %edi
xorl %eax, %eax
callq 0x7a7c
movq 0x8662(%rip), %rdi      # 0x11850
callq 0x7cf8
leaq 0x4c92(%rip), %rsi      # 0xde8c
movl $0x3, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7a7c
movl 0x8651(%rip), %edx      # 0x11860
leaq 0x4c86(%rip), %rsi      # 0xde9c
movl $0x3, %edi
xorl %eax, %eax
callq 0x7a7c
movl 0x863c(%rip), %edx      # 0x11864
leaq 0x4c7d(%rip), %rsi      # 0xdeac
movl $0x3, %edi
xorl %eax, %eax
callq 0x7a7c
movq 0x862e(%rip), %rax      # 0x11870
testq %rax, %rax
leaq 0x4c80(%rip), %rdx      # 0xdecc
cmovneq %rax, %rdx
leaq 0x4c65(%rip), %rsi      # 0xdebc
movl $0x3, %edi
xorl %eax, %eax
callq 0x7a7c
movl 0x85ff(%rip), %edx      # 0x11868
cmpl $0x2, %edx
je 0x929a
cmpl $0x1, %edx
je 0x9287
testl %edx, %edx
jne 0x92ad
leaq 0x4c53(%rip), %rsi      # 0xded1
movl $0x3, %edi
xorl %edx, %edx
jmp 0x92b9
leaq 0x4c59(%rip), %rsi      # 0xdee7
movl $0x3, %edi
movl $0x1, %edx
jmp 0x92b9
leaq 0x4c62(%rip), %rsi      # 0xdf03
movl $0x3, %edi
movl $0x2, %edx
jmp 0x92b9
leaq 0x4c6c(%rip), %rsi      # 0xdf20
movl $0x3, %edi
xorl %eax, %eax
popq %rcx
jmp 0x7a7c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x9f7a
movl $0x1390, %edi           # imm = 0x1390
callq 0x3300
movq %rax, %rdi
movq %rax, (%r14)
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
shrq $0x3, %rdx
callq 0x8a89
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %r14d, %r12d
andl $0x7, %r12d
cmpq $0x8, %rdx
jb 0x9fd2
movq %r14, %r13
shrq $0x3, %r13
xorl %ebp, %ebp
movq (%rbx), %rdi
callq 0x8ba2
movq %rax, (%r15,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x9fbe
testq %r12, %r12
je 0x9ff7
negq %r12
addq %r15, %r14
decq %r14
xorl %r15d, %r15d
movq (%rbx), %rdi
callq 0x8ba2
movb %al, (%r14,%r15)
decq %r15
cmpq %r15, %r12
jne 0x9fe3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa032
movq %rdi, %r15
movl $0x1020, %edi           # imm = 0x1020
callq 0x3300
movq %rax, %rbx
movq %rax, (%r15)
testq %rax, %rax
je 0xa08f
movl $0x800, %eax            # imm = 0x800
cmpq $0x800, (%r14)          # imm = 0x800
ja 0xa05a
leaq 0x8(%rbx), %rdi
xorl %ebp, %ebp
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x31d0
movl (%r14), %eax
testq %rax, %rax
je 0xa088
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
movslq %eax, %rdx
callq 0x32a0
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x76e2
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
jmp 0xa074
callq 0x3070
movl (%rax), %edi
leaq 0x42b0(%rip), %rsi      # 0xe34d
leaq 0x1b0c(%rip), %rdx      # 0xbbb0
callq 0x7cc3
leaq 0x42ae(%rip), %rsi      # 0xe35e
movl $0x6, %edi
xorl %eax, %eax
callq 0x7a7c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0xa07b
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_24/check_syntax.c
// Function: main
int main(void)
{
  char str[MAXSTR];

  get_str(str, MAXSTR);
  check_syntax(str);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x2710, %rsp           # imm = 0x2710
xorl %ebx, %ebx
callq 0x1040
cmpl $-0x1, %eax
je 0x1174
movb %al, (%rsp,%rbx)
incq %rbx
cmpq $0x270f, %rbx           # imm = 0x270F
jne 0x1156
movl $0x270f, %ebx           # imm = 0x270F
movb $0x0, (%rsp,%rbx)
movq %rsp, %rdi
callq 0x11d5
xorl %eax, %eax
addq $0x2710, %rsp           # imm = 0x2710
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x35c1
movl %esi, %edx
movl $0x1, %ecx
cmpb $0x0, (%rdi,%rcx)
jne 0x35c2
incq %rcx
cmpq %rcx, %rdx
jne 0x35b3
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x35e3
movl %esi, %ecx
xorl %eax, %eax
movl $0x1, %edx
movzbl (%rdi,%rdx), %esi
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x35d5
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0xba38(%rip), %rax      # 0xf240
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
callq 0x2250
incq %r15
cmpq $0xc, %r15
jne 0x3801
movq 0xba1b(%rip), %rax      # 0xf240
movq (%rax,%r14,8), %rdi
callq 0x2250
movq 0xba13(%rip), %rdi      # 0xf248
movq %rbx, (%rdi,%r14,8)
movq 0xba10(%rip), %rax      # 0xf250
movq %rbx, (%rax,%r14,8)
incq %r14
cmpq $0x10, %r14
jne 0x37fe
callq 0x2250
movq 0xb9f7(%rip), %rdi      # 0xf250
callq 0x2250
movq 0xb9db(%rip), %rdi      # 0xf240
callq 0x2250
movq $0x0, 0xb9cb(%rip) # 0xf240
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79f0(%rip), %rdi      # 0xb284
leaq 0x77fd(%rip), %rsi      # 0xb098
movq %rsp, %rdx
callq 0x807d
cmpq $0x0, 0xb98d(%rip)      # 0xf238
movzbl %bl, %ebx
jle 0x38bf
movq %rsp, %rdi
movl %ebx, %esi
callq 0x3936
callq 0x3731
leaq 0x79c8(%rip), %rdi      # 0xb28e
leaq 0x77cb(%rip), %rsi      # 0xb098
movq %rsp, %r14
movq %r14, %rdx
callq 0x807d
leaq 0x79e1(%rip), %r13      # 0xb2c0
xorl %r15d, %r15d
leaq 0x70(%rsp), %r12
movsd (%r13), %xmm0
movq %r12, %rdi
movq %r14, %rsi
callq 0x3a93
movq 0xb951(%rip), %rax      # 0xf250
cmpq $0x0, (%rax,%r15,8)
jle 0x3913
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x3b24
incq %r15
addq $0x8, %r13
cmpq $0x10, %r15
jne 0x38e7
callq 0x37f4
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2380
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2040
cmpq $0x0, 0xb8c7(%rip)      # 0xf238
jle 0x39f2
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0x7917(%rip), %r15      # 0xb299
leaq 0x78b0(%rip), %r12      # 0xb239
movq 0xb898(%rip), %rax      # 0xf228
xorl %ebp, %ebp
movq (%rax,%rbp,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
callq 0x2350
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
incq %rbp
movq 0xb86a(%rip), %rax      # 0xf228
cmpq $0x7, %rbp
jne 0x3992
movq 0x38(%rax), %rax
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
callq 0x2350
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
incq %r13
cmpq 0xb848(%rip), %r13      # 0xf238
jl 0x3989
testb %bl, %bl
je 0x3a22
leaq 0x789e(%rip), %rsi      # 0xb29b
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x2210
leaq 0x7826(%rip), %rsi      # 0xb239
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x2210
leaq 0x8(%rsp), %rdi
callq 0x2120
leaq 0x8(%rsp), %rdi
callq 0x22c0
movq 0xb56b(%rip), %rax      # 0xefa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2190
leaq 0x100(%rsp), %rdi
callq 0x20a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a7e
jmp 0x3a7e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2380
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2040
movq 0xb6ed(%rip), %rax      # 0xf250
cmpq $0x0, (%rax,%r14,8)
jle 0x3bf6
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
leaq 0x771d(%rip), %r12      # 0xb299
leaq 0x76b6(%rip), %r13      # 0xb239
movq 0xb6b6(%rip), %rax      # 0xf240
movq (%rax,%r14,8), %rax
xorl %ebx, %ebx
movq (%rax,%rbx,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r15, %rdi
callq 0x2350
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
incq %rbx
movq 0xb685(%rip), %rax      # 0xf240
movq (%rax,%r14,8), %rax
cmpq $0xb, %rbx
jne 0x3b90
movq 0x58(%rax), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r15, %rdi
callq 0x2350
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2210
incq %rbp
movq 0xb660(%rip), %rax      # 0xf250
cmpq (%rax,%r14,8), %rbp
jl 0x3b83
cmpb $0x0, 0x4(%rsp)
je 0x3c29
leaq 0x7697(%rip), %rsi      # 0xb29b
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x2210
leaq 0x761f(%rip), %rsi      # 0xb239
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x2210
leaq 0x8(%rsp), %rdi
callq 0x2120
leaq 0x8(%rsp), %rdi
callq 0x22c0
movq 0xb364(%rip), %rax      # 0xefa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2190
leaq 0x100(%rsp), %rdi
callq 0x20a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c85
jmp 0x3c85
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O3/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 0xb5a7(%rip), %rax      # 0xf248
movq 0xb588(%rip), %rcx      # 0xf230
shlq $0x3, %rcx
movq %rcx, %xmm1
xorl %ecx, %ecx
movdqa 0x7595(%rip), %xmm0     # 0xb250
movdqu (%rax,%rcx,8), %xmm2
movdqa %xmm2, %xmm3
pmuludq %xmm0, %xmm3
paddq %xmm1, %xmm3
psrlq $0x20, %xmm2
pmuludq %xmm0, %xmm2
psllq $0x20, %xmm2
movdqa %xmm2, %xmm1
paddq %xmm3, %xmm1
addq $0x2, %rcx
cmpq $0x10, %rcx
jne 0x3cbb
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
paddq %xmm1, %xmm0
movq %xmm0, %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
setge %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp            # imm = 0x398
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x2380
leaq 0x7596(%rip), %rax      # 0xb2c0
movsd (%rax,%r14,8), %xmm0
leaq 0x7568(%rip), %rsi      # 0xb29f
leaq 0x2d0(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x2060
leaq 0x7348(%rip), %rsi      # 0xb098
leaq 0x200(%rsp), %rdx
movq %r14, %rdi
callq 0x807d
movq %rsp, %rdi
leaq 0x200(%rsp), %rsi
movl $0x1, %edx
callq 0x2040
movq $-0x40000, %rbp         # imm = 0xFFFC0000
movq %rsp, %r14
leaq 0x7513(%rip), %r15      # 0xb299
leaq 0x74ac(%rip), %r12      # 0xb239
movsd 0xc0000(%rbx,%rbp), %xmm0
movq %r14, %rdi
callq 0x2350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movsd 0x100000(%rbx,%rbp), %xmm0
movq %r13, %rdi
callq 0x2350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movsd 0x140000(%rbx,%rbp), %xmm0
movq %r13, %rdi
callq 0x2350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movsd 0x40000(%rbx,%rbp), %xmm0
movq %r13, %rdi
callq 0x2350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movsd 0x80000(%rbx,%rbp), %xmm0
movq %r13, %rdi
callq 0x2350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movsd 0x140000(%rbx), %xmm0
movq %r13, %rdi
callq 0x2350
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
addq $0x8, %rbp
jne 0x3d8d
movq %rsp, %rdi
callq 0x2120
movq %rsp, %rdi
callq 0x22c0
movq 0xb126(%rip), %rax      # 0xefa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2190
leaq 0xf8(%rsp), %rdi
callq 0x20a0
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ec0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O3/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 0xb34e(%rip), %rax      # 0xf228
movq (%rax), %rcx
movq 0xb354(%rip), %rdx      # 0xf238
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, 0xb306(%rip)      # 0xf238
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
xorl %ebx, %ebx
movq %rbx, 0xb24a(%rip)      # 0xf230
movq %rbx, 0xb24b(%rip)      # 0xf238
movl $0x10, %edi
movl $0x8, %esi
callq 0x2110
movq %rax, 0xb245(%rip)      # 0xf248
movl $0x10, %edi
movl $0x8, %esi
callq 0x2110
movq %rax, 0xb237(%rip)      # 0xf250
movl $0x8, %edi
movl $0x8, %esi
callq 0x2110
movq %rax, 0xb1f9(%rip)      # 0xf228
movl $0x10, %edi
movl $0x8, %esi
callq 0x2110
movq %rax, 0xb1fb(%rip)      # 0xf240
movl $0xc, %edi
movl $0x8, %esi
callq 0x2110
movq 0xb1e5(%rip), %rcx      # 0xf240
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq $0x10, %rbx
jne 0x4045
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x727c(%rip), %xmm1     # 0xb358
callq 0x2390
movsd %xmm0, 0x8(%rsp)
testq %rbx, %rbx
jle 0x4129
xorl %r13d, %r13d
movsd (%r12,%r13,8), %xmm0
movsd 0x725b(%rip), %xmm1     # 0xb358
callq 0x2390
addsd 0x8(%rsp), %xmm0
movsd 0x7250(%rip), %xmm1     # 0xb360
callq 0x2390
mulsd (%r15,%r13,8), %xmm0
movsd %xmm0, (%r14,%r13,8)
incq %r13
cmpq %r13, %rbx
jne 0x40ef
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/EvolveField.c
// Function: FindCMFTimeIndex(double)
long FindCMFTimeIndex(double tcurrent)
{
	int j;
	long res;
	const double CMFTimes[CMFTIMENUM] = CMFTIMEVALUES; //times at which CMF and IMF are saved. 
	//Find nearest CMF observation time
	res=-1;//init
	if(tcurrent<=CMFTimes[0]){
		res=0;
	}
	else{
		for ( j = 1; j < CMFTIMENUM; j++ ){
			if(CMFTimes[j-1]<tcurrent && CMFTimes[j]>=tcurrent){ //between these values
				res=j;
			}
		}
	}

	return res;
}

// Assembly:
movsd 0x3bba(%rip), %xmm1     # 0xb418
ucomisd %xmm0, %xmm1
jae 0x7897
movq $-0x1, %rax
movl $0x1, %ecx
leaq 0x3d79(%rip), %rdx      # 0xb5f0
ucomisd -0x8(%rdx,%rcx,8), %xmm0
jbe 0x788d
movsd (%rdx,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jb 0x788d
movq %rcx, %rax
incq %rcx
cmpq $0x10, %rcx
jne 0x7877
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: IncreaseInputStorage()
void IncreaseInputStorage(){
	long i;
	InputStorage=(struct inputstruct_s*) realloc(InputStorage, (NInputAllocated+StructIncreaseUnit)* sizeof(struct inputstruct_s));
	if(InputStorage==NULL){ //unsuccessful allocation
		cout<<"Memory allocation failure! Exiting!";
		exit(EXIT_FAILURE);
	}
	IsUsed=(bool*) realloc(IsUsed, (NInputAllocated+StructIncreaseUnit)*sizeof(bool));
	for(i=0;i<StructIncreaseUnit;i++){
		IsUsed[NInputAllocated+i]=false;
	}
    InputPriority=(double*) realloc(InputPriority, (NInputAllocated+StructIncreaseUnit)*sizeof(double));
	NInputAllocated+=StructIncreaseUnit; //note the number of elements
	cout<<"Input storage expanded to "<<NInputAllocated<<"\n";
}

// Assembly:
pushq %rbx
movq 0x79dc(%rip), %rdi      # 0xf280
imulq $0x80050, 0x79e9(%rip), %rsi # imm = 0x80050
addq $0x1900fa0, %rsi        # imm = 0x1900FA0
callq 0x2360
movq %rax, 0x79be(%rip)      # 0xf280
testq %rax, %rax
je 0x796a
movq 0x79be(%rip), %rdi      # 0xf290
movq 0x79bf(%rip), %rsi      # 0xf298
addq $0x32, %rsi
callq 0x2360
movq %rax, 0x79a7(%rip)      # 0xf290
movq 0x79a8(%rip), %rcx      # 0xf298
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax,%rcx)
movups %xmm0, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movw $0x0, 0x30(%rax,%rcx)
movq 0x7979(%rip), %rdi      # 0xf288
leaq 0x190(,%rcx,8), %rsi
callq 0x2360
movq %rax, 0x7965(%rip)      # 0xf288
addq $0x32, 0x796d(%rip)     # 0xf298
movq 0x7696(%rip), %rbx      # 0xefc8
leaq 0x3d37(%rip), %rsi      # 0xb670
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2210
movq 0x794b(%rip), %rsi      # 0xf298
movq %rbx, %rdi
callq 0x21c0
leaq 0x38dd(%rip), %rsi      # 0xb239
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
jmp 0x2210
movq 0x7657(%rip), %rdi      # 0xefc8
leaq 0x38e8(%rip), %rsi      # 0xb260
callq 0x21e0
movl $0x1, %edi
callq 0x2260