LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: select_individual_device()
item* select_individual_device()
{
	if(total_inv_devices())
	{

		int device_type = 999;
		while(device_type != -1)
		{
			device_type = select_device();
			if(device_type >= 0)
			{
				
				/*int t = ask_for_time();
			
				if (t >= 0)*/
				{
					item* dev = dev_inv[device_type][UNCONFIGURED].back();
					/*set_timer(dev,t);
					dev_inv[device_type][UNCONFIGURED].pop_back();*/
					return dev;
				}
			}
				//else
				//{
				//	return NULL;
				//}
				/*}
			{
				int device_configuration = 999;
				while(device_configuration != -1)
				{
					device_configuration = select_configuration(device_type);
					if(device_configuration != -1)
					{
						item* dev;
						if(device_configuration == ON_TIMER)
						{
							dev = select_individual_device_from_type_and_config(device_type,device_configuration);
						}
						else
						{
							dev = dev_inv[device_type][device_configuration].back();
							dev_inv[device_type][device_configuration].pop_back();
						}
						if(dev != NULL)
						{
							if(!reconfigure(dev))
							{return dev;}
							else 
							{return NULL;}

						}
					}
				}
				if(device_configuration == -1) break;
			}*/
		}
	}
	else
	{
		add_message("Nothing to throw!"); draw_last_msg();
	}
	return NULL;
}

// Assembly:
subq $0x58, %rsp
callq 0xf900
cmpl $0x0, %eax
je 0x1ca50
movl $0x3e7, 0x4c(%rsp)      # imm = 0x3E7
cmpl $-0x1, 0x4c(%rsp)
je 0x1ca4b
callq 0x1ae30
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jl 0x1ca49
movslq 0x4c(%rsp), %rsi
leaq 0xc3a97(%rip), %rdi     # 0xe04b0
callq 0x20ad0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20af0
movq %rax, %rdi
callq 0x21a00
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x1cad9
jmp 0x1c9f6
jmp 0x1cad0
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5490
movq (%rsp), %rdx
leaq 0x11e1c(%rip), %rsi     # 0x2e885
leaq 0x20(%rsp), %rdi
callq 0x53d0
jmp 0x1ca75
leaq 0x20(%rsp), %rdi
callq 0x6670
jmp 0x1ca81
leaq 0x20(%rsp), %rdi
callq 0x54f8
leaq 0x1f(%rsp), %rdi
callq 0x5310
callq 0x8ce0
jmp 0x1cad0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x1cac4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x54f8
leaq 0x1f(%rsp), %rdi
callq 0x5310
jmp 0x1cae3
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x5480
nopl (%rax)
// File: 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 %rax
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
cmpq $0x0, 0x6ba2f(%rip)     # 0x88530
je 0x1cb13
movq 0x6ba26(%rip), %rax     # 0x88530
cmpq 0x6ba3f(%rip), %rax     # 0x88550
jne 0x1cb59
leaq 0x6ba1e(%rip), %rdi     # 0x88538
callq 0x21950
cmpq $0x0, %rax
jne 0x1cb35
movq 0x6ba24(%rip), %rax     # 0x88550
movq %rax, 0x6b9fd(%rip)     # 0x88530
jmp 0x1cb57
leaq 0x6b9fc(%rip), %rdi     # 0x88538
xorl %eax, %eax
movl %eax, %esi
callq 0x21970
movq (%rax), %rax
movq %rax, 0x6b9e1(%rip)     # 0x88530
movl $0x0, 0x4(%rsp)
jmp 0x1cb59
movq 0x6b9d0(%rip), %rax     # 0x88530
movl 0x20(%rax), %edi
movq 0x6b9c6(%rip), %rax     # 0x88530
movl 0x24(%rax), %esi
movq 0x6b9dc(%rip), %rax     # 0x88550
movl 0x20(%rax), %edx
movq 0x6b9d2(%rip), %rax     # 0x88550
movl 0x24(%rax), %ecx
leaq -0x96d8(%rip), %r8      # 0x134b0
callq 0x16520
testb $0x1, %al
jne 0x1cbd7
leaq 0x6b9a0(%rip), %rdi     # 0x88538
callq 0x21950
cmpq $0x0, %rax
jne 0x1cbb3
movq 0x6b9a6(%rip), %rax     # 0x88550
movq %rax, 0x6b97f(%rip)     # 0x88530
jmp 0x1cbd5
leaq 0x6b97e(%rip), %rdi     # 0x88538
xorl %eax, %eax
movl %eax, %esi
callq 0x21970
movq (%rax), %rax
movq %rax, 0x6b963(%rip)     # 0x88530
movl $0x0, 0x4(%rsp)
jmp 0x1cbd7
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
cmpl $0x96, 0x24(%rsp)
jge 0x1eb56
movl $0x0, 0x20(%rsp)
cmpl $0x96, 0x20(%rsp)
jge 0x1eb44
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x13140
testb $0x1, %al
jne 0x1eb32
movslq 0x24(%rsp), %rcx
leaq 0x3294f(%rip), %rax     # 0x51340
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x20(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movslq 0x24(%rsp), %rcx
leaq 0x488bf(%rip), %rax     # 0x672d0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl $0x1, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jge 0x1eae0
movslq 0x18(%rsp), %rcx
leaq 0xedb4(%rip), %rax      # 0x2d800
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
addl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x20(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq 0x13170
testb $0x1, %al
jne 0x1eace
movslq 0xc(%rsp), %rcx
leaq 0x328b6(%rip), %rax     # 0x51340
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movslq 0x24(%rsp), %rcx
leaq 0x48826(%rip), %rax     # 0x672d0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x20(%rsp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1ead0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1ea35
movslq 0x24(%rsp), %rcx
leaq 0x487e4(%rip), %rax     # 0x672d0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x20(%rsp), %rcx
movss 0xe56d(%rip), %xmm0     # 0x2d070
mulss (%rax,%rcx,4), %xmm0
cvtsi2ssl 0x1c(%rsp), %xmm1
divss %xmm1, %xmm0
movslq 0x24(%rsp), %rcx
leaq 0x32822(%rip), %rax     # 0x51340
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x1eb34
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1e9c2
jmp 0x1eb46
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1e9ac
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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 %rax
movl $0x0, 0x4(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5280
movl %eax, %edi
callq 0x52b0
callq 0x14180
movq 0x1b50b(%rip), %rax     # 0x3afd0
movl $0x0, (%rax)
movl $0x0, (%rsp)
movl $0x0, 0x1b8a8(%rip)     # 0x3b384
cmpl $0x0, (%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1faeb
jmp 0x1fb04
callq 0x1eb60
movl %eax, (%rsp)
movl 0x1b88b(%rip), %eax     # 0x3b384
addl $0x1, %eax
movl %eax, 0x1b882(%rip)     # 0x3b384
jmp 0x1fadc
callq 0x5340
movl 0x4(%rsp), %eax
popq %rcx
retq
nop
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: is_corner_b(int, int)
inline bool is_corner_b(int x,int y)
{
	bool n = (map_terrain[x][y-1] != WALL);
	bool s = (map_terrain[x][y+1] != WALL);
	bool e = (map_terrain[x+1][y] != WALL);
	bool w = (map_terrain[x-1][y] != WALL);
	if (n || s) return (e || w);
	return false;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movslq -0x8(%rsp), %rcx
leaq 0x1a5ac(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x4, (%rax,%rcx,4)
setne %al
andb $0x1, %al
movb %al, -0xd(%rsp)
movslq -0x8(%rsp), %rcx
leaq 0x1a57f(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movl -0xc(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x4, (%rax,%rcx,4)
setne %al
andb $0x1, %al
movb %al, -0xe(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1a54d(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq -0xc(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
setne %al
andb $0x1, %al
movb %al, -0xf(%rsp)
movl -0x8(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1a520(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq -0xc(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
setne %al
andb $0x1, %al
movb %al, -0x10(%rsp)
testb $0x1, -0xd(%rsp)
jne 0x20eba
testb $0x1, -0xe(%rsp)
je 0x20edb
movb $0x1, %al
testb $0x1, -0xf(%rsp)
movb %al, -0x11(%rsp)
jne 0x20ecf
movb -0x10(%rsp), %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x20ee0
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x1cbe(%rip), %rdi      # 0x4004
xorl %eax, %eax
callq 0x2040
movl $0x6, -0x8(%rbp)
movl $0x18, %edi
callq 0x2030
movq %rax, -0x10(%rbp)
movl $0x40, %edi
callq 0x2100
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x2430
jmp 0x237d
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl $0x0, -0x28(%rbp)
cmpl $0x6, -0x28(%rbp)
jge 0x23e6
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x23aa
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x2110
jmp 0x2425
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21b0
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x26f1
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x26e4
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x61, %ecx
movb %cl, %dl
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x26ae
jmp 0x26e6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x269b
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq (%rcx), %rdi
movq 0x20(%rax), %rcx
movq (%rcx), %rsi
movslq 0xc(%rax), %rdx
shlq $0x0, %rdx
callq 0x20d0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq 0x8(%rcx), %rdi
movq 0x20(%rax), %rcx
movq (%rcx), %rsi
movslq 0xc(%rax), %rdx
shlq $0x0, %rdx
callq 0x20d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x153b(%rip), %rdi      # 0x4106
movb $0x0, %al
callq 0x2040
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2c26
movl -0xc(%rbp), %esi
leaq 0x144c(%rip), %rdi      # 0x403b
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movb $0x0, %al
callq 0x2040
leaq 0x1469(%rip), %rdi      # 0x407d
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2bd9
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x14cb(%rip), %rdi      # 0x4116
movb $0x0, %al
callq 0x2040
leaq 0x13ee(%rip), %rdi      # 0x4047
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movb $0x0, %al
callq 0x2040
leaq 0x1404(%rip), %rdi      # 0x407d
movb $0x0, %al
callq 0x2040
leaq 0x13cb(%rip), %rdi      # 0x4052
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
movb $0x0, %al
callq 0x2040
leaq 0x13d5(%rip), %rdi      # 0x407d
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3078
movl -0xc(%rbp), %esi
leaq 0xffa(%rip), %rdi       # 0x403b
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movb $0x0, %al
callq 0x2040
leaq 0x1017(%rip), %rdi      # 0x407d
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x302b
leaq 0xfc8(%rip), %rdi       # 0x4047
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movb $0x0, %al
callq 0x2040
leaq 0xfde(%rip), %rdi       # 0x407d
movb $0x0, %al
callq 0x2040
leaq 0xfa5(%rip), %rdi       # 0x4052
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
movb $0x0, %al
callq 0x2040
leaq 0xfaf(%rip), %rdi       # 0x407d
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x18(%rbp), %eax
cltd
idivl -0x1c(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x20d0
movl $0x2, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jge 0x39b4
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x392f
jmp 0x39a6
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x39a4
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x3997
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x28(%rbp), %ecx
imull -0x2c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x28(%rbp), %ecx
imull -0x2c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3945
jmp 0x3999
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3936
jmp 0x39a6
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3914
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xd640
movq -0x20(%rbp), %rdi
leaq 0x2b11c(%rip), %rax     # 0x2e840
movq %rax, (%rdi)
movabsq $0x3f90000000000000, %rax # imm = 0x3F90000000000000
movq %rax, 0x8(%rdi)
movq $0x0, 0xf8(%rdi)
movabsq $0x4072c00000000000, %rax # imm = 0x4072C00000000000
movq %rax, 0x100(%rdi)
movabsq $0x3fc999999999999a, %rax # imm = 0x3FC999999999999A
movq %rax, 0x108(%rdi)
movq %rdi, %rsi
addq $0x138, %rsi            # imm = 0x138
movq %rdi, %rdx
addq $0x140, %rdx            # imm = 0x140
callq 0xd9d0
jmp 0x377d
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x148, %rsi            # imm = 0x148
movq %rdi, %rdx
addq $0x150, %rdx            # imm = 0x150
callq 0xd9d0
jmp 0x379c
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x158, %rsi            # imm = 0x158
movq %rdi, %rdx
addq $0x160, %rdx            # imm = 0x160
callq 0xd9d0
jmp 0x37bb
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd790
movq -0x10(%rbp), %rdi
callq 0x33d0
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3890
movq -0x10(%rbp), %rdi
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x130(%rax)
movq 0x178(%rax), %rcx
movsd 0x108(%rcx), %xmm0
movsd %xmm0, 0x128(%rax)
movsd 0x128(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DavidLBruce[P]sim3dof/build/../src/Autopilot.cpp
// Function: Autopilot::ResetAll()
void Autopilot::ResetAll()
{
  ayb         = 0.0;
  aCmdYb      = 0.0;
  aCmdYbLim   = 0.0;
  launchTime  = 0.0;
  simTime     = 0.0;
  x0          = 0.0;
  x0d         = 0.0;
  x1          = 0.0;
  x1d         = 0.0;
  x2          = 0.0;
  x2d         = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x118(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x120(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x110(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x128(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x130(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x138(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x140(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x160(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3c40
movq -0x18(%rbp), %rax
movsd %xmm0, 0x130(%rax)
movsd 0x108(%rax), %xmm0
movsd 0x205fb(%rip), %xmm1    # 0x24020
divsd %xmm1, %xmm0
movsd 0x205e7(%rip), %xmm1    # 0x24018
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x205ce(%rip), %xmm0    # 0x24010
divsd -0x10(%rbp), %xmm0
movsd 0x138(%rax), %xmm2
movsd 0x205b1(%rip), %xmm1    # 0x24008
divsd -0x10(%rbp), %xmm1
mulsd 0x148(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x140(%rax)
movsd 0x20594(%rip), %xmm0    # 0x24010
divsd -0x10(%rbp), %xmm0
movsd 0x148(%rax), %xmm2
movsd 0x20577(%rip), %xmm1    # 0x24008
divsd -0x10(%rbp), %xmm1
mulsd 0x158(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x150(%rax)
movsd 0x2055a(%rip), %xmm0    # 0x24010
divsd -0x10(%rbp), %xmm0
movsd 0x158(%rax), %xmm2
movsd 0x2053d(%rip), %xmm1    # 0x24008
divsd -0x10(%rbp), %xmm1
mulsd 0x110(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x160(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3c40
movq -0x20(%rbp), %rax
movsd %xmm0, 0x130(%rax)
testb $0x1, -0x9(%rbp)
je 0x3bbd
movq -0x18(%rbp), %rdi
leaq 0x204c6(%rip), %rsi     # 0x24028
leaq 0x204c4(%rip), %rdx     # 0x2402d
movb $0x0, %al
callq 0x3330
movq -0x18(%rbp), %rdi
leaq 0x204ad(%rip), %rsi     # 0x24028
leaq 0x204b5(%rip), %rdx     # 0x24037
movb $0x0, %al
callq 0x3330
movq -0x18(%rbp), %rdi
leaq 0x20494(%rip), %rsi     # 0x24028
leaq 0x204a9(%rip), %rdx     # 0x24044
movb $0x0, %al
callq 0x3330
movq -0x18(%rbp), %rdi
leaq 0x2047b(%rip), %rsi     # 0x24028
leaq 0x20497(%rip), %rdx     # 0x2404b
movb $0x0, %al
callq 0x3330
jmp 0x3c35
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movsd 0x100(%rax), %xmm0
leaq 0x2047e(%rip), %rsi     # 0x24052
movb $0x1, %al
callq 0x3330
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movsd 0x110(%rax), %xmm0
leaq 0x20460(%rip), %rsi     # 0x24052
movb $0x1, %al
callq 0x3330
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movsd 0x118(%rax), %xmm0
leaq 0x20442(%rip), %rsi     # 0x24052
movb $0x1, %al
callq 0x3330
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movsd 0x108(%rax), %xmm0
leaq 0x20424(%rip), %rsi     # 0x24052
movb $0x1, %al
callq 0x3330
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xd640
movq -0x10(%rbp), %rax
leaq 0x2ac14(%rip), %rcx     # 0x2e898
addq $0x10, %rcx
movq %rcx, (%rax)
movsd 0x203e5(%rip), %xmm0    # 0x24078
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xf8(%rax)
movsd 0x203c5(%rip), %xmm0    # 0x24070
movsd %xmm0, 0x100(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x108(%rax)
movsd 0x203a2(%rip), %xmm0    # 0x24068
movsd %xmm0, 0x110(%rax)
movsd 0x2034a(%rip), %xmm0    # 0x24020
movsd %xmm0, 0x120(%rax)
movsd 0x2033a(%rip), %xmm0    # 0x24020
movsd %xmm0, 0x118(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3dc0
movq -0x10(%rbp), %rdi
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x1a0(%rax)
movsd 0xf8(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movsd 0x100(%rax), %xmm0
movsd %xmm0, 0x140(%rax)
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0x148(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DavidLBruce[P]sim3dof/build/../src/FcRadar.cpp
// Function: FcRadar::ResetAll()
void FcRadar::ResetAll()
{
  measAng   = 0.0;
  measRng   = 0.0;
  measRdot  = 0.0;
  pxf       = 0.0;
  pyf       = 0.0; 
  truAng    = 0.0;
  truPosX   = 0.0;
  truPosY   = 0.0;
  truRng    = 0.0;
  truRdot   = 0.0;
  vxf       = 0.0;
  vyf       = 0.0; 
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x128(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x138(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x130(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x140(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1a8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1b0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x168(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x160(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x170(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x178(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x1a0(%rax)
movq 0x1d0(%rax), %rcx
movsd 0x160(%rcx), %xmm0
movsd %xmm0, 0x1a8(%rax)
movq 0x1d0(%rax), %rcx
movsd 0x168(%rcx), %xmm0
movsd %xmm0, 0x1b0(%rax)
movq 0x1d0(%rax), %rcx
movsd 0x180(%rcx), %xmm0
subsd 0x170(%rax), %xmm0
movsd %xmm0, 0x1b8(%rax)
movq 0x1d0(%rax), %rcx
movsd 0x190(%rcx), %xmm0
subsd 0x178(%rax), %xmm0
movsd %xmm0, 0x1c0(%rax)
movsd 0x1a8(%rax), %xmm0
subsd 0x140(%rax), %xmm0
movsd %xmm0, 0x180(%rax)
movsd 0x1b0(%rax), %xmm0
subsd 0x148(%rax), %xmm0
movsd %xmm0, 0x188(%rax)
movsd 0x1b8(%rax), %xmm0
movsd %xmm0, 0x190(%rax)
movsd 0x1c0(%rax), %xmm0
movsd %xmm0, 0x198(%rax)
movsd 0x188(%rax), %xmm0
movsd 0x180(%rax), %xmm1
callq 0x3070
movq -0x10(%rbp), %rax
movsd %xmm0, 0x158(%rax)
movsd 0x180(%rax), %xmm0
callq 0x4450
movq -0x10(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd 0x188(%rax), %xmm0
callq 0x4450
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x3190
movq -0x10(%rbp), %rax
movsd %xmm0, 0x168(%rax)
movsd 0x190(%rax), %xmm0
movsd 0x180(%rax), %xmm2
movsd 0x198(%rax), %xmm1
mulsd 0x188(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd 0x168(%rax), %xmm0
movsd %xmm0, 0x160(%rax)
movsd 0x158(%rax), %xmm0
movsd 0x110(%rax), %xmm1
movq 0x1c8(%rax), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0xcca0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x128(%rax)
movsd 0x160(%rax), %xmm0
movsd 0x118(%rax), %xmm1
movq 0x1c8(%rax), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0xcca0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x130(%rax)
movsd 0x168(%rax), %xmm0
movsd 0x120(%rax), %xmm1
movq 0x1c8(%rax), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0xcca0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x138(%rax)
movsd 0x1a0(%rax), %xmm0
movsd %xmm0, 0x150(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x49f0
movq -0x30(%rbp), %rdi
callq 0x3c40
movq -0x30(%rbp), %rsi
movsd %xmm0, 0x240(%rsi)
movsd 0xf8(%rsi), %xmm0
movsd %xmm0, 0x30(%rsi)
addq $0x170, %rsi            # imm = 0x170
leaq -0x28(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0x28(%rbp), %rdi
callq 0x1f580
movq -0x30(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
xorl %esi, %esi
callq 0x1fe60
movsd 0x1f667(%rip), %xmm0    # 0x24008
movsd %xmm0, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x49e1
movq -0x30(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movl -0xc(%rbp), %esi
callq 0x1fe60
movslq -0xc(%rbp), %rcx
movsd 0x1f637(%rip), %xmm0    # 0x24008
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x49ac
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x138(%rsi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x140(%rsi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rsi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rsi)
addq $0x158, %rsi            # imm = 0x158
leaq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0x20(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
leaq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0x38(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
addq $0x188, %rsi            # imm = 0x188
leaq -0x50(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0x50(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
movb $0x0, 0x1a0(%rsi)
addq $0x1a8, %rsi            # imm = 0x1A8
leaq -0x68(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0x68(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
leaq -0x80(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0x80(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, 0x1d8(%rsi)
addq $0x1e0, %rsi            # imm = 0x1E0
leaq -0x98(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0x98(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
addq $0x1f8, %rsi            # imm = 0x1F8
leaq -0xb0(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0xb0(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, 0x210(%rsi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x218(%rsi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x220(%rsi)
addq $0x228, %rsi            # imm = 0x228
leaq -0xc8(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0xc8(%rbp), %rdi
callq 0x1f580
movq -0xe8(%rbp), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, 0x240(%rsi)
addq $0x248, %rsi            # imm = 0x248
leaq -0xe0(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1ffd0
leaq -0xe0(%rbp), %rdi
callq 0x1f580
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x3, %esi
movl $0x1, %edx
movl %edx, -0x3c(%rbp)
xorps %xmm0, %xmm0
callq 0x1f2e0
movl -0x3c(%rbp), %esi
movq -0x18(%rbp), %rdi
callq 0x1fd40
movq %rax, -0x38(%rbp)
jmp 0x6b5d
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
xorl %esi, %esi
callq 0x1fd40
movq %rax, -0x58(%rbp)
jmp 0x6b7b
movq -0x58(%rbp), %rax
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x1fd40
movq %rax, -0x68(%rbp)
jmp 0x6b9c
movq -0x68(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x1d5b5(%rip), %xmm1    # 0x24160
pxor %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x1fd40
movq %rax, -0x70(%rbp)
jmp 0x6bc5
movq -0x50(%rbp), %rdi
movsd -0x78(%rbp), %xmm0
movq -0x70(%rbp), %rax
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movl $0x1, %esi
callq 0x1fd40
movq %rax, -0x80(%rbp)
jmp 0x6bf2
movq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rax
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movl $0x2, %esi
callq 0x1fd40
movq %rax, -0x90(%rbp)
jmp 0x6c19
movq -0x90(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x6c53
jmp 0x6c4a
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1f580
jmp 0x6c60
movq -0x50(%rbp), %rdi
callq 0x1f580
movq -0x48(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7400
movq -0x70(%rbp), %rdi
callq 0x3c40
movq -0x70(%rbp), %rax
movsd %xmm0, 0x2f8(%rax)
movsd 0xf8(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jge 0x730a
movq -0x70(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movl -0xc(%rbp), %esi
callq 0x1fe60
movslq -0xc(%rbp), %rcx
movsd 0x1cd0e(%rip), %xmm0    # 0x24008
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x72d5
movq -0x70(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movq %rdi, -0x80(%rbp)
xorl %esi, %esi
callq 0x1fe60
movq -0x80(%rbp), %rdi
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, -0x88(%rbp)
movq %rcx, (%rax)
movl $0x1, %esi
callq 0x1fe60
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rdi
movq %rcx, 0x10(%rax)
movl $0x2, %esi
callq 0x1fe60
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq %rcx, 0x18(%rax)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1f3e0
movq -0x78(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x23320
jmp 0x7386
movq -0x70(%rbp), %rsi
addq $0x1f0, %rsi            # imm = 0x1F0
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x1ff00
jmp 0x73a0
leaq -0x28(%rbp), %rdi
callq 0x1f580
leaq -0x40(%rbp), %rdi
callq 0x1f580
leaq -0x58(%rbp), %rdi
callq 0x1f580
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x73e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1f580
leaq -0x58(%rbp), %rdi
callq 0x1f580
movq -0x60(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x6, %esi
movl $0x1, %edx
xorps %xmm0, %xmm0
callq 0x1f2e0
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x1fd40
movq %rax, -0x38(%rbp)
jmp 0xaf7c
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
xorl %esi, %esi
callq 0x1fd40
movq %rax, -0x50(%rbp)
jmp 0xaf9a
movq -0x50(%rbp), %rax
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x1fd40
movq %rax, -0x60(%rbp)
jmp 0xafbb
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movl $0x1, %esi
callq 0x1fd40
movq %rax, -0x68(%rbp)
jmp 0xafdc
movq -0x68(%rbp), %rax
movsd -0x70(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x1fd40
movq %rax, -0x78(%rbp)
jmp 0xaffd
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movl $0x2, %esi
callq 0x1fd40
movq %rax, -0x80(%rbp)
jmp 0xb021
movq -0x80(%rbp), %rax
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movl $0x5, %esi
callq 0x1fd40
movq %rax, -0x90(%rbp)
jmp 0xb048
movq -0x48(%rbp), %rdi
movq -0x90(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movl $0x3, %esi
callq 0x1fd40
movq %rax, -0x98(%rbp)
jmp 0xb072
movq -0x48(%rbp), %rdi
movq -0x98(%rbp), %rax
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, (%rax)
movl $0x4, %esi
callq 0x1fd40
movq %rax, -0xa8(%rbp)
jmp 0xb09c
movq -0x48(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq $0x0, (%rax)
movl $0x5, %esi
callq 0x1fd40
movq %rax, -0xb0(%rbp)
jmp 0xb0c1
movq -0xb0(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xb0fb
jmp 0xb0f2
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1f580
jmp 0xb108
movq -0x48(%rbp), %rdi
callq 0x1f580
movq -0x40(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xd640
movq -0x10(%rbp), %rax
leaq 0x2388c(%rip), %rcx     # 0x2e9d0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x1d8(%rax)
movq $0x0, 0x1e0(%rax)
movq $0x0, 0x1e8(%rax)
movq $0x0, 0x1f0(%rax)
movq $0x0, 0x1f8(%rax)
movq $0x0, 0x200(%rax)
movq $0x0, 0x208(%rax)
movsd 0x18ed8(%rip), %xmm0    # 0x24078
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xf8(%rax)
movl $0x1, 0x100(%rax)
movsd 0x18e5e(%rip), %xmm0    # 0x24020
movsd %xmm0, 0x108(%rax)
movsd 0x1931e(%rip), %xmm0    # 0x244f0
movsd %xmm0, 0x118(%rax)
movb $0x0, 0x110(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xb3f0
movq -0x10(%rbp), %rdi
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x198(%rax)
cmpq $0x0, 0x1d8(%rax)
je 0xb27a
jmp 0xb299
leaq 0x1928f(%rip), %rdi     # 0x24510
leaq 0x1928c(%rip), %rsi     # 0x24514
movl $0x6a, %edx
leaq 0x19294(%rip), %rcx     # 0x24528
callq 0x3150
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1e0(%rax)
je 0xb2a9
jmp 0xb2c8
leaq 0x1929c(%rip), %rdi     # 0x2454c
leaq 0x1925d(%rip), %rsi     # 0x24514
movl $0x6b, %edx
leaq 0x19265(%rip), %rcx     # 0x24528
callq 0x3150
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1e8(%rax)
je 0xb2d8
jmp 0xb2f7
leaq 0x19273(%rip), %rdi     # 0x24552
leaq 0x1922e(%rip), %rsi     # 0x24514
movl $0x6c, %edx
leaq 0x19236(%rip), %rcx     # 0x24528
callq 0x3150
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1f0(%rax)
je 0xb307
jmp 0xb326
leaq 0x19249(%rip), %rdi     # 0x24557
leaq 0x191ff(%rip), %rsi     # 0x24514
movl $0x6d, %edx
leaq 0x19207(%rip), %rcx     # 0x24528
callq 0x3150
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1f8(%rax)
je 0xb336
jmp 0xb355
leaq 0x19222(%rip), %rdi     # 0x2455f
leaq 0x191d0(%rip), %rsi     # 0x24514
movl $0x6e, %edx
leaq 0x191d8(%rip), %rcx     # 0x24528
callq 0x3150
movq -0x10(%rbp), %rax
cmpq $0x0, 0x200(%rax)
je 0xb365
jmp 0xb384
leaq 0x191f8(%rip), %rdi     # 0x24564
leaq 0x191a1(%rip), %rsi     # 0x24514
movl $0x6f, %edx
leaq 0x191a9(%rip), %rcx     # 0x24528
callq 0x3150
movq -0x10(%rbp), %rax
cmpq $0x0, 0x208(%rax)
je 0xb394
jmp 0xb3b3
leaq 0x191ce(%rip), %rdi     # 0x24569
leaq 0x19172(%rip), %rsi     # 0x24514
movl $0x70, %edx
leaq 0x1917a(%rip), %rcx     # 0x24528
callq 0x3150
movq -0x10(%rbp), %rax
movl 0x100(%rax), %ecx
movl %ecx, 0x160(%rax)
movq 0x1e8(%rax), %rcx
movsd 0x108(%rcx), %xmm0
movsd %xmm0, 0x170(%rax)
movsd 0x170(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: DavidLBruce[P]sim3dof/build/../src/Guidance.cpp
// Function: Guidance::ResetAll()
void Guidance::ResetAll()
{
  aCmdYb         = 0.0;
  estAccX        = 0.0;
  estAccY        = 0.0;
  estLosAng      = 0.0;
  estLosr        = 0.0;
  estRng         = 0.0;
  estRdot        = 0.0;
  gdnLawSel      = glNULL;
  initialized    = false;
  kWeave         = 0.0;
  launchTime     = 0.0;
  relPxf         = 0.0;        
  relPyf         = 0.0;        
  relVxf         = 0.0;        
  relVyf         = 0.0;        
  simTime        = 0.0;
  tgo            = 0.0;       
  tgtAxf         = 0.0;        
  tgtAyf         = 0.0;        
  tgtPxf         = 0.0;        
  tgtPyf         = 0.0;        
  tgtVxf         = 0.0;        
  tgtVyf         = 0.0;        
  velClose       = 0.0;      

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x120(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x130(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x138(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x140(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rax)
movl $0x0, 0x160(%rax)
movb $0x0, 0x164(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x168(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x170(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x178(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x180(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x188(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x190(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x198(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x128(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1a0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1a8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1b0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1b8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1c0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1c8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1d0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: limit(double, double, double)
double limit(double val,
             double lower_lim,
             double upper_lim)
{
  if (val < lower_lim)
    return lower_lim;
  if (val > upper_lim)
    return upper_lim;

  return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc37f
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc3a1
movsd -0x10(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xc397
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc3a1
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)