LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: arisKoutsou[P]oopproj/./src/livings/Monster.cpp
// Function: Monster::applyNerf(int, double, Monster::Type)
void Monster :: applyNerf(int duration, double amount, Type nerfType) {
  Nerf newNerf(duration, amount, nerfType);
  nerfs.push_back(newNerf);
  switch (nerfType) {
  case ICE: {
    minDamage *= 1.0 - amount;
    maxDamage *= 1.0 - amount;
    break;  
  }
  case FIRE: {
    damageReductionFactor -= amount;
    damageReductionFactor = (damageReductionFactor < 0.0) ? 0.0 : damageReductionFactor;
    break;    
  }
  case LIGHT: {
    dodge -= amount;
    dodge = (dodge < 0.0) ? 0.0 : dodge;
    break;
  }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movl -0x1c(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x29b50
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x60, %rdi
callq 0x2a6c0
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x2a452
jmp 0x2a3f4
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x2a40f
jmp 0x2a3fe
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x2a49b
jmp 0x2a4e2
movq -0x50(%rbp), %rax
movsd 0x48fd(%rip), %xmm1     # 0x2ed18
subsd -0x18(%rbp), %xmm1
cvtsi2sdl 0x44(%rax), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x44(%rax)
movsd 0x48e0(%rip), %xmm1     # 0x2ed18
subsd -0x18(%rbp), %xmm1
cvtsi2sdl 0x48(%rax), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x48(%rax)
jmp 0x2a4e2
movq -0x50(%rbp), %rax
movsd -0x18(%rbp), %xmm1
movsd 0x50(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rax)
xorps %xmm0, %xmm0
ucomisd 0x50(%rax), %xmm0
jbe 0x2a47d
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
jmp 0x2a48b
movq -0x50(%rbp), %rax
movsd 0x50(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x50(%rbp), %rax
movsd -0x58(%rbp), %xmm0
movsd %xmm0, 0x50(%rax)
jmp 0x2a4e2
movq -0x50(%rbp), %rax
movsd -0x18(%rbp), %xmm1
movsd 0x58(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rax)
xorps %xmm0, %xmm0
ucomisd 0x58(%rax), %xmm0
jbe 0x2a4c6
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
jmp 0x2a4d4
movq -0x50(%rbp), %rax
movsd 0x58(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x50(%rbp), %rax
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x58(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/livings/Monster.cpp
// Function: Monster::updateNerfs()
void Monster :: updateNerfs() {
  list<Nerf> :: iterator it = nerfs.begin();
  for ( ; it != nerfs.end(); ++it) {
    (*it).roundPassed();
    if ((*it).getDuration() == -1) {
      switch ((*it).getNerfType()) {
      case ICE: {
	minDamage /= 1.0 - (*it).getNerfAmount();
	maxDamage /= 1.0 - (*it).getNerfAmount();
	break;
      }
      case FIRE: {
        damageReductionFactor += (*it).getNerfAmount();
	break;
      }
      case LIGHT: {
	dodge += (*it).getNerfAmount();
	break;
      }
      }
      list<Nerf> :: iterator tmp = it++;
      nerfs.erase(tmp);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x60, %rdi
callq 0x2a700
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
callq 0x2a760
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2a730
testb $0x1, %al
jne 0x2a538
jmp 0x2a68e
leaq -0x10(%rbp), %rdi
callq 0x2a790
movq %rax, %rdi
callq 0x29bd0
leaq -0x10(%rbp), %rdi
callq 0x2a790
movq %rax, %rdi
callq 0x29b80
cmpl $-0x1, %eax
jne 0x2a67e
leaq -0x10(%rbp), %rdi
callq 0x2a790
movq %rax, %rdi
callq 0x29bb0
movl %eax, %ecx
movl %ecx, -0x3c(%rbp)
testl %eax, %eax
je 0x2a602
jmp 0x2a583
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x2a59e
jmp 0x2a58d
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x2a623
jmp 0x2a642
leaq -0x10(%rbp), %rdi
callq 0x2a790
movq %rax, %rdi
callq 0x29b90
movq -0x38(%rbp), %rax
movsd 0x475d(%rip), %xmm1     # 0x2ed18
subsd %xmm0, %xmm1
cvtsi2sdl 0x44(%rax), %xmm0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x44(%rax)
leaq -0x10(%rbp), %rdi
callq 0x2a790
movq %rax, %rdi
callq 0x29b90
movq -0x38(%rbp), %rax
movsd 0x472c(%rip), %xmm1     # 0x2ed18
subsd %xmm0, %xmm1
cvtsi2sdl 0x48(%rax), %xmm0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x48(%rax)
jmp 0x2a642
leaq -0x10(%rbp), %rdi
callq 0x2a790
movq %rax, %rdi
callq 0x29b90
movq -0x38(%rbp), %rax
addsd 0x50(%rax), %xmm0
movsd %xmm0, 0x50(%rax)
jmp 0x2a642
leaq -0x10(%rbp), %rdi
callq 0x2a790
movq %rax, %rdi
callq 0x29b90
movq -0x38(%rbp), %rax
addsd 0x58(%rax), %xmm0
movsd %xmm0, 0x58(%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2a7b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
addq $0x60, %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2a830
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2a7e0
movq %rax, -0x30(%rbp)
jmp 0x2a680
leaq -0x10(%rbp), %rdi
callq 0x2a850
jmp 0x2a511
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: arisKoutsou[P]oopproj/./src/livings/heroes/Sorcerer.cpp
// Function: Sorcerer::operator==(Sorcerer const&) const
bool Sorcerer :: operator==(const Sorcerer& rValue) const {
  bool sameHeros;
  bool sameAgilityBonus;
  bool sameDexterityBonus;

  sameHeros = Hero::operator==(rValue);
  sameAgilityBonus = (this->agilityBonus == rValue.agilityBonus)
    ? true : false;
  sameDexterityBonus = (this->dexterityBonus == rValue.dexterityBonus)
    ? true : false;

  return (sameHeros && sameAgilityBonus && sameDexterityBonus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x23390
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movsd 0x158(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x158(%rcx), %xmm1
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
andb %dl, %cl
movb %cl, -0x12(%rbp)
movsd 0x160(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x160(%rax), %xmm1
ucomisd %xmm1, %xmm0
setnp %cl
sete %al
andb %cl, %al
negb %al
andb $0x1, %al
movb %al, -0x13(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x14(%rbp)
je 0x2b640
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x14(%rbp)
je 0x2b640
movb -0x13(%rbp), %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/livings/heroes/Warrior.cpp
// Function: Warrior::operator==(Warrior const&) const
bool Warrior :: operator==(const Warrior& rValue) const {
  bool sameHeros;
  bool sameAgilityBonus;
  bool sameStrengthBonus;

  sameHeros = Hero::operator==(rValue);
  sameAgilityBonus = (this->agilityBonus == rValue.agilityBonus)
    ? true : false;
  sameStrengthBonus = (this->strengthBonus == rValue.strengthBonus)
    ? true : false;

  return (sameHeros && sameAgilityBonus && sameStrengthBonus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x23390
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movsd 0x158(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x158(%rcx), %xmm1
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
andb %dl, %cl
movb %cl, -0x12(%rbp)
movsd 0x160(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x160(%rax), %xmm1
ucomisd %xmm1, %xmm0
setnp %cl
sete %al
andb %cl, %al
negb %al
andb $0x1, %al
movb %al, -0x13(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x14(%rbp)
je 0x2b900
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x14(%rbp)
je 0x2b900
movb -0x13(%rbp), %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/livings/heroes/Paladin.cpp
// Function: Paladin::operator==(Paladin const&) const
bool Paladin :: operator==(const Paladin& rValue) const {
  bool sameHeros;
  bool sameStrengthBonus;
  bool sameDexterityBonus;

  sameHeros = Hero::operator==(rValue);
  sameStrengthBonus = (this->strengthBonus == rValue.strengthBonus)
    ? true : false;
  sameDexterityBonus = (this->dexterityBonus == rValue.dexterityBonus)
    ? true : false;

  return (sameHeros && sameStrengthBonus && sameDexterityBonus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x23390
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movsd 0x158(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x158(%rcx), %xmm1
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
andb %dl, %cl
movb %cl, -0x12(%rbp)
movsd 0x160(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x160(%rax), %xmm1
ucomisd %xmm1, %xmm0
setnp %cl
sete %al
andb %cl, %al
negb %al
andb $0x1, %al
movb %al, -0x13(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x14(%rbp)
je 0x2bbc0
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x14(%rbp)
je 0x2bbc0
movb -0x13(%rbp), %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/items/Weapon.cpp
// Function: Weapon::operator==(Weapon const&) const
bool Weapon :: operator==(const Weapon& rValue) const {
  bool sameItems;
  bool sameDamage;
  bool sameRequiresBothHands;

  sameItems = Item::operator==(rValue);
  sameDamage = (this->damage == rValue.damage) ? true : false;
  sameRequiresBothHands = (this->requiresBothHands == rValue.requiresBothHands)
                           ? true : false;

  return (sameItems && sameDamage && sameRequiresBothHands);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2d5b0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movl 0x40(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x40(%rdx), %edx
subl %edx, %ecx
sete -0x12(%rbp)
movzbl 0x44(%rax), %eax
andl $0x1, %eax
movq -0x10(%rbp), %rcx
movzbl 0x44(%rcx), %ecx
andl $0x1, %ecx
subl %ecx, %eax
sete %al
negb %al
andb $0x1, %al
movb %al, -0x13(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x14(%rbp)
je 0x2c334
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x14(%rbp)
je 0x2c334
movb -0x13(%rbp), %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: arisKoutsou[P]oopproj/./src/items/Armor.cpp
// Function: Armor::operator==(Armor const&) const
bool Armor :: operator==(const Armor& rValue) const {
  bool sameItems;
  bool sameReduceDamageTakenBy;

  sameItems = Item::operator==(rValue);
  sameReduceDamageTakenBy =
    (this->reduceDamageTakenBy == rValue.reduceDamageTakenBy)
    ? true : false;

  return (sameItems && sameReduceDamageTakenBy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2d5b0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movsd 0x40(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm1
ucomisd %xmm1, %xmm0
setnp %cl
sete %al
andb %cl, %al
negb %al
andb $0x1, %al
movb %al, -0x12(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x13(%rbp)
je 0x2c97c
movb -0x12(%rbp), %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/items/Potion.cpp
// Function: Potion::operator==(Potion const&) const
bool Potion :: operator==(const Potion& rValue) const {
  bool sameItems;
  bool sameStrengthBoost;
  bool sameDexterityBoost;
  bool sameAgilityBoost;

  sameItems = Item::operator==(rValue);

  sameStrengthBoost = (this->strengthBoost == rValue.strengthBoost)
                       ? true : false;

  sameDexterityBoost = (this->dexterityBoost == rValue.dexterityBoost)
                        ? true : false;

  sameAgilityBoost = (this->agilityBoost == rValue.agilityBoost)
                      ? true : false;

  return (sameStrengthBoost &&
	  sameDexterityBoost &&
	  sameAgilityBoost &&
	  sameItems);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2d5b0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movsd 0x40(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x40(%rcx), %xmm1
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
andb %dl, %cl
movb %cl, -0x12(%rbp)
movsd 0x48(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x48(%rcx), %xmm1
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
andb %dl, %cl
movb %cl, -0x13(%rbp)
movsd 0x50(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x50(%rax), %xmm1
ucomisd %xmm1, %xmm0
setnp %cl
sete %al
andb %cl, %al
negb %al
andb $0x1, %al
movb %al, -0x14(%rbp)
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x15(%rbp)
je 0x2d3dc
xorl %eax, %eax
testb $0x1, -0x13(%rbp)
movb %al, -0x15(%rbp)
je 0x2d3dc
xorl %eax, %eax
testb $0x1, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x2d3dc
movb -0x11(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/items/Item.cpp
// Function: Item::operator==(Item const&) const
bool Item :: operator==(const Item& rValue) const {
  bool sameName;
  bool sameValue;
  bool sameSellingPrice;
  bool sameMinLevel;

  sameName = (this->name == rValue.name) ? true : false;
  sameValue = (this->value == rValue.value) ? true : false;
  sameSellingPrice = (this->sellFor == rValue.sellFor) ? true : false;
  sameMinLevel = (this->minLevel == rValue.minLevel) ? true : false;

  return (sameName && sameValue && sameSellingPrice && sameMinLevel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x7e80
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x28(%rdx), %edx
subl %edx, %ecx
sete -0x12(%rbp)
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x2c(%rdx), %edx
subl %edx, %ecx
sete -0x13(%rbp)
movl 0x30(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %ecx
subl %ecx, %eax
sete %al
negb %al
andb $0x1, %al
movb %al, -0x14(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x15(%rbp)
je 0x2d63f
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x15(%rbp)
je 0x2d63f
xorl %eax, %eax
testb $0x1, -0x13(%rbp)
movb %al, -0x15(%rbp)
je 0x2d63f
movb -0x14(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::gameLoop()
void Engine::gameLoop() {
    Engine::GetInput();
    Engine::checkEnding();
    Engine::makeMove();
    Engine::checkEnding();
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4e80
movq -0x10(%rbp), %rdi
callq 0x52c0
movq -0x10(%rbp), %rdi
callq 0x39f0
movq -0x10(%rbp), %rdi
callq 0x52c0
callq 0x33f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::checkEnding()
void Engine::checkEnding() {
    if(this->winner){
        refresh();
        sleep(1);
        clear();
        move(0,0);
        addstr("YOU ARE THE WINNER\n");
        refresh();
        sleep(1);
        this->gameEnded = true;
    }
    else if(!this->poterAlive){
        refresh();
        sleep(1);
        clear();
        move(0,0);
        addstr("YOU LOST :(\n");
        refresh();
        sleep(1);
        this->gameEnded = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x19d(%rax)
je 0x5331
callq 0x33f0
movl $0x1, %edi
callq 0x31a0
callq 0x3420
xorl %esi, %esi
movl %esi, %edi
callq 0x3190
movq 0xeccf(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
leaq 0x8d81(%rip), %rsi      # 0xe08c
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30c0
callq 0x33f0
movl $0x1, %edi
callq 0x31a0
movq -0x10(%rbp), %rax
movb $0x1, 0x19e(%rax)
jmp 0x5392
movq -0x10(%rbp), %rax
testb $0x1, 0x19c(%rax)
jne 0x5390
callq 0x33f0
movl $0x1, %edi
callq 0x31a0
callq 0x3420
xorl %esi, %esi
movl %esi, %edi
callq 0x3190
movq 0xec6e(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
leaq 0x8d34(%rip), %rsi      # 0xe0a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30c0
callq 0x33f0
movl $0x1, %edi
callq 0x31a0
movq -0x10(%rbp), %rax
movb $0x1, 0x19e(%rax)
jmp 0x5392
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::setAvailablePoints()
void Engine::setAvailablePoints() {
    this->available_points.clear();
    for(int y = 0; y<(int) maze.size();y++){
        for(int x=0;x<(int) maze[y].size();x++){
            if(maze[y][x] == DIADROMOS){
                Point p1(x,y);
                available_points.push_back(p1);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x6220
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x6240
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5703
movl $0x0, -0x10(%rbp)
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x40(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x58b0
movq %rax, %rdi
callq 0x6270
movq %rax, %rcx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x56f3
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x58b0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x58d0
cmpl $0x2, (%rax)
jne 0x56e3
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xa8d0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rdi
callq 0x5a80
jmp 0x56c1
leaq -0x20(%rbp), %rdi
callq 0xa900
jmp 0x56e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa900
jmp 0x5709
jmp 0x56e5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5658
jmp 0x56f5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5634
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::updateHG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Engine::updateHG(const string& filename) {

    int score = cntEatenGems * 10;
    if(winner)
        score += 10;
    hg<<this->username<< score;

    ofstream file(filename, ios::binary | ios::out);

    hg.save(file);

    file.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
imull $0xa, 0x198(%rax), %ecx
movl %ecx, -0x14(%rbp)
testb $0x1, 0x19d(%rax)
je 0x575a
movl -0x14(%rbp), %eax
addl $0xa, %eax
movl %eax, -0x14(%rbp)
movq -0x250(%rbp), %rsi
movq %rsi, %rax
addq $0x130, %rax            # imm = 0x130
movq %rax, -0x268(%rbp)
addq $0x178, %rsi            # imm = 0x178
leaq -0x38(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x3110
movq -0x268(%rbp), %rdi
movq -0x260(%rbp), %rsi
callq 0xc850
movq %rax, -0x258(%rbp)
jmp 0x57a4
movq -0x258(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc910
jmp 0x57b5
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x10(%rbp), %rax
movq %rax, -0x278(%rbp)
movl $0x4, %edi
movl $0x10, %esi
callq 0x5d80
movq -0x278(%rbp), %rsi
movl %eax, %edx
leaq -0x248(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x3470
movq -0x250(%rbp), %rdi
movq -0x270(%rbp), %rsi
addq $0x130, %rdi            # imm = 0x130
callq 0xc680
jmp 0x5810
leaq -0x248(%rbp), %rdi
callq 0x3330
jmp 0x581e
leaq -0x248(%rbp), %rdi
callq 0x3350
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x5862
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x3350
movq -0x40(%rbp), %rdi
callq 0x3430
nopl (%rax,%rax)
// File: Teris45[P]Maze-Game/Living.cpp
// Function: Point::euclidean(Point const&)
float Point:: euclidean(const Point &point){
    int x2 = this->x - point.x;
    int y2 = this->y - point.y;

    x2 = x2*x2;
    y2 = y2*y2;

    int distance = x2 + y2;

    return sqrt(distance);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rdx
subl 0x8(%rdx), %ecx
movl %ecx, -0x14(%rbp)
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0xabe0
cvtsd2ss %xmm0, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Teris45[P]Maze-Game/Living.cpp
// Function: Living::setPoint(std::vector<Point, std::allocator<Point>>&)
void Living::setPoint(vector<Point> &starting) {
    srand(time(nullptr));

    int size = (int) starting.size();
    int rand_int = rand()%size;

    this->inMap.setX(starting[rand_int].getX());
    this->inMap.setY(starting[rand_int].getY());

    starting.erase(starting.begin()+rand_int);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3210
movl %eax, %edi
callq 0x3220
movq -0x10(%rbp), %rdi
callq 0x7ac0
movl %eax, -0x14(%rbp)
callq 0x3080
cltd
idivl -0x14(%rbp)
movq -0x50(%rbp), %rax
movl %edx, -0x18(%rbp)
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xac00
movq %rax, %rdi
callq 0xa570
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0xa550
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xac00
movq %rax, %rdi
callq 0xa5b0
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xa590
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x79c0
movq %rax, -0x30(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xac90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xacd0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xac20
movq %rax, -0x38(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::Move(Traal, Poter&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
Point MyMoving::Move(Traal monster, Poter &poter, vector<vector<int>> &maze){
    vector<Point> possibleMoveSet;


    Point p = monster.getPoint();
    mvaddch(p.getY(),p.getX(),' ');

    possibleMoveSet = get_possible_moveset(p,maze);

    possibleMoveSet.push_back(p);

    p = getShortestEuclidean(poter,possibleMoveSet);

    mvaddch(p.getY(),p.getX(),'T');


    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5910
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movb $0x0, -0x39(%rbp)
callq 0xa840
jmp 0xb18f
movq -0x88(%rbp), %rdi
movq 0x8e33(%rip), %rax      # 0x13fd0
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
callq 0xa5b0
movl %eax, -0x94(%rbp)
jmp 0xb1b4
movq -0x88(%rbp), %rdi
callq 0xa570
movl %eax, -0xa4(%rbp)
jmp 0xb1c8
movl -0xa4(%rbp), %edx
movl -0x94(%rbp), %esi
movq -0xa0(%rbp), %rdi
callq 0x3260
movl %eax, -0xa8(%rbp)
jmp 0xb1e8
movl -0xa8(%rbp), %eax
cmpl $-0x1, %eax
jne 0xb1f5
jmp 0xb20d
movq 0x8dd4(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x30a0
jmp 0xb20b
jmp 0xb20d
movq -0x88(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0xb380
jmp 0xb223
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0xbfc0
movq -0xb8(%rbp), %rdi
callq 0x5da0
movq -0xb0(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x5a80
jmp 0xb25f
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0xb670
jmp 0xb272
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xd0(%rbp)
callq 0xb0e0
movq -0xd0(%rbp), %rdi
callq 0xa900
movq -0x88(%rbp), %rdi
movq 0x8d2d(%rip), %rax      # 0x13fd0
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
callq 0xa5b0
movl %eax, -0xbc(%rbp)
jmp 0xb2ba
movq -0x88(%rbp), %rdi
callq 0xa570
movl %eax, -0xd4(%rbp)
jmp 0xb2ce
movl -0xd4(%rbp), %edx
movl -0xbc(%rbp), %esi
movq -0xc8(%rbp), %rdi
callq 0x3260
movl %eax, -0xd8(%rbp)
jmp 0xb2ee
movl -0xd8(%rbp), %eax
cmpl $-0x1, %eax
jne 0xb2fb
jmp 0xb313
movq 0x8cce(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movl $0x54, %esi
callq 0x30a0
jmp 0xb311
jmp 0xb313
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0xb353
jmp 0xb347
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb36c
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xa900
jmp 0xb36c
movq -0x88(%rbp), %rdi
callq 0xa900
leaq -0x38(%rbp), %rdi
callq 0x5da0
movq -0x90(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5da0
movq -0x48(%rbp), %rdi
callq 0x3430
nop
// File: Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::Move(Goblin&, Poter&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
Point MyMoving::Move(Goblin &goblin, Poter &poter, const vector<vector<int>> &maze) {
    vector<Point> possibleMoveSet;


    Point p = goblin.getPoint();
    mvaddch(p.getY(),p.getX(),' ');

    possibleMoveSet = get_possible_moveset(p,maze);

    possibleMoveSet.push_back(p);

    p = getShortestEuclidean(poter,possibleMoveSet);

    mvaddch(p.getY(),p.getX(),'G');


    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5910
movq -0x80(%rbp), %rdi
movb $0x0, -0x39(%rbp)
movq -0x10(%rbp), %rsi
callq 0xa840
jmp 0xb935
movq -0x80(%rbp), %rdi
movq 0x8690(%rip), %rax      # 0x13fd0
movq (%rax), %rax
movq %rax, -0x98(%rbp)
callq 0xa5b0
movl %eax, -0x8c(%rbp)
jmp 0xb957
movq -0x80(%rbp), %rdi
callq 0xa570
movl %eax, -0x9c(%rbp)
jmp 0xb968
movl -0x9c(%rbp), %edx
movl -0x8c(%rbp), %esi
movq -0x98(%rbp), %rdi
callq 0x3260
movl %eax, -0xa0(%rbp)
jmp 0xb988
movl -0xa0(%rbp), %eax
cmpl $-0x1, %eax
jne 0xb995
jmp 0xb9ad
movq 0x8634(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x30a0
jmp 0xb9ab
jmp 0xb9ad
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0xb380
jmp 0xb9c0
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0xbfc0
movq -0xb0(%rbp), %rdi
callq 0x5da0
movq -0xa8(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x5a80
jmp 0xb9f9
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0xb670
jmp 0xba0c
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
callq 0xb0e0
movq -0xc8(%rbp), %rdi
callq 0xa900
movq -0x80(%rbp), %rdi
movq 0x8599(%rip), %rax      # 0x13fd0
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
callq 0xa5b0
movl %eax, -0xb4(%rbp)
jmp 0xba4e
movq -0x80(%rbp), %rdi
callq 0xa570
movl %eax, -0xcc(%rbp)
jmp 0xba5f
movl -0xcc(%rbp), %edx
movl -0xb4(%rbp), %esi
movq -0xc0(%rbp), %rdi
callq 0x3260
movl %eax, -0xd0(%rbp)
jmp 0xba7f
movl -0xd0(%rbp), %eax
cmpl $-0x1, %eax
jne 0xba8c
jmp 0xbaa4
movq 0x853d(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movl $0x47, %esi
callq 0x30a0
jmp 0xbaa2
jmp 0xbaa4
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0xbade
jmp 0xbad5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xbaf7
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xa900
jmp 0xbaf7
movq -0x80(%rbp), %rdi
callq 0xa900
leaq -0x38(%rbp), %rdi
callq 0x5da0
movq -0x88(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5da0
movq -0x48(%rbp), %rdi
callq 0x3430
nopl (%rax)
// File: Teris45[P]Maze-Game/Gem.cpp
// Function: Gem::setPoint(std::vector<Point, std::allocator<Point>>&)
void Gem::setPoint(vector<Point> &startingPoints) {
    srand(time(nullptr));

    int size = (int) startingPoints.size();
    int rand_int = rand()%size;

    this->inMap.setX(startingPoints[rand_int].getX());
    this->inMap.setY(startingPoints[rand_int].getY());


    startingPoints.erase(startingPoints.begin()+0);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3210
movl %eax, %edi
callq 0x3220
movq -0x10(%rbp), %rdi
callq 0x7ac0
movl %eax, -0x14(%rbp)
callq 0x3080
cltd
idivl -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xac00
movq %rax, %rdi
callq 0xa570
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xa550
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xac00
movq %rax, %rdi
callq 0xa5b0
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xa590
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x79c0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xacd0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xac20
movq %rax, -0x38(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::save(std::basic_ofstream<char, std::char_traits<char>>&)
void HighScore::save(ofstream &of) {
    for(int i=0;i<5;i++){
        if(score[i]!=-1){
            name[i].save(of);
            string str = to_string(score[i]);
            char *writeable = new char[str.size() + 1];
            copy(str.begin(),str.end(),writeable);
            writeable[str.size()] = '\0';
            of.write(writeable,sizeof(int));

        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0xc7ac
movq -0x68(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $-0x1, 0x34(%rax,%rcx,4)
je 0xc79c
movq -0x68(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,2), %rdi
movq -0x10(%rbp), %rsi
callq 0xc4f0
movq -0x68(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xcd50
movq -0x78(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
incq %rdi
callq 0x3030
movq %rax, -0x70(%rbp)
jmp 0xc70b
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x31e0
movq -0x80(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x3140
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rdx
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xce70
jmp 0xc744
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
movq %rax, %rcx
movq -0x88(%rbp), %rax
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x4, %edx
callq 0x3300
jmp 0xc77a
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0xc79c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0xc7b5
jmp 0xc79e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc6a2
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3430
nop
// File: Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::load(std::basic_ifstream<char, std::char_traits<char>>&)
void HighScore::load(ifstream &inf) {
    int i=0;
    while (inf.eof()){
        name[i].load(inf);
        char *val = nullptr;
        inf.read(val,sizeof(int));
        this->score[i] = atoi(val);
        i++;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3450
testb $0x1, %al
jne 0xc7f5
jmp 0xc849
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0xa, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xc4c0
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x32f0
movq -0x20(%rbp), %rdi
callq 0x33a0
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x34(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc7df
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::operator<<(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
HighScore &HighScore::operator<<(string myname) {
    for(int i=0;i<4;i++){
        name[i+1] = name[i];
    }

    name[0].setname(std::move(myname));
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xc8b4
movq -0x50(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0xa, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl -0x14(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0xa, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movw 0x8(%rcx), %cx
movw %cx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc873
movq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3150
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xc520
jmp 0xc8d4
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::operator<<(int)
HighScore &HighScore::operator<<(int myscore) {
    for(int i=0;i<4;i++){
        score[i+1] = score[i];
    }
    score[0] = myscore;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xc954
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %edx
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, 0x34(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc92a
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x34(%rax)
popq %rbp
retq
// File: hey-yahei[P]ConvNet/tests/test_mymodel.cpp
// Function: test_mymodel()
void test_mymodel() {
	float* input = (float*)malloc(sizeof(float) * 1 * 3 * 224 * 224);
	LoadFromFile("../models/my_testmodel/input.dat", (char*)input);

	Model model;
	float* output;
	output = model.Run(input);

	int out_shape[4];
	unsigned long size;
	model.GetOutputShape(out_shape);
	// size = out_shape[0] * out_shape[1] * out_shape[2] * out_shape[3];
	size = out_shape[0] * out_shape[1];
	SaveToFile("../outputs/my_testmodel/output.dat", (char*)output, size * sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x93000, %edi          # imm = 0x93000
callq 0x22e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x9950(%rip), %rdi      # 0xc004
xorl %eax, %eax
movl %eax, %edx
callq 0x7990
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2780
movq -0x88(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2c20
movq %rax, -0x80(%rbp)
jmp 0x26e3
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2ea0
jmp 0x26fa
movl -0x70(%rbp), %eax
movl -0x6c(%rbp), %ecx
imull %ecx, %eax
cltq
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rsi
movq -0x78(%rbp), %rdx
shlq $0x2, %rdx
leaq 0x9909(%rip), %rdi      # 0xc025
callq 0x80f0
jmp 0x2723
leaq -0x48(%rbp), %rdi
callq 0x2ed0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2ed0
movq -0x58(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: hey-yahei[P]ConvNet/tests/test_mymodel.cpp
// Function: Model::~Model()
~Model() {
		delete conv1, conv2, conv3;
		delete fc1, fc2;
		delete elt;
		delete cat;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2f08
movq -0x10(%rbp), %rdi
callq 0x3070
movq -0x10(%rbp), %rdi
movl $0x80, %esi
callq 0x21f0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2f31
movq -0x20(%rbp), %rdi
callq 0x30c0
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x21f0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2f5a
movq -0x28(%rbp), %rdi
callq 0x3110
movq -0x28(%rbp), %rdi
movl $0x48, %esi
callq 0x21f0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2f83
movq -0x30(%rbp), %rdi
callq 0x3120
movq -0x30(%rbp), %rdi
movl $0x60, %esi
callq 0x21f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: hey-yahei[P]ConvNet/./include/Convolution.h
// Function: Convolution::~Convolution()
~Convolution() { 
		if (weight_data != nullptr) 
			free(weight_data); 
		if (bias_data != nullptr)
			free(bias_data);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x68(%rax)
je 0x3098
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2280
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x30b0
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hey-yahei[P]ConvNet/./include/FullyConnection.h
// Function: FullyConnection::~FullyConnection()
~FullyConnection(){
		if (weight_data != nullptr)
			free(weight_data);
		if (bias_data != nullptr)
			free(bias_data);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x30e8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2280
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3100
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hey-yahei[P]ConvNet/./include/Concat.h
// Function: Concat::~Concat()
~Concat(){
		// Free in_shape
		while (!in_shape.empty()) {
			free(in_shape.back());
			in_shape.pop_back();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3180
xorb $-0x1, %al
testb $0x1, %al
jne 0x3145
jmp 0x3161
movq -0x10(%rbp), %rdi
callq 0x31c0
movq (%rax), %rdi
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x3200
jmp 0x3134
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3230
movq -0x10(%rbp), %rdi
callq 0x3250
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: hey-yahei[P]ConvNet/src/Concat.cpp
// Function: Concat::SetKeepOrNot(bool, ...)
int Concat::SetKeepOrNot(bool keep, ...) {
	va_list ap;

	keep_in.clear();
	va_start(ap, keep);
	for (int i = 0; i < in_shape.size(); i++) {
		keep_in.push_back(keep);
		// ‘bool’ is promoted to ‘int’ when passed through ‘...’
		// so you should pass ‘int’ not ‘bool’ to ‘va_arg’
		keep = va_arg(ap, int);
	}
	va_end(ap);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x3e4b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
addq $0x28, %rdi
callq 0x4100
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl $0x0, -0x34(%rbp)
movq -0xf8(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x100(%rbp)
callq 0x4030
movq %rax, %rcx
movq -0x100(%rbp), %rax
cmpq %rcx, %rax
jae 0x3f6c
movq -0xf8(%rbp), %rdi
addq $0x28, %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4150
leaq -0x30(%rbp), %rax
movq %rax, -0x110(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x104(%rbp)
cmpl $0x28, %eax
ja 0x3f2f
movq -0x110(%rbp), %rcx
movl -0x104(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x118(%rbp)
jmp 0x3f4c
movq -0x110(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3eb2
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: hey-yahei[P]ConvNet/src/Eltwise.cpp
// Function: Eltwise::Eltwise(char const*, int*, bool)
Eltwise::Eltwise(const char* t, int ishape[], bool with_relu) : with_relu(with_relu) {
	elt_t = t;

	memcpy(in_shape, ishape, sizeof(int) * 4);
	memcpy(out_shape, ishape, sizeof(int) * 4);

	out_w = ishape[3];
	out_hw = ishape[2] * out_w;
	out_chw = ishape[1] * out_hw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
imull 0x28(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
imull 0x2c(%rax), %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hey-yahei[P]ConvNet/src/FullyConnection.cpp
// Function: FullyConnection::FullyConnection(int, int*, bool, bool, bool)
FullyConnection::FullyConnection(int out_num, int ishape[], bool with_relu, bool wiht_bias, bool flatten) 
		: out_num(out_num), with_relu(with_relu), with_bias(with_bias){
	if (flatten) {
		in_shape[0] = ishape[0];
		in_shape[1] = ishape[1] * ishape[2] * ishape[3];
	} else {
		in_shape[0] = ishape[0];
		in_shape[1] = ishape[1];
	}

	out_shape[0] = ishape[0];
	out_shape[1] = out_num;

	weight_data = (float*)malloc(sizeof(float) * in_shape[1] * out_shape[1]);
	if (wiht_bias)
		bias_data = (float*)malloc(sizeof(float) * out_num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r8d, -0x40(%rbp)
movl %ecx, %eax
movl -0x40(%rbp), %ecx
movl %eax, -0x3c(%rbp)
movq %rdx, %rax
movl -0x3c(%rbp), %edx
movq %rax, -0x38(%rbp)
movl %esi, %eax
movq -0x38(%rbp), %rsi
movl %eax, -0x2c(%rbp)
movq %rdi, %r8
movl -0x2c(%rbp), %edi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
andb $0x1, %cl
movb %cl, -0x1a(%rbp)
andb $0x1, %al
movb %al, -0x1b(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x14(%rax)
movb 0x15(%rax), %cl
andb $0x1, %cl
movb %cl, 0x15(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
testb $0x1, -0x1b(%rbp)
je 0x7052
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rdx
imull 0x8(%rdx), %ecx
movq -0x18(%rbp), %rdx
imull 0xc(%rdx), %ecx
movl %ecx, 0x8(%rax)
jmp 0x7069
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movslq 0x8(%rax), %rdi
shlq $0x2, %rdi
movslq 0x10(%rax), %rax
imulq %rax, %rdi
callq 0x22e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
testb $0x1, -0x1a(%rbp)
je 0x70ba
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x22e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: hey-yahei[P]ConvNet/src/FullyConnection.cpp
// Function: FullyConnection::Run(float*, bool)
float* FullyConnection::Run(float* in_data, bool keep_in) {
	float dat, wt, result;

	out_data = (float*)malloc(sizeof(float) * out_shape[0] * out_shape[1]);

	for (int idx_bs = 0; idx_bs < out_shape[0]; idx_bs++) {
		for (int idx_out = 0; idx_out < out_shape[1]; idx_out++) {
			result = 0.;
			for (int idx_in = 0; idx_in < in_shape[1]; idx_in++) {
				dat = in_data[idx_bs * in_shape[0] + idx_in];
				wt = weight_data[idx_out * in_shape[1] + idx_in];
				result += dat * wt;
			}
			if (with_bias)
				result += bias_data[idx_out];
			if (with_relu && result < 0)
				result = 0;
			out_data[idx_bs * out_shape[1] + idx_out] = result;
		}
	}

	if (!keep_in)
		free(in_data);

	return out_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
movslq 0x10(%rax), %rax
imulq %rax, %rdi
callq 0x22e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x7226
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x7216
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x71a9
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
imull 0x4(%rdx), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x18(%rbp)
movq 0x18(%rdx), %rax
movl -0x28(%rbp), %ecx
imull 0x8(%rdx), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
movss -0x20(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x713c
movq -0x38(%rbp), %rax
testb $0x1, 0x15(%rax)
je 0x71ce
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
addss -0x20(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x71e9
xorps %xmm0, %xmm0
ucomiss -0x20(%rbp), %xmm0
jbe 0x71e9
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x38(%rbp), %rdx
movss -0x20(%rbp), %xmm0
movq 0x28(%rdx), %rax
movl -0x24(%rbp), %ecx
imull 0x10(%rdx), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x711d
jmp 0x7218
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7106
testb $0x1, -0x11(%rbp)
jne 0x7235
movq -0x10(%rbp), %rdi
callq 0x2280
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)