LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/conf2img/conf2img.cpp
// Function: CaptureInteger(gaps::R2Grid&)
static int
CaptureInteger(R2Grid& image)
{
  // Allocate pixel buffer
  unsigned char *pixels = new unsigned char [ 4 * width * height ];

  // Read pixels
  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

  // Fill image
  unsigned char *pixelp = pixels;
  for (int iy = 0; iy < height; iy++) {
    for (int ix = 0; ix < width; ix++) {
      unsigned int red = *pixelp++;
      unsigned int green = *pixelp++;
      unsigned int blue = *pixelp++;
      unsigned int alpha = *pixelp++;
      unsigned int value = 0;
      value |= red << 24;
      value |= green << 16;
      value |= blue <<  8;
      value |= alpha;
      image.SetGridValue(ix, iy, value);
    }
  }

  // Delete pixels
  delete [] pixels;
  
  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl 0x225c3d(%rip), %eax    # 0x255d9c
shll $0x2, %eax
imull 0x225c37(%rip), %eax    # 0x255da0
movslq %eax, %rdi
callq 0x24040
movq %rax, 0x38(%rsp)
movl 0x225c20(%rip), %edx    # 0x255d9c
movl 0x225c1e(%rip), %ecx    # 0x255da0
movq 0x38(%rsp), %rax
xorl %esi, %esi
movl $0x1908, %r8d           # imm = 0x1908
movl $0x1401, %r9d           # imm = 0x1401
movl %esi, %edi
movq %rax, (%rsp)
callq 0x24420
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x225be4(%rip), %eax    # 0x255da0
jge 0x302bc
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x225bc8(%rip), %eax    # 0x255d9c
jge 0x302aa
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x24(%rsp), %ecx
shll $0x18, %ecx
movl 0x14(%rsp), %eax
orl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x20(%rsp), %ecx
shll $0x10, %ecx
movl 0x14(%rsp), %eax
orl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %ecx
shll $0x8, %ecx
movl 0x14(%rsp), %eax
orl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %ecx
movl 0x14(%rsp), %eax
orl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x2c(%rsp), %edx
movl 0x14(%rsp), %eax
cvtsi2sd %rax, %xmm0
callq 0x308a0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x301ca
jmp 0x302ac
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x301b2
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x302d6
movq 0x8(%rsp), %rdi
callq 0x24db0
movl $0x1, %eax
addq $0x48, %rsp
retq
// File: tomfunkhouser[P]gaps/apps/conf2img/conf2img.cpp
// Function: LoadInteger(int)
static void
LoadInteger(int value)
{
  // Just checking
  assert(value >= 0);
  
  // Set color to represent an integer (24 bits)
  unsigned char color[4];
  color[0] = (value >> 24) & 0xFF;
  color[1] = (value >> 16) & 0xFF;
  color[2] = (value >>  8) & 0xFF;
  color[3] = (value      ) & 0xFF;
  RNLoadRgba(color);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl 0x4(%rsp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, (%rsp)
movl 0x4(%rsp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, 0x1(%rsp)
movl 0x4(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, 0x2(%rsp)
movl 0x4(%rsp), %eax
andl $0xff, %eax
movb %al, 0x3(%rsp)
movq %rsp, %rdi
callq 0x30e50
popq %rax
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/conf2img/conf2img.cpp
// Function: Affinity(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3Point const&, gaps::R3Vector const&)
static RNScalar
Affinity(const R3Point& source_viewpoint, const R3Vector& source_towards,
         const R3Point& target_viewpoint, const R3Vector& target_towards)
{
  // Initialize affinity
  RNScalar affinity = 1.0;
  
  // Consider distance
  RNScalar dd = R3SquaredDistance(source_viewpoint, target_viewpoint);
  if (dd > 1.0) affinity /= dd;

  // Consider delta z
  RNScalar dz = fabs(source_viewpoint.Z() - target_viewpoint.Z());
  if (dz > 1.0) return 0;

  // Consider view angle
  RNScalar dot = source_towards.Dot(target_towards);
  if (dot > 0) affinity *= dot*dot;
  else return 0;

  // Return affinity
  return affinity;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movsd 0x1aecd8(%rip), %xmm0   # 0x1df028
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xad570
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x1aecaf(%rip), %xmm1   # 0x1df028
ucomisd %xmm1, %xmm0
jbe 0x30395
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x30d30
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x30d30
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movaps 0x1aecbd(%rip), %xmm1   # 0x1df080
pand %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x1aec4d(%rip), %xmm1   # 0x1df028
ucomisd %xmm1, %xmm0
jbe 0x303ec
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x30441
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x107070
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3042a
movsd 0x10(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x30435
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x30441
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopl (%rax)
// File: gabryatfendor[P]SocietySimulator/src/map.cpp
// Function: update()
void update()
{
	printMap();
	int k,x,y;
	for(int i=0;i<POPULATION;i++)
	{
		people[i].work();
		if(!people[i].working)
		{
			people[i].move();
		}
	}

	if(cfg.automated)
	sleep(cfg.speed);
	else
	getchar();
	system("clear");

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x4bc0
movl $0x0, -0x10(%rbp)
cmpl $0x19, -0x10(%rbp)
jge 0x4b7d
movslq -0x10(%rbp), %rax
leaq 0xe24b(%rip), %rdi      # 0x12d80
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x6090
movslq -0x10(%rbp), %rcx
leaq 0xe234(%rip), %rax      # 0x12d80
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x15(%rax)
jne 0x4b70
movslq -0x10(%rbp), %rax
leaq 0xe21c(%rip), %rdi      # 0x12d80
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x5d90
jmp 0x4b72
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4b24
leaq 0x96b4(%rip), %rax      # 0xe238
testb $0x1, 0x3c(%rax)
je 0x4b9b
leaq 0x96a7(%rip), %rax      # 0xe238
movl 0x40(%rax), %edi
callq 0x2180
jmp 0x4ba0
callq 0x2330
leaq 0x44ad(%rip), %rdi      # 0x9054
callq 0x21c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/map.cpp
// Function: setWater()
void setWater()
{
    int lakes = randBetween(1, cfg.maxLakes);
    for(int i=0;i<lakes;i++)
    {
        int ray = randBetween(1, cfg.maxLakesRay);
				int x = randBetween(ray, WIDTH-ray);
				int y = randBetween(ray, HEIGHT-ray);
        for(int j=x-ray;j<x+ray;j++)
        {
            for(int k=y-ray;k<y+ray;k++)
            {
                map[j][k].kind='-';
                map[j][k].origin='-';
                map[j][k].walkable=true;
            }
        }
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x9269(%rip), %rax      # 0xe238
movl 0x24(%rax), %esi
movl $0x1, %edi
callq 0x8440
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x50f8
leaq 0x923f(%rip), %rax      # 0xe238
movl 0x30(%rax), %esi
movl $0x1, %edi
callq 0x8440
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0x50, %esi
subl -0xc(%rbp), %esi
callq 0x8440
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl $0x14, %esi
subl -0xc(%rbp), %esi
callq 0x8440
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x50e8
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x50d8
movslq -0x18(%rbp), %rcx
leaq 0x9216(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x2d, 0x1(%rax)
movslq -0x18(%rbp), %rcx
leaq 0x91f2(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x2d, (%rax)
movslq -0x18(%rbp), %rcx
leaq 0x91cf(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x9(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5052
jmp 0x50da
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5038
jmp 0x50ea
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4fe6
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gabryatfendor[P]SocietySimulator/src/map.cpp
// Function: setWood()
void setWood()
{
	int woods = randBetween(1, cfg.maxWoods);

	for(int i=0;i<woods;i++)
	{
		/*set ray*/
		int ray = randBetween(1, cfg.maxWoodsRay);
		/*choose center*/
		int x = randBetween(ray, WIDTH-ray);
		int y = randBetween(ray, HEIGHT-ray);
		/*mapping*/
		for(int j=x-ray;j<x+ray;j++)
		{
			for(int k=y-ray;k<y+ray;k++)
			{
				map[j][k].kind='|';
				map[j][k].origin='|';
			}
		}
	 }

	 return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x9129(%rip), %rax      # 0xe238
movl 0x2c(%rax), %esi
movl $0x1, %edi
callq 0x8440
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x520d
leaq 0x90ff(%rip), %rax      # 0xe238
movl 0x38(%rax), %esi
movl $0x1, %edi
callq 0x8440
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0x50, %esi
subl -0xc(%rbp), %esi
callq 0x8440
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl $0x14, %esi
subl -0xc(%rbp), %esi
callq 0x8440
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x51fd
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x51ed
movslq -0x18(%rbp), %rcx
leaq 0x90da(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x7c, 0x1(%rax)
movslq -0x18(%rbp), %rcx
leaq 0x90b6(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x7c, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x518e
jmp 0x51ef
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5178
jmp 0x51ff
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5126
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/map.cpp
// Function: setMountain()
void setMountain()
{
	int mountains = randBetween(1, cfg.maxMountains);
	for(int i=0;i<mountains;i++)
	{
		/*set ray*/
		int ray = randBetween(1, cfg.maxMountainsRay);
		/*choose center*/
		int x = randBetween(ray, WIDTH-ray);
		int y = randBetween(ray, HEIGHT-ray);
		/*mapping*/
		for(int j=x-ray;j<x+ray;j++)
		{
			for(int k=y-ray;k<y+ray;k++)
			{
				map[j][k].kind='^';
				map[j][k].origin='^';
			}
		}
	 }

	 return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x9009(%rip), %rax      # 0xe238
movl 0x28(%rax), %esi
movl $0x1, %edi
callq 0x8440
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x532d
leaq 0x8fdf(%rip), %rax      # 0xe238
movl 0x34(%rax), %esi
movl $0x1, %edi
callq 0x8440
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0x50, %esi
subl -0xc(%rbp), %esi
callq 0x8440
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl $0x14, %esi
subl -0xc(%rbp), %esi
callq 0x8440
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x531d
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x530d
movslq -0x18(%rbp), %rcx
leaq 0x8fba(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x5e, 0x1(%rax)
movslq -0x18(%rbp), %rcx
leaq 0x8f96(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x5e, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52ae
jmp 0x530f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5298
jmp 0x531f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5246
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/map.cpp
// Function: setIsland()
void setIsland()
{
	if(cfg.mapIsland)
	 {
		 for(int i=0;i<WIDTH;i++)
		 {
			for(int j=0;j<HEIGHT;j++)
			{
				if(i<2 || j<2 || i>WIDTH-3 || j>HEIGHT-3)
				{
					map[i][j].kind = '-';
					map[i][j].origin = '-';
					map[i][j].walkable=false;
				}
			}
		 }
	 }

	 return;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8eed(%rip), %rax      # 0xe238
testb $0x1, 0x44(%rax)
je 0x541c
movl $0x0, -0x4(%rbp)
cmpl $0x50, -0x4(%rbp)
jge 0x541a
movl $0x0, -0x8(%rbp)
cmpl $0x14, -0x8(%rbp)
jge 0x540a
cmpl $0x2, -0x4(%rbp)
jl 0x538f
cmpl $0x2, -0x8(%rbp)
jl 0x538f
cmpl $0x4d, -0x4(%rbp)
jg 0x538f
cmpl $0x11, -0x8(%rbp)
jle 0x53fa
movslq -0x4(%rbp), %rcx
leaq 0x8ee6(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x2d, 0x1(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x8ec2(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x2d, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x8e9f(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x9(%rax)
jmp 0x53fc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x536d
jmp 0x540c
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x535c
jmp 0x541c
popq %rbp
retq
nop
// File: gabryatfendor[P]SocietySimulator/src/map.cpp
// Function: initPeople()
void initPeople()
{
	int x,y;
	for(int k=0;k<POPULATION;k++)
	{
		do
		{
			x = rand() % WIDTH;
			y = rand() % HEIGHT;
		} while(map[x][y].villagerHere || map[x][y].kind=='-');

		people[k].position[0]=x;
		people[k].position[1]=y;
		people[k].underMe=map[x][y].kind;
		map[x][y].villagerHere=true;
		people[k].pathCoordinates = people[k].setPath();
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0x5597
jmp 0x543b
callq 0x2080
movl $0x50, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
callq 0x2080
movl $0x14, %ecx
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movslq -0x4(%rbp), %rax
leaq 0x8e1a(%rip), %rcx      # 0xe280
imulq $0xf0, %rax, %rax
addq %rax, %rcx
movslq -0x8(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
movb $0x1, %al
testb $0x1, 0xa(%rcx)
movb %al, -0x29(%rbp)
jne 0x54b3
movslq -0x4(%rbp), %rcx
leaq 0x8def(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl 0x1(%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x543b
movl -0x4(%rbp), %ecx
movslq -0xc(%rbp), %rdx
leaq 0xd8b8(%rip), %rax      # 0x12d80
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x8(%rbp), %ecx
movslq -0xc(%rbp), %rdx
leaq 0xd8a0(%rip), %rax      # 0x12d80
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x8d8b(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb 0x1(%rax), %cl
movslq -0xc(%rbp), %rdx
leaq 0xd868(%rip), %rax      # 0x12d80
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x14(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x8d53(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0xa(%rax)
movslq -0xc(%rbp), %rax
leaq 0xd82f(%rip), %rsi      # 0x12d80
imulq $0x30, %rax, %rax
addq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x5ef0
movslq -0xc(%rbp), %rax
leaq 0xd814(%rip), %rdi      # 0x12d80
imulq $0x30, %rax, %rax
addq %rax, %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x55a0
leaq -0x28(%rbp), %rdi
callq 0x55d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x542f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::fishing()
void Person::fishing()
{
    if(checkAround(this->position[0],this->position[1],'-'))
    {
        this->working = true;
        fish++;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0xc(%rax), %edi
movl 0x10(%rax), %esi
movl $0x2d, %edx
callq 0x8260
testb $0x1, %al
jne 0x5a9a
jmp 0x5ab7
movq -0x10(%rbp), %rax
movb $0x1, 0x15(%rax)
leaq 0xd78f(%rip), %rax      # 0x13238
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xd783(%rip), %rax      # 0x13238
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::woodcutting()
void Person::woodcutting()
{
    if(this->underMe=='|')
    {
        int x = this->position[0];
        int y = this->position[1];
        this->working = true;
        wood++;
        map[x][y].usable-=25;
        if(map[x][y].usable<=0)
        {
            this->working=false;
            this->underMe='x';
            map[x][y].isRegenerating=true;
            map[x][y].kind = 'x';
        }
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x14(%rax), %eax
cmpl $0x7c, %eax
jne 0x5bab
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x10(%rbp)
movb $0x1, 0x15(%rax)
leaq 0xd73c(%rip), %rax      # 0x13234
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xd730(%rip), %rax      # 0x13234
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x876f(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
subl $0x19, %ecx
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8746(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jg 0x5ba9
movq -0x18(%rbp), %rax
movb $0x0, 0x15(%rax)
movb $0x78, 0x14(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8714(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x8(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x86f0(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x78, 0x1(%rax)
jmp 0x5bab
popq %rbp
retq
nopl (%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::farming()
void Person::farming()
{
    if(this->underMe=='.')
    {
        int x = this->position[0];
        int y = this->position[1];
        this->working = true;
        food++;
        map[x][y].usable-=25;
        if(map[x][y].usable<=0)
        {
            this->working=false;
            this->underMe='x';
            map[x][y].isRegenerating=true;
            map[x][y].kind = 'x';
        }
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x14(%rax), %eax
cmpl $0x2e, %eax
jne 0x5c9b
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x10(%rbp)
movb $0x1, 0x15(%rax)
leaq 0xd654(%rip), %rax      # 0x1323c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xd648(%rip), %rax      # 0x1323c
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x867f(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
subl $0x19, %ecx
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8656(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jg 0x5c99
movq -0x18(%rbp), %rax
movb $0x0, 0x15(%rax)
movb $0x78, 0x14(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8624(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x8(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8600(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x78, 0x1(%rax)
jmp 0x5c9b
popq %rbp
retq
nopl (%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::mining()
void Person::mining()
{
    if(this->underMe=='^')
    {
        int x = this->position[0];
        int y = this->position[1];
        this->working = true;
        stone++;
        map[x][y].usable-=25;
        if(map[x][y].usable<=0)
        {
            this->working=false;
            this->underMe='x';
            map[x][y].isRegenerating=true;
            map[x][y].kind = 'x';
        }
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x14(%rax), %eax
cmpl $0x5e, %eax
jne 0x5d8b
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x10(%rbp)
movb $0x1, 0x15(%rax)
leaq 0xd568(%rip), %rax      # 0x13240
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xd55c(%rip), %rax      # 0x13240
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x858f(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
subl $0x19, %ecx
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8566(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jg 0x5d89
movq -0x18(%rbp), %rax
movb $0x0, 0x15(%rax)
movb $0x78, 0x14(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8534(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x8(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x8510(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x78, 0x1(%rax)
jmp 0x5d8b
popq %rbp
retq
nopl (%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::move()
void Person::move()
{
    map[this->position[0]][this->position[1]].villagerHere = false;
    //move along the path
    //if we don't have a path we create it
    if(this->pathCoordinates.empty())
    {
        cout << "Arrived, looking for another path" << endl;
        this->pathCoordinates = this->setPath();
    }
    this->position[0] = get<0>(this->pathCoordinates.front());
    this->position[1] = get<1>(this->pathCoordinates.front());
    //remove first element
    this->pathCoordinates.erase (this->pathCoordinates.begin());

    this->underMe = map[this->position[0]][this->position[1]].kind;
    map[this->position[0]][this->position[1]].villagerHere = true;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movslq 0xc(%rdi), %rcx
leaq 0x84d1(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rdi), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0xa(%rax)
addq $0x18, %rdi
callq 0x6100
testb $0x1, %al
jne 0x5dd7
jmp 0x5e20
movq 0x81e2(%rip), %rdi      # 0xdfc0
leaq 0x3313(%rip), %rsi      # 0x90f8
callq 0x2220
movq %rax, %rdi
movq 0x81bc(%rip), %rsi      # 0xdfb0
callq 0x2260
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5ef0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0x55a0
leaq -0x20(%rbp), %rdi
callq 0x55d0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x6160
movq %rax, %rdi
callq 0x6140
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, 0xc(%rdi)
addq $0x18, %rdi
callq 0x6160
movq %rax, %rdi
callq 0x6190
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, 0x10(%rdi)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
addq $0x18, %rdi
callq 0x6220
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6250
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x61b0
movq -0x40(%rbp), %rcx
movq %rax, -0x38(%rbp)
movslq 0xc(%rcx), %rdx
leaq 0x83e3(%rip), %rax      # 0xe280
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movslq 0x10(%rcx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movb 0x1(%rax), %al
movb %al, 0x14(%rcx)
movslq 0xc(%rcx), %rdx
leaq 0x83bd(%rip), %rax      # 0xe280
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movslq 0x10(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0xa(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::setPath()
vector<tuple<int, int>> Person::setPath()
{
    vector<tuple<int, int> > path;
    tuple<int, int> objective = findOneFree(this->preferredTerrain);

    //at the moment, since everything is walkable, move right/left until
    //pos[x] is equal to objective one, then move straight to objective
    int x = this->position[0];
    int y = this->position[1];
    int objectiveX = get<0>(objective);
    int objectiveY = get<1>(objective);
    while(x != objectiveX)
    {
        if(x < objectiveX)
        x++;
        else
        x--;
        path.emplace_back(x,y);
    }
    while(y != objectiveY)
    {
        if(y < objectiveY)
        y++;
        else
        y--;
        path.emplace_back(x,y);
    }

    if(path.empty())
    {
        path.emplace_back(this->position[0], this->position[1]);
    }

    return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6290
movq -0x48(%rbp), %rax
movsbl 0x4(%rax), %esi
leaq -0x1c(%rbp), %rdi
callq 0x8470
jmp 0x5f2f
movq -0x48(%rbp), %rax
movl 0xc(%rax), %ecx
movl %ecx, -0x30(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x6140
movl (%rax), %eax
movl %eax, -0x38(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x6190
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x38(%rbp), %eax
je 0x5fae
movl -0x30(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x5f90
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5f99
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x55d0
jmp 0x6031
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x62b0
jmp 0x5fac
jmp 0x5f5b
jmp 0x5fb0
movl -0x34(%rbp), %eax
cmpl -0x3c(%rbp), %eax
je 0x5fe9
movl -0x34(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x5fcb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5fd4
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x62b0
jmp 0x5fe7
jmp 0x5fb0
movq -0x58(%rbp), %rdi
callq 0x6100
testb $0x1, %al
jne 0x5ff8
jmp 0x6014
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rdx, %rsi
addq $0xc, %rsi
addq $0x10, %rdx
callq 0x62b0
jmp 0x6012
jmp 0x6014
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6027
movq -0x58(%rbp), %rdi
callq 0x55d0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x23b0
nopw (%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::setPreferredTerrain()
char Person::setPreferredTerrain()
{
    char terrain;
    switch(this->sector)
    {
        case 0:
        terrain = '|';
        break;
        case 1:
        terrain = '.';
        break;
        case 2:
        terrain = '-';
        break;
        case 3:
        terrain = '^';
        break;
        default:
        break;
    }

    return terrain;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x6084
movq -0x18(%rbp), %rax
leaq 0x3075(%rip), %rcx      # 0x90d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x7c, -0x9(%rbp)
jmp 0x6086
movb $0x2e, -0x9(%rbp)
jmp 0x6086
movb $0x2d, -0x9(%rbp)
jmp 0x6086
movb $0x5e, -0x9(%rbp)
jmp 0x6086
jmp 0x6086
movb -0x9(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/person.cpp
// Function: Person::work()
void Person::work()
{
    switch(this->sector)
    {
        case 0:
        this->woodcutting();
        break;
        case 1:
        this->farming();
        break;
        case 2:
        this->fishing();
        break;
        case 3:
        this->mining();
        break;
        default:
        break;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x60f0
movq -0x10(%rbp), %rax
leaq 0x302d(%rip), %rcx      # 0x90e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x5ac0
jmp 0x60f2
movq -0x18(%rbp), %rdi
callq 0x5bb0
jmp 0x60f2
movq -0x18(%rbp), %rdi
callq 0x5a70
jmp 0x60f2
movq -0x18(%rbp), %rdi
callq 0x5ca0
jmp 0x60f2
jmp 0x60f2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/societysimulator.cpp
// Function: main
int main()
{
    srand(time(NULL));
    initMap();
    initPeople();
    while(true)
    {
        update();
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2200
movl %eax, %edi
callq 0x2210
callq 0x4f70
callq 0x5420
callq 0x4b10
jmp 0x73f9
// File: gabryatfendor[P]SocietySimulator/src/utilities.cpp
// Function: checkAround(int, int, char)
bool checkAround(int x, int y, char check)
{
	bool isCheckAroundMe = false;

	if(map[x-1][y].kind==check||
	   map[x][y-1].kind==check||
	   map[x][y+1].kind==check||
	   map[x+1][y].kind==check)
	{
		isCheckAroundMe = true;
	}

	return isCheckAroundMe;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x5ffd(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl 0x1(%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x833b
movslq -0x4(%rbp), %rcx
leaq 0x5fcd(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl 0x1(%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x833b
movslq -0x4(%rbp), %rcx
leaq 0x5f9c(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl 0x1(%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x833b
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x5f66(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl 0x1(%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x833f
movb $0x1, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/utilities.cpp
// Function: checkAroundOrigin(int, int, char)
bool checkAroundOrigin(int x, int y, char check)
{
	bool isCheckAroundMe = false;

	if(map[x-1][y].origin==check||
	   map[x][y-1].origin==check||
	   map[x][y+1].origin==check||
	   map[x+1][y].origin==check)
	{
		isCheckAroundMe = true;
	}

	return isCheckAroundMe;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x5f0d(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x8427
movslq -0x4(%rbp), %rcx
leaq 0x5ede(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x8427
movslq -0x4(%rbp), %rcx
leaq 0x5eae(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x8427
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x5e79(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x842b
movb $0x1, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gabryatfendor[P]SocietySimulator/src/utilities.cpp
// Function: findOneFree(char)
tuple<int, int> findOneFree(char kind)
{
	tuple<int, int> free;
	for(int j=0;j<HEIGHT;j++)
		{
		for(int i=0;i<WIDTH;i++)
		{
			if (map[i][j].kind == kind &&
			!map[i][j].villagerAimingHere)
			{
				free = make_tuple(i, j);
				map[i][j].villagerAimingHere = true;
				goto returnme; /*ykes, but from MISRA c++ coding standards
								 this seems to remain the last kind of place in which goto
							     it's still good to use, to exit double for loop*/
			}
		}
	}

	returnme:
	return free;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
callq 0x8580
movl $0x0, -0x10(%rbp)
cmpl $0x14, -0x10(%rbp)
jge 0x856a
movl $0x0, -0x14(%rbp)
cmpl $0x50, -0x14(%rbp)
jge 0x855a
movslq -0x14(%rbp), %rcx
leaq 0x5dc1(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl 0x1(%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x854a
movslq -0x14(%rbp), %rcx
leaq 0x5d95(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0xb(%rax)
jne 0x854a
leaq -0x1c(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x85b0
movq -0x30(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x69e0
movslq -0x14(%rbp), %rcx
leaq 0x5d51(%rip), %rax      # 0xe280
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0xb(%rax)
jmp 0x856c
jmp 0x854c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x84aa
jmp 0x855c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8499
jmp 0x856c
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/rsa_enc.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned char *pubkey = NULL;
	unsigned int size;

	if (argc < 3)
	{
		printf("Usage: enc public_key plaintext\r\n");
		return -1;
	}

	pubkey = (unsigned char *)get_file(argv[1], &size);
	if (pubkey == NULL)
	{
		printf("Failed to open public key\r\n");
		return -1;
	}

	unsigned char data[256] = {0};

	strcpy((char *)data, argv[2]);
	int data_len = strlen((char *)data);
	printf("plaintext %s\r\n", data); 

	unsigned char encrypted[4098]={};



	RSA *rsa = createRSA(pubkey, true);
	int encrypted_length = RSA_public_encrypt(data_len, data, encrypted, rsa, RSA_PKCS1_PADDING);
	if (encrypted_length == -1)
	{
		char err[130];

		ERR_load_crypto_strings();
		ERR_error_string(ERR_get_error(), err);
		printf("ERROR: %s\n", err);
		return -1;
	}
	RSA_free(rsa);

	printf("Encrypted Length %d\r\n", encrypted_length);
	write_file((char *)"file.enc", (char *)encrypted, encrypted_length);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x11c0, %rsp           # imm = 0x11C0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x1531
leaq 0xb57(%rip), %rdi       # 0x2075
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1692
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1350
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1567
leaq 0xb43(%rip), %rdi       # 0x2097
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1692
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10b0
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10e0
leaq -0x120(%rbp), %rdi
callq 0x1090
movl %eax, -0x124(%rbp)
leaq -0x120(%rbp), %rsi
leaq 0xb05(%rip), %rdi       # 0x20b3
movb $0x0, %al
callq 0x1050
leaq -0x1130(%rbp), %rdi
xorl %esi, %esi
movl $0x1002, %edx           # imm = 0x1002
callq 0x10b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1290
movq %rax, -0x1138(%rbp)
movl -0x124(%rbp), %edi
leaq -0x120(%rbp), %rsi
leaq -0x1130(%rbp), %rdx
movq -0x1138(%rbp), %rcx
movl $0x1, %r8d
callq 0x10c0
movl %eax, -0x113c(%rbp)
cmpl $-0x1, -0x113c(%rbp)
jne 0x1652
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
callq 0x1140
movq %rax, %rdi
leaq -0x11c0(%rbp), %rsi
callq 0x1070
leaq -0x11c0(%rbp), %rsi
leaq 0xa80(%rip), %rdi       # 0x20c2
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1692
movq -0x1138(%rbp), %rdi
callq 0x1110
movl -0x113c(%rbp), %esi
leaq 0xa62(%rip), %rdi       # 0x20cd
movb $0x0, %al
callq 0x1050
leaq -0x1130(%rbp), %rsi
movl -0x113c(%rbp), %edx
leaq 0xa5d(%rip), %rdi       # 0x20e3
callq 0x1450
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x11c0, %rsp           # imm = 0x11C0
popq %rbp
retq
// File: marcellapantarotto[P]pseudoSO/main.cpp
// Function: main
int main(int argq, char* argv[]) {
	if(argq < 2) {
		cerr << "\a Not enough number of arguments!" << endl;
		cerr << "\a Command line: ./run <input.txt>" << endl;
		return -1;
	}

	char* input;
	input = argv[1];

	Scheduler sched;
	InitializeSemaphores();
	sched.readFile(input);
	sched.simulation();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x251f
movq 0xcb1a(%rip), %rdi      # 0xeff0
leaq 0x7b27(%rip), %rsi      # 0xa004
callq 0x2170
movq %rax, %rdi
movq 0xcad4(%rip), %rsi      # 0xefc0
callq 0x2190
movq 0xcaf8(%rip), %rdi      # 0xeff0
leaq 0x7b27(%rip), %rsi      # 0xa026
callq 0x2170
movq %rax, %rdi
movq 0xcab2(%rip), %rsi      # 0xefc0
callq 0x2190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2628
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x2640
callq 0x4190
jmp 0x253e
movq -0x18(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x229(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x2290
movq -0x240(%rbp), %rsi
movq -0x238(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x21e0
jmp 0x2578
leaq -0x1f8(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x4f60
jmp 0x258d
leaq -0x228(%rbp), %rdi
callq 0x20e0
leaq -0x229(%rbp), %rdi
callq 0x21a0
leaq -0x1f8(%rbp), %rdi
callq 0x5390
jmp 0x25b3
movl $0x0, -0x4(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x2750
jmp 0x2628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
jmp 0x261a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
jmp 0x260e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x20e0
leaq -0x229(%rbp), %rdi
callq 0x21a0
leaq -0x1f8(%rbp), %rdi
callq 0x2750
jmp 0x2634
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x200(%rbp), %rdi
callq 0x2280
// File: marcellapantarotto[P]pseudoSO/process.cpp
// Function: operator<<(std::ostream&, Process const&)
ostream& operator<<(ostream& pl,const Process& punit) {
	pl << "\tPID: " << punit.pid << '\n';
	pl << "\tPriority: " << punit.priority << '\n';
	pl << "\tInitialization Time: " << punit.initTime << '\n';
	pl << "\tExecuting Time: " << punit.processTime << '\n';
	pl << "\tMemory Offset: " << punit.memoryOffset << '\n';
	pl << "\tBlocks Amount " << punit.amoutBlocks << '\n';
	pl << "\tPrinters: " << punit.usePrinter << '\n';
	pl << "\tScanners: " << punit.usescan << '\n';
	pl << "\tModems: " << punit.useModem << '\n';
	pl << "\tSATA: " << punit.useSATA;
	return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6b2d(%rip), %rsi      # 0xa048
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x2270
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6b09(%rip), %rsi      # 0xa04f
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2270
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6ae9(%rip), %rsi      # 0xa05b
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2270
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6ad4(%rip), %rsi      # 0xa072
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x2270
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6aba(%rip), %rsi      # 0xa084
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2270
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6a9f(%rip), %rsi      # 0xa095
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x2270
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6a83(%rip), %rsi      # 0xa0a5
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6a5e(%rip), %rsi      # 0xa0b1
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movb 0x19(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6a39(%rip), %rsi      # 0xa0bd
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movb 0x1a(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x6a12(%rip), %rsi      # 0xa0c7
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movb 0x1b(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22a0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: marcellapantarotto[P]pseudoSO/process.cpp
// Function: Process::gives()
void Process::gives() {
	int resource, hit;

	freeResource(resource);
	resource = usesResource();
	hit = blockResource(resource);
	if(hit) {
		blockedResource = resource;
	}
	processTime -= QUANTUM;		// cálculo do tempo
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x42a0
movq -0x18(%rbp), %rdi
callq 0x39f0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x41f0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x39d3
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marcellapantarotto[P]pseudoSO/process.cpp
// Function: Process::usesResource()
int Process::usesResource() {
	srand(time(NULL));		// cada vez cria uma sequência nova
	int use = existsResource();
	if(use) {
		use = 0;
		if(rand()%100 < PERCENTAGE) {
			int redo;
			while(redo) {
				redo = 0;
				use = rand()%4 + 1;
				if (use == 1)
						if(!getScanner()) redo = 1;
				else if(use == 2)
						if(!getPrinter()) redo = 1;
				else if(use == 3)
						if(!getModem()) redo = 1;
				else if(use == 4)
						if(!getSata()) redo = 1;
			};
		}
	}
	return use;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x3b40
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3af2
movl $0x0, -0xc(%rbp)
callq 0x2060
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x65, %edx
jge 0x3af0
jmp 0x3a49
cmpl $0x0, -0x10(%rbp)
je 0x3aee
movl $0x0, -0x10(%rbp)
callq 0x2060
movl $0x4, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x3ae9
movq -0x18(%rbp), %rdi
callq 0x3850
testb $0x1, %al
jne 0x3a89
movl $0x1, -0x10(%rbp)
jmp 0x3ae7
cmpl $0x2, -0xc(%rbp)
jne 0x3ae5
movq -0x18(%rbp), %rdi
callq 0x3890
testb $0x1, %al
jne 0x3aa5
movl $0x1, -0x10(%rbp)
jmp 0x3ae3
cmpl $0x3, -0xc(%rbp)
jne 0x3ae1
movq -0x18(%rbp), %rdi
callq 0x38d0
testb $0x1, %al
jne 0x3ac1
movl $0x1, -0x10(%rbp)
jmp 0x3adf
cmpl $0x4, -0xc(%rbp)
jne 0x3add
movq -0x18(%rbp), %rdi
callq 0x3910
testb $0x1, %al
jne 0x3adb
movl $0x1, -0x10(%rbp)
jmp 0x3add
jmp 0x3adf
jmp 0x3ae1
jmp 0x3ae3
jmp 0x3ae5
jmp 0x3ae7
jmp 0x3ae9
jmp 0x3a49
jmp 0x3af0
jmp 0x3af2
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: marcellapantarotto[P]pseudoSO/process.cpp
// Function: Process::existsResource()
int Process::existsResource() {
	int is = WITHOUT_RESOURCES;
	if(getScanner() || getPrinter() || getModem() || getSata()) {
		is = WITH_RESOURCES;
	}
	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x3850
testb $0x1, %al
jne 0x3b8d
movq -0x18(%rbp), %rdi
callq 0x3890
testb $0x1, %al
jne 0x3b8d
movq -0x18(%rbp), %rdi
callq 0x38d0
testb $0x1, %al
jne 0x3b8d
movq -0x18(%rbp), %rdi
callq 0x3910
testb $0x1, %al
jne 0x3b8d
jmp 0x3b94
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: marcellapantarotto[P]pseudoSO/process.cpp
// Function: Process::inMemory()
bool Process::inMemory() {
	bool inside = false;
	if(this->memoryOffset != -1) {
		inside = true;
	}
	return inside;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0x9(%rbp)
cmpl $-0x1, 0xc(%rax)
je 0x3bba
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marcellapantarotto[P]pseudoSO/memory.cpp
// Function: Memory::Memory()
Memory::Memory(){
	int i=0;
	while(i < MAX_MEM){
		memoir[i] = 0;		// zera memória
		i++;
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3f40
movl $0x0, -0xc(%rbp)
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
jge 0x3c69
movq -0x28(%rbp), %rsi
movslq -0xc(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x3f60
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3fa0
leaq -0x20(%rbp), %rdi
callq 0x4010
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c30
addq $0x30, %rsp
popq %rbp
retq
nop