LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: set_remote(item*, int)
void set_remote(item* dev,int w)
{
	if(dev->player_has && dev->configuration != ON_REMOTE)
	{
		set_unconfigured(dev);
		inv_remove(dev);
		dev_inv[dev->device_type][ON_REMOTE].push_back(dev);
	}
	//if(dev->configuration == ON_TIMER)
	//{
	//	dev->time_remaining = -1;
	//	kill_velement(timer_devices,dev);
	//}
	dev->configuration = ON_REMOTE;
	dev->wavelength = w;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x98(%rdi)
jne 0x13df2
cmpl $0x2, 0x8c(%rdi)
je 0x13df2
callq 0x13c16
movq 0x8(%rsp), %rsi
movslq 0x70(%rsi), %rax
movq 0xb26b4(%rip), %rcx     # 0xc6450
leaq (%rax,%rax,2), %rax
movslq 0x8c(%rsi), %rdx
leaq (%rdx,%rdx,2), %rdi
shlq $0x3, %rdi
addq (%rcx,%rax,8), %rdi
callq 0x16158
movq 0x8(%rsp), %rax
movslq 0x70(%rax), %rcx
movq 0xb2688(%rip), %rdx     # 0xc6450
leaq (%rcx,%rcx,2), %rcx
movq (%rdx,%rcx,8), %rdi
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0x13de4
movq %rax, (%rsi)
addq $0x8, 0x38(%rdi)
jmp 0x13df2
addq $0x30, %rdi
leaq 0x8(%rsp), %rdx
callq 0x16d04
movq 0x8(%rsp), %rax
movl $0x2, 0x8c(%rax)
movl %ebx, 0x74(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: autotarget()
int autotarget()
{
	int tab_ind = -1;
	if(current_target == NULL || current_target == p_ptr)
	{
		if(visible_actors.size() == 0)
		{
			current_target = p_ptr;
		}
		else
		{
			current_target = visible_actors[0];
			tab_ind = 0;
		}
	}
	if(!symmetrical_los(current_target->x,current_target->y,p_ptr->x,p_ptr->y,is_opaque))
	{
		if(visible_actors.size() == 0)
		{
			current_target = p_ptr;
		}
		else
		{
			current_target = visible_actors[0];
			tab_ind = 0;
		}
	}
	return tab_ind;
}

// Assembly:
pushq %rbx
movq 0x5a0f6(%rip), %rcx     # 0x6e4d0
testq %rcx, %rcx
sete %dl
movq 0x5a109(%rip), %rax     # 0x6e4f0
cmpq %rax, %rcx
sete %cl
orb %dl, %cl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x1, %cl
jne 0x1441a
movq 0x5a0d8(%rip), %rcx     # 0x6e4d8
cmpq %rcx, 0x5a0d9(%rip)     # 0x6e4e0
je 0x14410
movq (%rcx), %rcx
xorl %ebx, %ebx
jmp 0x14413
movq %rax, %rcx
movq %rcx, 0x5a0b6(%rip)     # 0x6e4d0
movq 0x5a0af(%rip), %rcx     # 0x6e4d0
movl 0x20(%rcx), %edi
movl 0x24(%rcx), %esi
movl 0x20(%rax), %edx
movl 0x24(%rax), %ecx
leaq -0x6b0b(%rip), %r8      # 0xd929
callq 0xfc80
testb %al, %al
jne 0x14465
movq 0x5a094(%rip), %rax     # 0x6e4d8
xorl %ecx, %ecx
cmpq %rax, 0x5a093(%rip)     # 0x6e4e0
leaq 0x5a09c(%rip), %rdx     # 0x6e4f0
cmovneq %rax, %rdx
cmovnel %ecx, %ebx
movq (%rdx), %rax
movq %rax, 0x5a06b(%rip)     # 0x6e4d0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: diffuse_scent_human()
void diffuse_scent_human()
{
	for (int x=0;x<MAP_SIZE;x++)
	{
		for(int y=0; y < MAP_SIZE;y++)
		{
			if(!is_wall(x,y))
			{
				spare_scent_map[x][y] = map_human_scent[x][y];
				int count = 1;
				for(int d=0;d<8;d++)
				{
					std::pair<int,int> dir = directions[d];
					int xx = x+dir.first; int yy = y+dir.second;
					if(!undiffusable(xx,yy))
					{
						spare_scent_map[x][y] += map_human_scent[xx][yy];
						count++;
					}
				}
				map_human_scent[x][y] = 0.9999f*spare_scent_map[x][y]/count;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %eax, %eax
leaq 0xbf44(%rip), %rcx      # 0x21350
leaq 0x21ecd(%rip), %rdx     # 0x372e0
leaq 0x30d6(%rip), %rdi      # 0x184f0
movss 0x2c7a(%rip), %xmm0     # 0x1809c
imulq $0x258, %rax, %r8       # imm = 0x258
leaq (%rcx,%r8), %r9
leaq (%rdx,%r8), %rsi
movq %rsi, -0x10(%rsp)
leaq 0x37e33(%rip), %rsi     # 0x4d270
addq %rsi, %r8
movq %r8, -0x8(%rsp)
movq %rax, -0x18(%rsp)
movslq %eax, %r11
xorl %ebx, %ebx
cmpl $0x4, (%r9,%rbx,4)
je 0x154e9
movq -0x10(%rsp), %rax
leaq (%rax,%rbx,4), %r14
movss (%r14), %xmm1
movq -0x8(%rsp), %rax
leaq (%rax,%rbx,4), %r15
movss %xmm1, (%r15)
movl $0x1, %ebp
movslq %ebx, %r12
xorl %r13d, %r13d
movslq (%rdi,%r13,8), %rax
addq %r11, %rax
movslq 0x4(%rdi,%r13,8), %rsi
addq %r12, %rsi
imulq $0x258, %rax, %rax      # imm = 0x258
leaq (%rcx,%rax), %r10
movl (%r10,%rsi,4), %r10d
leal -0x6(%r10), %r8d
cmpl $0x7, %r8d
jae 0x154b4
incq %r13
cmpq $0x8, %r13
jne 0x15481
jmp 0x154d0
cmpl $0x4, %r10d
je 0x154a9
addq %rdx, %rax
movss (%rax,%rsi,4), %xmm1
addss (%r15), %xmm1
movss %xmm1, (%r15)
incl %ebp
jmp 0x154a9
xorps %xmm1, %xmm1
cvtsi2ss %ebp, %xmm1
movss (%r15), %xmm2
mulss %xmm0, %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%r14)
incq %rbx
cmpq $0x96, %rbx
jne 0x1544f
movq -0x18(%rsp), %rax
incq %rax
cmpq $0x96, %rax
jne 0x15422
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: main
int main()
{
	srand((unsigned int)time(NULL));
	init();
#ifdef KILL_ESCAPE
	ESCDELAY=0;
#endif
	int end_game = 0;
	for(turn_count = 0;!end_game; turn_count++)
	{
		end_game = play_turn();
	}
	endwin();
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x5220
movl %eax, %edi
callq 0x5240
callq 0xe35b
movq 0xb27b(%rip), %rax      # 0x20fc8
movl $0x0, (%rax)
movl %ebx, 0xb5cb(%rip)      # 0x21324
callq 0x15518
movl 0xb5c0(%rip), %ebx      # 0x21324
incl %ebx
jmp 0x15d53
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/fec_test.cpp
// Function: main
int main()
{

    printf("starting");

    // the quantity of data columns
    const int NUM = 6;
    int *err = new int[NUM];

//    fec *fecCode = new rscode(10,3,1024);
//    fec *fecCode = new star(6,257,1024);
    fec *fecCode = new rdp();


    fecCode->setData();
    fecCode->encoding();
    fecCode->outputData();

    // 1 means fault data
    for(int i=0; i<NUM; i++)
    {
        err[i] = 0;
    }

    err[0]=1;
//   err[1]=1;
//   err[2]=1;
    err[3]=1;

    fecCode->setErrData(err);
    fecCode->decoding();
    fecCode->outputOrigin();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1dca(%rip), %rdi      # 0x3004
xorl %eax, %eax
callq 0x1040
movl $0x18, %edi
callq 0x1030
movq %rax, %r14
movl $0x40, %edi
callq 0x1090
movq %rax, %rbx
movq %rax, %rdi
callq 0x12be
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x1, %eax
movl %eax, (%r14)
movl %eax, 0xc(%r14)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::rdp()
rdp()
    {
        disks = 4;
        pnumRdp = 257;
        stripe_unit_size = DATA_LENGTH;
        w = pnumRdp - 1;
        allDisks = disks + TOLERENCE;

        idata=(char **)malloc(sizeof(char *)*disks);
        for(int i=0; i<disks; i++)
        {
            idata[i]=(char *) malloc(sizeof(char)*stripe_unit_size);
            memset(idata[i],0,stripe_unit_size);
        }

        odata=(char **)malloc(sizeof(char *)*TOLERENCE);
        for(int i=0; i<TOLERENCE; i++)
        {
            odata[i]=(char *) malloc(sizeof(char)*stripe_unit_size);
            memset(odata[i],0,stripe_unit_size);
        }

        data=(char **)malloc(sizeof(char *)*allDisks);
        for(int i=0; i<allDisks; i++)
        {
            data[i]=(char *) malloc(sizeof(char)*stripe_unit_size);
            memset(data[i],0,stripe_unit_size);
        }

        inthis = (int *)malloc(sizeof(int *)*allDisks);

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3a8e(%rip), %rax      # 0x4d60
movq %rax, (%rdi)
movabsq $0x40000000004, %rax    # imm = 0x40000000004
movq %rax, 0x8(%rdi)
movl $0x101, 0x10(%rdi)      # imm = 0x101
movabsq $0x600000100, %rax      # imm = 0x600000100
movq %rax, 0x14(%rdi)
movl $0x20, %edi
callq 0x10a0
movq %rax, 0x20(%rbx)
cmpl $0x0, 0x8(%rbx)
jle 0x1341
xorl %r15d, %r15d
movslq 0xc(%rbx), %r14
movq %r14, %rdi
callq 0x10a0
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1050
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x130f
movl $0x10, %edi
callq 0x10a0
movq %rax, 0x28(%rbx)
xorl %r15d, %r15d
movslq 0xc(%rbx), %r14
movq %r14, %rdi
callq 0x10a0
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1050
incq %r15
cmpq $0x1, %r15
je 0x1352
movslq 0x18(%rbx), %r14
leaq (,%r14,8), %rdi
callq 0x10a0
movq %rax, 0x30(%rbx)
testq %r14, %r14
jle 0x13d0
xorl %r15d, %r15d
movslq 0xc(%rbx), %r14
movq %r14, %rdi
callq 0x10a0
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1050
incq %r15
movslq 0x18(%rbx), %r14
cmpq %r14, %r15
jl 0x139e
movslq %r14d, %rdi
shlq $0x3, %rdi
callq 0x10a0
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::setData()
void setData()
    {
        for(int i = 0; i < disks; i++)
        {
            for(int j = 0; j < stripe_unit_size; j++)
            {
                idata[i][j]=(char) ('a' + i);
            }
        }

        memcpy(odata[0], idata[0], stripe_unit_size* sizeof(char));
        memcpy(odata[1], idata[0], stripe_unit_size* sizeof(char));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x1457
xorl %eax, %eax
cmpl $0x0, 0xc(%rbx)
jle 0x144b
leal 0x61(%rax), %ecx
xorl %edx, %edx
movq 0x20(%rbx), %rsi
movq (%rsi,%rax,8), %rsi
movb %cl, (%rsi,%rdx)
incq %rdx
movslq 0xc(%rbx), %rsi
cmpq %rsi, %rdx
jl 0x1434
incq %rax
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jl 0x1429
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
movslq 0xc(%rbx), %rdx
callq 0x1070
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rcx), %rdi
movq (%rax), %rsi
movslq 0xc(%rbx), %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::outputOrigin()
void outputOrigin()
    {

        printf("After decoding:");
        for(int i=0; i < disks; i++)
        {
            printf("idata:%d:  ",i);
            printf(idata[i]);
            printf("\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18d5(%rip), %rdi      # 0x305d
xorl %eax, %eax
callq 0x1040
cmpl $0x0, 0x8(%rbx)
jle 0x17d1
leaq 0x189f(%rip), %r14      # 0x303b
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1040
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %eax, %eax
callq 0x1040
movl $0xa, %edi
callq 0x10b0
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x179f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::outputData()
void outputData()
    {

        printf("The res:");
        printf("odata:0:  ");
        printf(odata[0]);
        printf("\n");
        printf("odata:1:  ");
        printf(odata[1]);
        printf("\n");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1881(%rip), %rdi      # 0x306d
xorl %eax, %eax
callq 0x1040
leaq 0x184d(%rip), %rdi      # 0x3047
xorl %eax, %eax
callq 0x1040
movq 0x28(%rbx), %rax
movq (%rax), %rdi
xorl %eax, %eax
callq 0x1040
movl $0xa, %edi
callq 0x10b0
leaq 0x1832(%rip), %rdi      # 0x3052
xorl %eax, %eax
callq 0x1040
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
callq 0x1040
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::outputRes()
void outputRes()
    {

        for(int i=0; i < disks; i++)
        {
            printf("idata:%d:  ",i);
            printf(idata[i]);
            printf("\n");
        }
        printf("odata:0:  ");
        printf(odata[0]);
        printf("\n");
        printf("odata:1:  ");
        printf(odata[1]);
        printf("\n");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x192f
leaq 0x1741(%rip), %r14      # 0x303b
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1040
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %eax, %eax
callq 0x1040
movl $0xa, %edi
callq 0x10b0
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x18fd
leaq 0x1711(%rip), %rdi      # 0x3047
xorl %eax, %eax
callq 0x1040
movq 0x28(%rbx), %rax
movq (%rax), %rdi
xorl %eax, %eax
callq 0x1040
movl $0xa, %edi
callq 0x10b0
leaq 0x16f6(%rip), %rdi      # 0x3052
xorl %eax, %eax
callq 0x1040
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
callq 0x1040
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::rdp_encoding()
void rdp_encoding()
    {

        int off = 0;
        int d = 0;
        int p = 0;
        int diag = 0;
        int packet_size = stripe_unit_size /w;

        for (d = 1; d < disks; d++)
        {

            diag = d;

            for (p = 0; p < w; p++)
            {
                if (diag <= w - 1)
                {
                    for (off = 0; off < packet_size; off++)
                    {

                        odata[0][p * packet_size + off]^= idata[d][p * packet_size + off];
                        odata[1][diag * packet_size + off]^= idata[d][p * packet_size + off];
                    }
                    diag++;

                }
                else
                {

                    for (off = 0; off < packet_size; off++)
                    {

                        odata[0][p * packet_size + off]^= idata[d][p * packet_size + off];
                    }
                    diag = 0;

                }

            }
        }
        for (p = 1; p < w; p++)
        {
            for (off = 0; off < packet_size; off++)
            {
                odata[1][(p - 1) * packet_size + off]^= odata[0][p * packet_size + off];

            }
        }


    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
cltd
idivl 0x14(%rdi)
cmpl $0x2, %ecx
jl 0x1a6d
movslq %eax, %rcx
movl %eax, %edx
movl $0x1, %esi
movl 0x14(%rdi), %r11d
testl %r11d, %r11d
jle 0x1a5d
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %esi, %r10d
cmpl %r11d, %r10d
jge 0x1a1e
testl %eax, %eax
jle 0x1a19
movl %r10d, %r11d
imull %eax, %r11d
movslq %r11d, %r11
movq %rdx, %rbx
movq %r8, %r14
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
movq (%r15,%rsi,8), %r15
movb (%r15,%r14), %r15b
movq (%r12), %r12
xorb %r15b, (%r12,%r14)
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
movq (%r15,%rsi,8), %r15
movb (%r15,%r14), %r15b
movq 0x8(%r12), %r12
xorb %r15b, (%r12,%r11)
incq %r11
incq %r14
decq %rbx
jne 0x19dd
incl %r10d
jmp 0x1a4a
xorl %r10d, %r10d
testl %eax, %eax
jle 0x1a4a
movl %r8d, %r11d
movq %rdx, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
movq (%r14,%rsi,8), %r14
movb (%r14,%r11), %r14b
movq (%r15), %r15
xorb %r14b, (%r15,%r11)
incq %r11
decq %rbx
jne 0x1a2b
incq %r9
movslq 0x14(%rdi), %r11
addq %rcx, %r8
cmpq %r11, %r9
jl 0x19c4
incq %rsi
movslq 0x8(%rdi), %r8
cmpq %r8, %rsi
jl 0x19ae
cmpl $0x2, 0x14(%rdi)
jl 0x1ab7
movslq %eax, %rcx
movl %ecx, %edx
movl $0x1, %esi
xorl %r8d, %r8d
testl %eax, %eax
jle 0x1aa8
movq %rdx, %r9
movq %r8, %r10
movq 0x28(%rdi), %r11
movq (%r11), %rbx
addq %rcx, %rbx
movb (%r10,%rbx), %bl
movq 0x8(%r11), %r11
xorb %bl, (%r11,%r10)
incq %r10
decq %r9
jne 0x1a8a
incq %rsi
movslq 0x14(%rdi), %r9
addq %rcx, %r8
cmpq %r9, %rsi
jl 0x1a80
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::rdp_decoding_r(char**, int, int, int, int)
void rdp_decoding_r(char * g_data[], int disks, int stripe_unit_size, int w, int k)
    {
        int off = 0;
        int p = 0;
        int packet_size = stripe_unit_size / w;
        int i = 0;

        memcpy(g_data[k],g_data[0],stripe_unit_size*sizeof(char));
        for(i=2; i<(disks+2); i++)
        {
            if(i==k) continue;
            for (p = 0; p < w; p++)
            {
                for (off = 0; off < packet_size; off++)
                {
                    g_data[k][p * packet_size + off]^=g_data[i][p * packet_size + off];
                }
            }
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %edx, %r14d
movq %rsi, %r15
movl %ecx, %eax
cltd
movl %r8d, -0x2c(%rbp)
idivl %r8d
movl %eax, %r12d
movslq %r9d, %r13
movq (%rsi,%r13,8), %rdi
movq (%rsi), %rsi
movslq %ecx, %rdx
callq 0x1070
testl %r14d, %r14d
jle 0x1ea3
movl %r12d, %eax
movl %ebx, %ecx
addl $0x2, %r14d
movl -0x2c(%rbp), %edx
movl $0x2, %esi
cmpl $0x0, -0x2c(%rbp)
setle %dil
cmpq %rcx, %rsi
sete %r8b
orb %dil, %r8b
jne 0x1e9b
xorl %edi, %edi
xorl %r8d, %r8d
testl %r12d, %r12d
jle 0x1e90
movq %rax, %r9
movq %rdi, %r10
movq (%r15,%rsi,8), %r11
movb (%r11,%r10), %r11b
movq (%r15,%r13,8), %rbx
xorb %r11b, (%rbx,%r10)
incq %r10
decq %r9
jne 0x1e78
incq %r8
addq %rax, %rdi
cmpq %rdx, %r8
jne 0x1e6d
incq %rsi
cmpq %r14, %rsi
jne 0x1e54
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Autopilot.cpp
// Function: Autopilot::Autopilot()
Autopilot::Autopilot() :
MdlBase()
{
  //
  // Default initialization of input variables
  //
  frameTimeStep = 1.0/64.0;  // sec     Frame time step
  initFrameTime = 0.0;       // sec     Time of first frame update

  accLim = 300.0;            // m/sec^2 Acceleration limit
  tau = 0.2;                 // sec     Control system time constant
                             //         Autopilot, Aero, & CAS
  //
  // Register states for integration
  //
  RegisterState( x0, x0d );
  RegisterState( x1, x1d );
  RegisterState( x2, x2d );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xa084
leaq 0x1a2c6(%rip), %rax     # 0x1d890
movq %rax, (%rbx)
movabsq $0x3f90000000000000, %rax # imm = 0x3F90000000000000
movq %rax, 0x8(%rbx)
movq $0x0, 0xf8(%rbx)
movabsq $0x4072c00000000000, %rax # imm = 0x4072C00000000000
movq %rax, 0x100(%rbx)
movabsq $0x3fc999999999999a, %rax # imm = 0x3FC999999999999A
movq %rax, 0x108(%rbx)
leaq 0x138(%rbx), %rsi
leaq 0x140(%rbx), %rdx
movq %rbx, %rdi
callq 0xa376
leaq 0x148(%rbx), %rsi
leaq 0x150(%rbx), %rdx
movq %rbx, %rdi
callq 0xa376
leaq 0x158(%rbx), %rsi
leaq 0x160(%rbx), %rdx
movq %rbx, %rdi
callq 0xa376
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1e4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Autopilot.cpp
// Function: Autopilot::Initialize()
void Autopilot::Initialize()
{
  ResetAll();

  simTime = GetSimTime();

  launchTime = pMsl->launchTime;

  nextFrameTime = launchTime;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%rdi)
movups %xmm0, 0x140(%rdi)
movups %xmm0, 0x130(%rdi)
movups %xmm0, 0x120(%rdi)
movups %xmm0, 0x110(%rdi)
movq $0x0, 0x160(%rdi)
movq 0x38(%rdi), %rax
movq 0x178(%rdi), %rcx
movsd (%rax), %xmm0
movsd %xmm0, 0x130(%rdi)
movsd 0x108(%rcx), %xmm0
movsd %xmm0, 0x128(%rdi)
movsd %xmm0, 0x30(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Autopilot.cpp
// Function: Autopilot::UpdateDerivatives()
void Autopilot::UpdateDerivatives()
{
  double tauPrime;

  simTime = GetSimTime();

  //
  // Third order transfer function.  Ref Zarchan 3rd ed. page 98.
  // Three identical single order systems in series.
  //
  tauPrime = tau / 3.0 / 1.09;

  x0d = -1.0/tauPrime * x0 + 1.0/tauPrime * x1;

  x1d = -1.0/tauPrime * x1 + 1.0/tauPrime * x2;

  x2d = -1.0/tauPrime * x2 + 1.0/tauPrime * aCmdYbLim;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x130(%rdi)
movsd 0x108(%rdi), %xmm0
divsd 0x12852(%rip), %xmm0    # 0x16020
divsd 0x12852(%rip), %xmm0    # 0x16028
movsd 0x12852(%rip), %xmm1    # 0x16030
divsd %xmm0, %xmm1
movsd 0x1284e(%rip), %xmm2    # 0x16038
divsd %xmm0, %xmm2
movsd 0x148(%rdi), %xmm0
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
movsd 0x138(%rdi), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, 0x140(%rdi)
movsd 0x158(%rdi), %xmm3
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm1, %xmm0
addsd %xmm4, %xmm0
movsd %xmm0, 0x150(%rdi)
mulsd 0x110(%rdi), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x160(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Autopilot.cpp
// Function: Autopilot::Output(bool, _IO_FILE*)
void Autopilot::Output( bool printHeader,
                        FILE *pOutFile )
{
  simTime = GetSimTime();

  if ( printHeader )
  {
    fprintf( pOutFile, "%20s", "ap.accLim" );
    fprintf( pOutFile, "%20s", "ap.aCmdYbLim");
    fprintf( pOutFile, "%20s", "ap.ayb" );
    fprintf( pOutFile, "%20s", "ap.tau" );
  }
  else
  {
    fprintf(pOutFile, "%20.6e", accLim );
    fprintf(pOutFile, "%20.6e", aCmdYbLim );
    fprintf(pOutFile, "%20.6e", ayb );
    fprintf(pOutFile, "%20.6e", tau );

  } // end if ( printHeader ) else
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x130(%rdi)
testl %esi, %esi
je 0x38e8
leaq 0x127b2(%rip), %r14     # 0x16040
leaq 0x127b0(%rip), %rdx     # 0x16045
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x127a6(%rip), %rdx     # 0x1604f
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x1279f(%rip), %rdx     # 0x1605c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x12792(%rip), %rdx     # 0x16063
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
movq %rdi, %r14
movsd 0x100(%rdi), %xmm0
leaq 0x12770(%rip), %r15     # 0x1606a
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x110(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x118(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x108(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcRadar.cpp
// Function: FcRadar::FcRadar()
FcRadar::FcRadar()
{
  //
  // Input parameter defaults
  //
  frameTimeStep = 1.0/64.0;
  initFrameTime = 0.0;

  initPxf = -10e3;;
  initPyf = 0.0;

  rinAng = 500.0e-6; // rad   Range independent angle noise
  rinRng = 3.0;      // m     Range independent range noise
  rinRdot = 3.0;     // m/sec Range independent range rate noise

  //
  // Other variable initialization
  //

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa084
leaq 0x19f8f(%rip), %rax     # 0x1d8f8
movq %rax, (%rbx)
movabsq $0x3f90000000000000, %rax # imm = 0x3F90000000000000
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0xf8(%rbx)
movabsq $-0x3f3c780000000000, %rcx # imm = 0xC0C3880000000000
movq %rcx, 0x100(%rbx)
movq %rax, 0x108(%rbx)
movabsq $0x3f40624dd2f1a9fc, %rax # imm = 0x3F40624DD2F1A9FC
movq %rax, 0x110(%rbx)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x120(%rbx)
movq %rax, 0x118(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcRadar.cpp
// Function: FcRadar::Initialize()
void FcRadar::Initialize()
{
  ResetAll();

  simTime = GetSimTime();

  nextFrameTime = initFrameTime;

  pxf = initPxf;
  pyf = initPyf;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x138(%rdi)
movups %xmm0, 0x128(%rdi)
xorl %eax, %eax
movq %rax, 0x148(%rdi)
movups %xmm0, 0x158(%rdi)
movups %xmm0, 0x168(%rdi)
movq %rax, 0x178(%rdi)
movups %xmm0, 0x1a8(%rdi)
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0xf8(%rdi), %xmm0
movsd %xmm0, 0x30(%rdi)
movups 0x100(%rdi), %xmm0
movups %xmm0, 0x140(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcRadar.cpp
// Function: FcRadar::FrameUpdate()
void FcRadar::FrameUpdate()
{
  simTime = GetSimTime();

  truPosX = pTgt->pxf;
  truPosY = pTgt->pyf;

  truVelX = pTgt->vxf - vxf;
  truVelY = pTgt->vyf - vyf;

  relPosX = truPosX - pxf;
  relPosY = truPosY - pyf;

  relVelX = truVelX;
  relVelY = truVelY;

  truAng = atan2( relPosY, relPosX );

  truRng = sqrt( SQ(relPosX) + SQ(relPosY) );

  truRdot = ( relVelX * relPosX + relVelY * relPosY ) / truRng;
  
  measAng = gaussian( truAng, rinAng, &pExec->seed );
              
  measRdot = gaussian( truRdot, rinRdot, &pExec->seed );

  measRng = gaussian( truRng, rinRng, &pExec->seed );

  timeStamp = simTime;
              
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x1d0(%rdi), %rcx
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0x160(%rcx), %xmm1
movsd %xmm1, 0x1a8(%rdi)
movsd 0x168(%rcx), %xmm0
movsd %xmm0, 0x1b0(%rdi)
movsd 0x180(%rcx), %xmm2
subsd 0x170(%rdi), %xmm2
movsd %xmm2, 0x1b8(%rdi)
movsd 0x190(%rcx), %xmm3
subsd 0x178(%rdi), %xmm3
movsd %xmm3, 0x1c0(%rdi)
subsd 0x140(%rdi), %xmm1
movsd %xmm1, 0x180(%rdi)
subsd 0x148(%rdi), %xmm0
movsd %xmm0, 0x188(%rdi)
movsd %xmm2, 0x190(%rdi)
movsd %xmm3, 0x198(%rdi)
callq 0x3060
movsd %xmm0, 0x158(%rbx)
movsd 0x180(%rbx), %xmm1
movsd 0x188(%rbx), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3b76
sqrtsd %xmm0, %xmm0
jmp 0x3b7b
callq 0x3120
movsd %xmm0, 0x168(%rbx)
movsd 0x190(%rbx), %xmm1
movsd 0x198(%rbx), %xmm2
mulsd 0x188(%rbx), %xmm2
mulsd 0x180(%rbx), %xmm1
addsd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x160(%rbx)
movsd 0x110(%rbx), %xmm1
movsd 0x158(%rbx), %xmm0
movl $0x200, %r14d           # imm = 0x200
movq 0x1c8(%rbx), %rdi
addq %r14, %rdi
callq 0x98f4
movsd %xmm0, 0x128(%rbx)
movsd 0x118(%rbx), %xmm1
movsd 0x160(%rbx), %xmm0
movq 0x1c8(%rbx), %rdi
addq %r14, %rdi
callq 0x98f4
movsd %xmm0, 0x130(%rbx)
movsd 0x120(%rbx), %xmm1
movsd 0x168(%rbx), %xmm0
addq 0x1c8(%rbx), %r14
movq %r14, %rdi
callq 0x98f4
movsd %xmm0, 0x138(%rbx)
movsd 0x1a0(%rbx), %xmm0
movsd %xmm0, 0x150(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::Initialize()
void FcTseO::Initialize()
{
  int idx;

  ResetAll();

  simTime = GetSimTime();

  nextFrameTime = initFrameTime;

  HH = 0.0;
  HH[0][0] = 1.0;

  for ( idx = 0; idx < 3; ++idx )
  {
    eye[idx][idx] = 1.0;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x4370
movq 0x38(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x240(%rbx)
movsd 0xf8(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
leaq 0x170(%rbx), %r15
leaq -0x30(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %r15, %rsi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x13b48
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
movq %r15, (%rax)
addq $0x158, %rbx            # imm = 0x158
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13b48
movq %r15, (%rax,%r14,8)
incq %r14
cmpq $0x3, %r14
jne 0x434c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::ResetAll()
void FcTseO::ResetAll()
{
  estPosY     = 0.0;
  estPosYdot  = 0.0;
  estOmega    = 0.0;
  estOmega2   = 0.0;
  eye         = 0.0;
  HH          = 0.0;
  HT          = 0.0;
  initialized = false;
  innovation  = 0.0;
  KK          = 0.0;
  measPosY    = 0.0;
  phi         = 0.0;
  PP          = 0.0;
  residual    = 0.0;
  rinPosY     = 0.0;
  RR          = 0.0;
  QQ          = 0.0;
  simTime     = 0.0;
  stateVec    = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x158(%rdi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rdi)
movups %xmm0, 0x138(%rdi)
leaq -0xf0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x170(%rbx), %rsi
leaq -0xd8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x188(%rbx), %rsi
leaq -0xc0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
movb $0x0, 0x1a0(%rbx)
leaq 0x1a8(%rbx), %rsi
leaq -0xa8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x1c0(%rbx), %rsi
leaq -0x90(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
xorl %r15d, %r15d
movq %r15, 0x1d8(%rbx)
leaq 0x1e0(%rbx), %rsi
leaq -0x78(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x1f8(%rbx), %rsi
leaq -0x60(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x228(%rbx), %rsi
movq %r15, 0x220(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x210(%rbx)
leaq -0x48(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
movq %r15, 0x240(%rbx)
addq $0x248, %rbx            # imm = 0x248
leaq -0x30(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::FrameUpdate()
void FcTseO::FrameUpdate()
{
  double angSig;
  double measAng;
  double measRng;
  double rngSig;

  simTime = GetSimTime();

  measAng = pRdr->measAng;
  angSig = pRdr->rinAng; 

  measRng = pRdr->measRng;
  rngSig = pRdr->rinRng;

  measPosY = measRng * measAng;
  rinPosY = measRng * angSig + measAng * rngSig; 

  if ( !initialized )
  {
    initialized = true;

    stateVec(0) = initPosY;
    stateVec(1) = initVelY;
    stateVec(2) = initOmega;

    PP[0][0] = SQ( initPosYsigScale * rinPosY );
    PP[1][1] = SQ( initVelYsig );
    PP[2][2] = SQ( initWsig );
  }

  PropStates( frameTimeStep );

  UpdateStates( measPosY );

  estPosY = stateVec(0);
  estPosYdot = stateVec(1);
  estOmega2 = stateVec(2);
  estOmega = sqrt( estOmega2 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x240(%rdi)
movq 0x268(%rdi), %rax
movsd 0x128(%rax), %xmm0
movsd 0x138(%rax), %xmm1
movapd %xmm0, %xmm2
mulsd 0x120(%rax), %xmm0
mulsd %xmm1, %xmm2
mulsd 0x110(%rax), %xmm1
addsd %xmm0, %xmm1
movsd %xmm2, 0x1d8(%rdi)
movsd %xmm1, 0x218(%rdi)
cmpb $0x0, 0x1a0(%rdi)
jne 0x4651
movb $0x1, 0x1a0(%rbx)
movsd 0x108(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0x248(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x118(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x100(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x110(%rbx), %xmm0
mulsd 0x218(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0x1f8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x13b48
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x120(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13b48
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x128(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13b48
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x8(%rbx), %xmm0
movq %rbx, %rdi
callq 0x46e4
movsd 0x1d8(%rbx), %xmm0
movq %rbx, %rdi
callq 0x4b42
leaq 0x248(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, 0x138(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, 0x140(%rbx)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, 0x150(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x46cd
sqrtsd %xmm0, %xmm0
jmp 0x46d2
callq 0x3120
movsd %xmm0, 0x148(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::CalcStateDeriv(Matrix&)
Matrix FcTseO::CalcStateDeriv( Matrix &XX )
{
  Matrix deriv(3,1);
                             // posY = A*sin(w*t)

  deriv(0) = XX(1);          // d/dt( posY ) = velY = w*A*cos(w*t) 

  deriv(1) = -XX(2) * XX(0); // d/dt( velY ) = -w^2*posY = -w^2*A*sin(w*t)

  deriv(2) = 0.0;

  return( deriv );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movl $0x3, %esi
movl $0x1, %edx
callq 0x13504
movq %r14, %rdi
movl $0x1, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13aba
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13aba
movsd (%rax), %xmm0
movapd %xmm0, -0x20(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13aba
movapd -0x20(%rbp), %xmm0
xorpd 0x1067c(%rip), %xmm0    # 0x16010
movsd -0x28(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rax)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13aba
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x13642
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::Initialize()
void FcTse6::Initialize()
{
  int idx;

  ResetAll();

  simTime = GetSimTime();

  nextFrameTime = initFrameTime;

  for (idx = 0; idx < 6; ++idx)
  {
    eye[idx][idx] = 1.0;
  }

  HH[0][0] = 1.0;
  HH[1][2] = 1.0;
  HH[2][3] = 1.0;

  HT = Transpose( HH );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x5f8c
movq 0x38(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x2f8(%rbx)
movsd 0xf8(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
leaq 0x1c0(%rbx), %r14
xorl %r15d, %r15d
movabsq $0x3ff0000000000000, %r12 # imm = 0x3FF0000000000000
movq %r14, %rdi
movl %r15d, %esi
callq 0x13b48
movq %r12, (%rax,%r15,8)
incq %r15
cmpq $0x6, %r15
jne 0x5ec2
leaq 0x1d8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x13b48
movq %r12, (%rax)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13b48
movq %r12, 0x10(%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13b48
movq %r12, 0x18(%rax)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x13576
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x15940
addq $0x1f0, %rbx            # imm = 0x1F0
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %rbx, %rsi
callq 0x13b92
leaq -0x68(%rbp), %rdi
callq 0x13642
leaq -0x38(%rbp), %rdi
callq 0x13642
leaq -0x50(%rbp), %rdi
callq 0x13642
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x13642
jmp 0x5f7b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x13642
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::ResetAll()
void FcTse6::ResetAll()
{
  angSig      = 0.0;
  cartRel     = 0.0;
  estLosAng   = 0.0;
  estLosr     = 0.0;
  estRng      = 0.0;
  estRdot     = 0.0;
  estAccX     = 0.0;
  estAccY     = 0.0;
  eye         = 0.0;
  HH          = 0.0;
  HT          = 0.0;
  initialized = false;
  innovation  = 0.0;
  KK          = 0.0;
  measAng     = 0.0;
  measRng     = 0.0;
  measRdot    = 0.0;
  measVec     = 0.0;
  mscState    = 0.0;
  phi         = 0.0;
  PP          = 0.0;
  rDotSig     = 0.0;
  residual    = 0.0;
  rngSig      = 0.0;
  RR          = 0.0;
  simTime     = 0.0;
  timeStamp   = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x1b8(%rdi)
leaq 0x110(%rdi), %rsi
leaq -0x138(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x1c0(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rbx)
movups %xmm0, 0x138(%rbx)
movups %xmm0, 0x128(%rbx)
leaq -0x120(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x1d8(%rbx), %rsi
leaq -0x108(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x1f0(%rbx), %rsi
leaq -0xf0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
movb $0x0, 0x208(%rbx)
leaq 0x210(%rbx), %rsi
leaq -0xd8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x228(%rbx), %rsi
leaq -0xc0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x258(%rbx), %rsi
movq %r15, 0x250(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x240(%rbx)
leaq -0xa8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x270(%rbx), %rsi
leaq -0x90(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x288(%rbx), %rsi
leaq -0x78(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
leaq 0x2a0(%rbx), %rsi
leaq -0x60(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
movq %r15, 0x2b8(%rbx)
leaq 0x2c0(%rbx), %rsi
leaq -0x48(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
movq %r15, 0x2d8(%rbx)
leaq 0x2e0(%rbx), %rsi
leaq -0x30(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13c1a
movq %r14, %rdi
callq 0x13642
movq %r15, 0x2f8(%rbx)
movq %r15, 0x158(%rbx)
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::MscToCart(Matrix&, Matrix&)
void FcTse6::MscToCart( Matrix &mscState,
                        Matrix &cartRel )
{
  double range = 1.0 / mscState(2);
  double rDot = mscState(3) * range;

  double cth = cos( mscState(0) );
  double sth = sin( mscState(0) );

  double thDot = mscState(1);

  cartRel(0) = range * cth;
  cartRel(1) = range * sth;
  
  cartRel(2) = rDot * cth - range * thDot * sth;
  cartRel(3) = rDot * sth + range * thDot * cth;

  cartRel(4) = range * ( mscState(4) * cth - mscState(5) * sth );
  cartRel(5) = range * ( mscState(4) * sth + mscState(5) * cth );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
movl $0x2, %esi
callq 0x13aba
movsd 0xe02c(%rip), %xmm0     # 0x16038
divsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x13aba
movsd (%rax), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x13aba
movsd (%rax), %xmm0
callq 0x3310
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x13aba
movsd (%rax), %xmm0
callq 0x3080
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13aba
movsd -0x38(%rbp), %xmm0
movapd %xmm0, %xmm1
mulsd -0x28(%rbp), %xmm1
movsd %xmm1, -0x30(%rbp)
movsd (%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13aba
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13aba
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13aba
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x4, %esi
callq 0x13aba
movsd (%rax), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x13aba
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd -0x38(%rbp), %xmm1
movsd %xmm1, -0x18(%rbp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x4, %esi
callq 0x13aba
movsd -0x20(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x13aba
movsd -0x28(%rbp), %xmm0
mulsd (%rax), %xmm0
addsd -0x20(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13aba
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::CalcStateDeriv(Matrix&)
Matrix  FcTse6::CalcStateDeriv( Matrix &XX )
{
  Matrix  deriv(6,1);
                             
  deriv(0) = XX(2);  // d/dt(posX) = velX
  deriv(1) = XX(3);  // d/dt(posY) = velY
  deriv(2) = XX(4);  // d/dt(velX) = accX
  deriv(3) = XX(5);  // d/dt(velY) = accY
  deriv(4) = 0.0;    // d/dt(accX) = 0.0
  deriv(5) = 0.0;    // d/dy(accY) = 0.0

  return( deriv );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x6, %esi
movl $0x1, %edx
callq 0x13504
movq %r14, %rdi
movl $0x2, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x3, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x4, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x5, %esi
callq 0x13aba
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13aba
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13aba
movq $0x0, (%rax)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13aba
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x13642
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Guidance.cpp
// Function: Guidance::Guidance()
Guidance::Guidance() :
pAp(0),
pExec(0),
pMsl(0),
pMslTse(0),
pRdr(0),
pTgt(0),
pTse6(0),
MdlBase()
{
  //
  // Default initialization of input variables
  //
  frameTimeStep = 1.0/64.0;  // sec     Frame time step
  initFrameTime = 0.0;       // sec     Time of first frame update

  gdnLawSelInt  = 1;         // na      Guidance law selection
                             //         1 = Proportion Navigation
                             //         2 = Weave guidance
  kpn           = 3.0;       // na      Pro Nav gain
  tauCtrl       = 0.4;       // sec     Optimal guidance tuning parameter
  useTruth      = false;     // na      Use truth for target state

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa084
leaq 0x15087(%rip), %rax     # 0x1da30
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1d8(%rbx)
movups %xmm0, 0x1e8(%rbx)
movups %xmm0, 0x1f8(%rbx)
xorl %eax, %eax
movq %rax, 0x208(%rbx)
movabsq $0x3f90000000000000, %rcx # imm = 0x3F90000000000000
movq %rcx, 0x8(%rbx)
movq %rax, 0xf8(%rbx)
movl $0x1, 0x100(%rbx)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x108(%rbx)
movabsq $0x3fd999999999999a, %rax # imm = 0x3FD999999999999A
movq %rax, 0x118(%rbx)
movb $0x0, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Guidance.cpp
// Function: Guidance::Initialize()
void Guidance::Initialize()
{
  ResetAll();

  simTime = GetSimTime();

  assert( pAp );
  assert( pExec );
  assert( pMsl );
  assert( pMslTse );
  assert( pRdr );
  assert( pTgt );
  assert( pTse6 );

  gdnLawSel = static_cast<GdnLawSel>( gdnLawSelInt );

  launchTime = pMsl->launchTime;
  
  nextFrameTime = launchTime;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%rdi)
movups %xmm0, 0x140(%rdi)
movups %xmm0, 0x130(%rdi)
movups %xmm0, 0x120(%rdi)
movq $0x0, 0x15d(%rdi)
movups %xmm0, 0x168(%rdi)
movups %xmm0, 0x178(%rdi)
movups %xmm0, 0x188(%rdi)
movups %xmm0, 0x198(%rdi)
movups %xmm0, 0x1a8(%rdi)
movups %xmm0, 0x1b8(%rdi)
movups %xmm0, 0x1c8(%rdi)
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x198(%rdi)
cmpq $0x0, 0x1d8(%rdi)
je 0x8b3a
cmpq $0x0, 0x1e0(%rdi)
je 0x8b59
movq 0x1e8(%rdi), %rax
testq %rax, %rax
je 0x8b78
cmpq $0x0, 0x1f0(%rdi)
je 0x8b97
cmpq $0x0, 0x1f8(%rdi)
je 0x8bb6
cmpq $0x0, 0x200(%rdi)
je 0x8bd5
cmpq $0x0, 0x208(%rdi)
je 0x8bf4
movl 0x100(%rdi), %ecx
movl %ecx, 0x160(%rdi)
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
movsd %xmm0, 0x30(%rdi)
popq %rbp
retq
leaq 0xd98f(%rip), %rdi      # 0x164d0
leaq 0xd98c(%rip), %rsi      # 0x164d4
leaq 0xd999(%rip), %rcx      # 0x164e8
movl $0x6a, %edx
callq 0x30f0
leaq 0xd9ac(%rip), %rdi      # 0x1650c
leaq 0xd96d(%rip), %rsi      # 0x164d4
leaq 0xd97a(%rip), %rcx      # 0x164e8
movl $0x6b, %edx
callq 0x30f0
leaq 0xd993(%rip), %rdi      # 0x16512
leaq 0xd94e(%rip), %rsi      # 0x164d4
leaq 0xd95b(%rip), %rcx      # 0x164e8
movl $0x6c, %edx
callq 0x30f0
leaq 0xd979(%rip), %rdi      # 0x16517
leaq 0xd92f(%rip), %rsi      # 0x164d4
leaq 0xd93c(%rip), %rcx      # 0x164e8
movl $0x6d, %edx
callq 0x30f0
leaq 0xd962(%rip), %rdi      # 0x1651f
leaq 0xd910(%rip), %rsi      # 0x164d4
leaq 0xd91d(%rip), %rcx      # 0x164e8
movl $0x6e, %edx
callq 0x30f0
leaq 0xd948(%rip), %rdi      # 0x16524
leaq 0xd8f1(%rip), %rsi      # 0x164d4
leaq 0xd8fe(%rip), %rcx      # 0x164e8
movl $0x6f, %edx
callq 0x30f0
leaq 0xd92e(%rip), %rdi      # 0x16529
leaq 0xd8d2(%rip), %rsi      # 0x164d4
leaq 0xd8df(%rip), %rcx      # 0x164e8
movl $0x70, %edx
callq 0x30f0
nop