<?xml version="1.0" encoding="utf-8"?>
<CheatTable CheatEngineTableVersion="42">
  <CheatEntries>
    <CheatEntry>
      <ID>16</ID>
      <Description>"Evoland 1"</Description>
      <GroupHeader>1</GroupHeader>
      <CheatEntries>
        <CheatEntry>
          <ID>12</ID>
          <Description>"Glis"</Description>
          <VariableType>4 Bytes</VariableType>
          <Address>"libhl.dll"+0004914C</Address>
          <Offsets>
            <Offset>0</Offset>
            <Offset>84</Offset>
            <Offset>30</Offset>
            <Offset>8</Offset>
            <Offset>7FC</Offset>
          </Offsets>
        </CheatEntry>
        <CheatEntry>
          <ID>2</ID>
          <Description>"Invincibility (Turn Based)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(NO_PLAYER_DAMAGE,2B 55 14 89 55 FC 89 91) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  cmp [ecx+14],0x00307240
  je @f
  cmp [ecx+14],0x40723000
  je @f
  cmp [ecx+14],0x40718000
  je @f
  cmp [ecx+14],0x40719000
  je @f
  sub edx,[ebp+14]
@@:
  mov [ebp-04],edx
  jmp return

NO_PLAYER_DAMAGE:
  jmp newmem
  nop
return:
registersymbol(NO_PLAYER_DAMAGE)

[DISABLE]

NO_PLAYER_DAMAGE:
  db 2B 55 14 89 55 FC

unregistersymbol(NO_PLAYER_DAMAGE)
dealloc(newmem)

</AssemblerScript>
        </CheatEntry>
        <CheatEntry>
          <ID>5</ID>
          <Description>"Invincibility (Diablo Style)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(NO_DIABLO_PC_DAMAGE,F2 0F 11 11 8B 45 08 8B 48 78) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  //movsd [ecx],xmm2
  mov eax,[ebp+08]
  jmp return

NO_DIABLO_PC_DAMAGE:
  jmp newmem
  nop 2
return:
registersymbol(NO_DIABLO_PC_DAMAGE)

[DISABLE]

NO_DIABLO_PC_DAMAGE:
  db F2 0F 11 11 8B 45 08

unregistersymbol(NO_DIABLO_PC_DAMAGE)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 0A4ED373

0A4ED352: F2 0F 11 34 24  - movsd [esp],xmm6
0A4ED357: B9 06 12 B3 07  - mov ecx,SHELL32.dll+581206
0A4ED35C: 51              - push ecx
0A4ED35D: 50              - push eax
0A4ED35E: B8 E0 13 B0 7A  - mov eax,libhl.hl_dyn_setd
0A4ED363: FF D0           - call eax
0A4ED365: 89 6C 24 FC     - mov [esp-04],ebp
0A4ED369: 83 C4 1C        - add esp,1C
0A4ED36C: EB 09           - jmp 0A4ED377
0A4ED36E: F2 0F 10 55 F0  - movsd xmm2,[ebp-10]
// ---------- INJECTING HERE ----------
0A4ED373: F2 0F 11 11     - movsd [ecx],xmm2
// ---------- DONE INJECTING  ----------
0A4ED377: 8B 45 08        - mov eax,[ebp+08]
0A4ED37A: 8B 48 78        - mov ecx,[eax+78]
0A4ED37D: 89 4D C8        - mov [ebp-38],ecx
0A4ED380: 85 C9           - test ecx,ecx
0A4ED382: 75 0E           - jne 0A4ED392
0A4ED384: 83 EC 0C        - sub esp,0C
0A4ED387: B8 00 21 FC 09  - mov eax,09FC2100
0A4ED38C: FF D0           - call eax
0A4ED38E: 89 6C 24 FC     - mov [esp-04],ebp
0A4ED392: 83 EC 08        - sub esp,08
}
</AssemblerScript>
        </CheatEntry>
        <CheatEntry>
          <ID>15</ID>
          <Description>"Invincibility (Hearts)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(NO_HEART_DAMAGE,2B 55 0C 89 55 EC) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  //sub edx,[ebp+0C]
  mov [ebp-14],edx
  jmp return

NO_HEART_DAMAGE:
  jmp newmem
  nop
return:
registersymbol(NO_HEART_DAMAGE)

[DISABLE]

NO_HEART_DAMAGE:
  db 2B 55 0C 89 55 EC

unregistersymbol(NO_HEART_DAMAGE)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 0A7275D0

0A7275B0: 8B 05 80 3B 9C 06        - mov eax,[069C3B80]
0A7275B6: 89 45 E0                 - mov [ebp-20],eax
0A7275B9: 50                       - push eax
0A7275BA: 52                       - push edx
0A7275BB: E8 80 2E F9 FF           - call 0A6BA440
0A7275C0: 89 6C 24 FC              - mov [esp-04],ebp
0A7275C4: 83 C4 08                 - add esp,08
0A7275C7: 8B 4D 08                 - mov ecx,[ebp+08]
0A7275CA: 8B 51 48                 - mov edx,[ecx+48]
0A7275CD: 89 55 EC                 - mov [ebp-14],edx
// ---------- INJECTING HERE ----------
0A7275D0: 2B 55 0C                 - sub edx,[ebp+0C]
// ---------- DONE INJECTING  ----------
0A7275D3: 89 55 EC                 - mov [ebp-14],edx
0A7275D6: 89 51 48                 - mov [ecx+48],edx
0A7275D9: F2 0F 10 25 44 C9 05 01  - movsd xmm4,[0105C944]
0A7275E1: F2 0F 11 65 F8           - movsd [ebp-08],xmm4
0A7275E6: F2 0F 11 61 60           - movsd [ecx+60],xmm4
0A7275EB: 83 EC 08                 - sub esp,08
0A7275EE: E8 BD 97 31 00           - call 0AA40DB0
0A7275F3: 89 6C 24 FC              - mov [esp-04],ebp
0A7275F7: 83 C4 08                 - add esp,08
0A7275FA: 89 45 DC                 - mov [ebp-24],eax
}
</AssemblerScript>
        </CheatEntry>
      </CheatEntries>
    </CheatEntry>
    <CheatEntry>
      <ID>17</ID>
      <Description>"Evoland 2"</Description>
      <GroupHeader>1</GroupHeader>
      <CheatEntries>
        <CheatEntry>
          <ID>38</ID>
          <Description>"Glis"</Description>
          <VariableType>4 Bytes</VariableType>
          <Address>"libhl.dll"+0004914C</Address>
          <Offsets>
            <Offset>58</Offset>
            <Offset>24</Offset>
            <Offset>40</Offset>
            <Offset>8</Offset>
            <Offset>544</Offset>
          </Offsets>
        </CheatEntry>
        <CheatEntry>
          <ID>40</ID>
          <Description>"Invincibility (Action)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(NO_DAMAGE,89 55 F0 89 51 64 8B 51 64) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  cmp word ptr [ecx+24],0x0020
  je return
  cmp [ecx+78],2
  je return
  cmp [ecx+78],0x00000533
  je return
  mov [ecx+64],edx
  mov edx,[ecx+64]
  jmp return

NO_DAMAGE+03:
  jmp newmem
  nop
return:
registersymbol(NO_DAMAGE)

[DISABLE]

NO_DAMAGE+03:
  db 89 51 64 8B 51 64

unregistersymbol(NO_DAMAGE)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 09D51F08

09D51EEA: 52                 - push edx
09D51EEB: E8 70 B4 84 00     - call 0A59D360
09D51EF0: 89 6C 24 FC        - mov [esp-04],ebp
09D51EF4: 83 C4 10           - add esp,10
09D51EF7: 89 45 FC           - mov [ebp-04],eax
09D51EFA: 8B 4D 08           - mov ecx,[ebp+08]
09D51EFD: 8B 51 64           - mov edx,[ecx+64]
09D51F00: 89 55 F0           - mov [ebp-10],edx
09D51F03: 2B D0              - sub edx,eax
09D51F05: 89 55 F0           - mov [ebp-10],edx
// ---------- INJECTING HERE ----------
09D51F08: 89 51 64           - mov [ecx+64],edx
// ---------- DONE INJECTING  ----------
09D51F0B: 8B 51 64           - mov edx,[ecx+64]
09D51F0E: 89 55 F0           - mov [ebp-10],edx
09D51F11: 33 C0              - xor eax,eax
09D51F13: 89 45 EC           - mov [ebp-14],eax
09D51F16: 3B D0              - cmp edx,eax
09D51F18: 0F 8D 08 00 00 00  - jnl 09D51F26
09D51F1E: 33 D2              - xor edx,edx
09D51F20: 89 55 F0           - mov [ebp-10],edx
09D51F23: 89 51 64           - mov [ecx+64],edx
09D51F26: 33 D2              - xor edx,edx
}
</AssemblerScript>
        </CheatEntry>
        <CheatEntry>
          <ID>43</ID>
          <Description>"Invincibility (Turn Based)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(TURN_BASED_INVINCIBLE,89 42 64 8B 42 64 89 45 EC) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  cmp word ptr [edx+24],0x0020
  je return
  mov [edx+64],eax
  mov eax,[edx+64]
  jmp return

TURN_BASED_INVINCIBLE:
  jmp newmem
  nop
return:
registersymbol(TURN_BASED_INVINCIBLE)

[DISABLE]

TURN_BASED_INVINCIBLE:
  db 89 42 64 8B 42 64

unregistersymbol(TURN_BASED_INVINCIBLE)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 0A29BD5A

0A29BD33: 8B 54 24 FC        - mov edx,[esp-04]
0A29BD37: 81 CA 00 60 00 00  - or edx,00006000
0A29BD3D: 89 54 24 F8        - mov [esp-08],edx
0A29BD41: 0F AE 54 24 F8     - ldmxcsr [esp-08]
0A29BD46: F2 0F 2D CD        - cvtsd2si ecx,xmm5
0A29BD4A: 0F AE 54 24 FC     - ldmxcsr [esp-04]
0A29BD4F: 89 4D E8           - mov [ebp-18],ecx
0A29BD52: 2B C1              - sub eax,ecx
0A29BD54: 89 45 EC           - mov [ebp-14],eax
0A29BD57: 8B 55 08           - mov edx,[ebp+08]
// ---------- INJECTING HERE ----------
0A29BD5A: 89 42 64           - mov [edx+64],eax
// ---------- DONE INJECTING  ----------
0A29BD5D: 8B 42 64           - mov eax,[edx+64]
0A29BD60: 89 45 EC           - mov [ebp-14],eax
0A29BD63: 33 C9              - xor ecx,ecx
0A29BD65: 89 4D E8           - mov [ebp-18],ecx
0A29BD68: 3B C8              - cmp ecx,eax
0A29BD6A: 0F 8C 08 00 00 00  - jl 0A29BD78
0A29BD70: 33 C0              - xor eax,eax
0A29BD72: 89 45 EC           - mov [ebp-14],eax
0A29BD75: 89 42 64           - mov [edx+64],eax
0A29BD78: 8B 45 F4           - mov eax,[ebp-0C]
}
</AssemblerScript>
        </CheatEntry>
        <CheatEntry>
          <ID>45</ID>
          <Description>"Invincibility (Beat-em-up)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(INVINCIBLE_BEAT_UP,89 51 64 8B 51 64 89) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  cmp word ptr [ecx+24],0x0020
  je return
  mov [ecx+64],edx
  mov edx,[ecx+64]
  jmp return

INVINCIBLE_BEAT_UP:
  jmp newmem
  nop
return:
registersymbol(INVINCIBLE_BEAT_UP)

[DISABLE]

INVINCIBLE_BEAT_UP:
  db 89 51 64 8B 51 64

unregistersymbol(INVINCIBLE_BEAT_UP)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 09A158DF

09A158BD: 83 EC 08           - sub esp,08
09A158C0: F2 0F 11 14 24     - movsd [esp],xmm2
09A158C5: B8 C0 E8 F3 7A     - mov eax,libhl.hl_math_ceil
09A158CA: FF D0              - call eax
09A158CC: 89 6C 24 FC        - mov [esp-04],ebp
09A158D0: 83 C4 10           - add esp,10
09A158D3: 89 45 EC           - mov [ebp-14],eax
09A158D6: 29 45 F0           - sub [ebp-10],eax
09A158D9: 8B 4D 08           - mov ecx,[ebp+08]
09A158DC: 8B 55 F0           - mov edx,[ebp-10]
// ---------- INJECTING HERE ----------
09A158DF: 89 51 64           - mov [ecx+64],edx
// ---------- DONE INJECTING  ----------
09A158E2: 8B 51 64           - mov edx,[ecx+64]
09A158E5: 89 55 F0           - mov [ebp-10],edx
09A158E8: 33 C0              - xor eax,eax
09A158EA: 89 45 EC           - mov [ebp-14],eax
09A158ED: 3B C2              - cmp eax,edx
09A158EF: 0F 8C 2D 00 00 00  - jl 09A15922
09A158F5: 33 D2              - xor edx,edx
09A158F7: 89 55 F0           - mov [ebp-10],edx
09A158FA: 89 51 64           - mov [ecx+64],edx
09A158FD: 8B 05 BC 22 6B 06  - mov eax,[066B22BC]
}
</AssemblerScript>
        </CheatEntry>
        <CheatEntry>
          <ID>53</ID>
          <Description>"Invincibility (Match 3)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(INVINCIBLE_MATCH3,89 0A 8B 45 0C 8B) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  cmp [eax+8C],0x3FF00000
  je return
  mov [edx],ecx
  mov eax,[ebp+0C]
  jmp return

INVINCIBLE_MATCH3:
  jmp newmem
return:
registersymbol(INVINCIBLE_MATCH3)

[DISABLE]

INVINCIBLE_MATCH3:
  db 89 0A 8B 45 0C

unregistersymbol(INVINCIBLE_MATCH3)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 0A8F25B6

0A8F259B: 52              - push edx
0A8F259C: BA 06 12 B3 07  - mov edx,07B31206
0A8F25A1: 52              - push edx
0A8F25A2: 50              - push eax
0A8F25A3: B8 40 12 58 71  - mov eax,libhl.hl_dyn_seti
0A8F25A8: FF D0           - call eax
0A8F25AA: 89 6C 24 FC     - mov [esp-04],ebp
0A8F25AE: 83 C4 1C        - add esp,1C
0A8F25B1: EB 05           - jmp 0A8F25B8
0A8F25B3: 8B 4D F8        - mov ecx,[ebp-08]
// ---------- INJECTING HERE ----------
0A8F25B6: 89 0A           - mov [edx],ecx
// ---------- DONE INJECTING  ----------
0A8F25B8: 8B 45 0C        - mov eax,[ebp+0C]
0A8F25BB: 8B 48 1C        - mov ecx,[eax+1C]
0A8F25BE: 85 C9           - test ecx,ecx
0A8F25C0: 75 21           - jne 0A8F25E3
0A8F25C2: 68 AC 61 7E 04  - push 047E61AC
0A8F25C7: 68 A8 1C 5B E4  - push E45B1CA8
0A8F25CC: 50              - push eax
0A8F25CD: B8 90 0F 58 71  - mov eax,libhl.hl_dyn_getp
0A8F25D2: FF D0           - call eax
0A8F25D4: 89 6C 24 FC     - mov [esp-04],ebp
}
</AssemblerScript>
        </CheatEntry>
        <CheatEntry>
          <ID>58</ID>
          <Description>"Invincibility (Strategy)"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(INVINCIBLE_STRAT,89 42 64 8B 42 64 89 45 E8) // should be unique
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  cmp [edx+94],0
  je return
  cmp [edx+24],0x0020
  jne return
  mov [edx+64],eax
  mov eax,[edx+64]
  jmp return

INVINCIBLE_STRAT:
  jmp newmem
  nop
return:
registersymbol(INVINCIBLE_STRAT)

[DISABLE]

INVINCIBLE_STRAT:
  db 89 42 64 8B 42 64

unregistersymbol(INVINCIBLE_STRAT)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 0A6A83EC

0A6A83C2: 0F AE 5C 24 FC     - stmxcsr [esp-04]
0A6A83C7: 8B 44 24 FC        - mov eax,[esp-04]
0A6A83CB: 81 C8 00 60 00 00  - or eax,00006000
0A6A83D1: 89 44 24 F8        - mov [esp-08],eax
0A6A83D5: 0F AE 54 24 F8     - ldmxcsr [esp-08]
0A6A83DA: F2 0F 2D CE        - cvtsd2si ecx,xmm6
0A6A83DE: 0F AE 54 24 FC     - ldmxcsr [esp-04]
0A6A83E3: 89 4D D0           - mov [ebp-30],ecx
0A6A83E6: 29 4D E8           - sub [ebp-18],ecx
0A6A83E9: 8B 45 E8           - mov eax,[ebp-18]
// ---------- INJECTING HERE ----------
0A6A83EC: 89 42 64           - mov [edx+64],eax
// ---------- DONE INJECTING  ----------
0A6A83EF: 8B 42 64           - mov eax,[edx+64]
0A6A83F2: 89 45 E8           - mov [ebp-18],eax
0A6A83F5: 33 C9              - xor ecx,ecx
0A6A83F7: 89 4D D0           - mov [ebp-30],ecx
0A6A83FA: 3B C8              - cmp ecx,eax
0A6A83FC: 0F 8C 08 00 00 00  - jl 0A6A840A
0A6A8402: 33 C0              - xor eax,eax
0A6A8404: 89 45 E8           - mov [ebp-18],eax
0A6A8407: 89 42 64           - mov [edx+64],eax
0A6A840A: 8B 45 F4           - mov eax,[ebp-0C]
}
</AssemblerScript>
        </CheatEntry>
        <CheatEntry>
          <ID>29</ID>
          <Description>"Experience Multiplier"</Description>
          <VariableType>Auto Assembler Script</VariableType>
          <AssemblerScript>[ENABLE]

aobscan(EXP_MULTIPLIER,03 4D 14 89 4D F4 8B 55) // should be unique
alloc(newmem,$1000)

label(code)
label(return)
label(exp_value)
registersymbol(exp_value)

newmem:

code:
  push eax
  mov eax,[ebp+14]
  imul eax,[exp_value]
  add ecx,eax
  pop eax
  mov [ebp-0C],ecx
  jmp return

exp_value:
  dd 1

EXP_MULTIPLIER:
  jmp newmem
  nop
return:
registersymbol(EXP_MULTIPLIER)

[DISABLE]

EXP_MULTIPLIER:
  db 03 4D 14 89 4D F4

unregistersymbol(EXP_MULTIPLIER)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: 0AB09576

0AB0955A: 51              - push ecx
0AB0955B: B8 10 0D 4F 7C  - mov eax,libhl.hl_dyn_geti
0AB09560: FF D0           - call eax
0AB09562: 89 6C 24 FC     - mov [esp-04],ebp
0AB09566: 83 C4 10        - add esp,10
0AB09569: 89 45 F4        - mov [ebp-0C],eax
0AB0956C: EB 05           - jmp 0AB09573
0AB0956E: 8B 02           - mov eax,[edx]
0AB09570: 89 45 F4        - mov [ebp-0C],eax
0AB09573: 8B 4D F4        - mov ecx,[ebp-0C]
// ---------- INJECTING HERE ----------
0AB09576: 03 4D 14        - add ecx,[ebp+14]
// ---------- DONE INJECTING  ----------
0AB09579: 89 4D F4        - mov [ebp-0C],ecx
0AB0957C: 8B 55 10        - mov edx,[ebp+10]
0AB0957F: 8B 42 1C        - mov eax,[edx+1C]
0AB09582: 85 C0           - test eax,eax
0AB09584: 75 1E           - jne 0AB095A4
0AB09586: 51              - push ecx
0AB09587: B8 4C 3B 66 04  - mov eax,04663B4C
0AB0958C: 50              - push eax
0AB0958D: B8 F8 68 00 00  - mov eax,000068F8
0AB09592: 50              - push eax
}
</AssemblerScript>
          <CheatEntries>
            <CheatEntry>
              <ID>54</ID>
              <Description>"Experience Multiplier"</Description>
              <ShowAsSigned>0</ShowAsSigned>
              <VariableType>4 Bytes</VariableType>
              <Address>"exp_value"</Address>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
      </CheatEntries>
    </CheatEntry>
  </CheatEntries>
  <UserdefinedSymbols/>
</CheatTable>
