CODE:004024B5     ; init ExtendedRegisters
CODE:004024B5
CODE:004024B8 164                 xor     ecx, ecx
CODE:004024BA 164                 mov     edx, 10h
CODE:004024BF 164                 call    c_memset        ; eax = buffer
CODE:004024BF                                             ; edx = count
CODE:004024BF                                             ; ecx = int
CODE:004024BF
CODE:004024C7 164                 xor     ecx, ecx
CODE:004024C9 164                 mov     edx, 44h
CODE:004024CE 164                 call    c_memset

VOID ExtendedRegisters()
{
  __Asm {
    //Save our registers
    push ecx 
    push edx

    //Set registers and call function
    xor ecx, ecx
    mov edx, 10h
    call c_memset

    //Set registers and call function
    xor ecx, ecx
    mov edx, 44h
    call c_memset

    //Revert our registers to original data
    pop ecx
    pop edx
  }
}

void fooey()
  {
  char s[ 5 ];
  // in the following, I don't care about clobbering EAX and ECX
  // --because VC++ doesn't expect them to be preserved
  __asm {
    // count = 5
    mov  eax, 5
    push eax
    // value = 0
    mov  eax, 0  // people used to use xor eax, eax because on 
    push eax     // really old processors it made a difference in speed
    // destination = s
    lea  eax, byte ptr s
    // memset( s, 0, 50 )
    call _memset
    // (eax has the return value, which is s)
    // clean up
    pop  ecx
    pop  ecx
    pop  ecx
    
    mov  [eax],   'A'  // s[ 0 ] = 'A'
    mov  [eax+1], 'B'  // s[ 1 ] = 'B'
    mov  [eax+2], 'C'  // s[ 2 ] = 'C'

    // puts( s )
    push eax
    call  _puts
    pop  eax
    }
  }

//Declare MovePlayer functions address in the program
#define MovePlayerToXYZCoords 0x40DD40


//Contains assembly for 0x4000A0 which is a function that
//sets these registers (eax, ecx and edx) which contain the
//new X, Y and Z locations and then passes them to the
//MovePlayer function which uses the registers to move you
///to new location.
VOID MoveLocation(float x, float y, float z)
{

//From my very little knowledge in assembly it seems
//that unless I set parameters as a local variable, the 
//assembly won't compile. So I just set some local variables
//pulled from the parameters here so it will compile.
float WarpXLoc = x;
float WarpYLoc = y;
float WarpZLoc = z;
__asm {
//Initialize
    push eax
    push ecx
    push ebp
    
//Mov X, Y, and Z into registers with local variables in brackets
//because from what I've read they must be.
    mov eax,[x]
    mov ecx,[y]
    mov ebp,[z] 

//Call move function with new registers
call MovePlayerToXYZCoords
    
//Revert
    pop eax
    pop ecx
    pop ebp
  }
}

VOID MoveLocation(float x, float y, float z)
{
float WarpXLoc = x;
float WarpYLoc = y;
float WarpZLoc = z;

__asm {
    push eax
    
//Mov X, Y and Z locations into the eax register. This
//is my guess on how to use the same register for 
//three different variables, I may be wrong and please
//tell me the correct method if I am wrong.
    mov eax,[x]
    push eax

    mov eax,[y]
    push eax

    mov eax,[z] 
    push eax

//Call MovePlayer function
    call MovePlayerToXYZCoords
    
//Revert
    pop eax
  }
}

mov     eax, dword_980D84
test    eax, eax
jz      short loc_40A365
mov     ecx, dword_7B8440
push    ebx
push    0
//Variable One (0x24A1 = opcode)
push    24A1h
call    sub_658FB0
mov     ecx, dword_980D84
//Variable Two (2 = size)
push    2               ; Size
push    offset word_97F2B8 ; int
push    4               ; int
//Variable Three (ax = data)
mov     word_97F2B8, ax
call    sub_64A430
//Not used in my assembly, a little unsure what 
//exactly it does (0 = memory?)
push    0               ; Memory
mov     bl, al
call    j_j__free
mov     ecx, dword_A49E3C
add     esp, 4
dec     ecx
test    bl, bl
mov     dword_A49E3C, ecx
pop     ebx
jnz     short locret_40A380
mov     ecx, dword_7B8444
push    offset dword_980D84
call    sub_440B90
retn

int quux( int x, int y )
  {
  int z = x + y;
  return z / (x - y);
  }

  ; when the function is called, the stack looks like this:
  (return address) <-- ESP  ; (lower addresses)
  (x)                       ; (function arguments were pushed right to left)
  (y)
  ...              <-- EBP  ; (higher addresses)

_quux:
  ; The function prolog
  push ebp       ; preserve the last function's frame
  mov  ebp, esp  ; and set this function's frame
  sub  esp, 4    ; make room for our local variable: sizeof( z )

  ; now the stack looks like this
  (z)              <-- ESP
  (previous EBP)   <-- EBP
  (return address)
  (x)                       ; (function arguments were pushed right to left)
  (y)
  ...

  ; The function body
  mov  eax, [ebp+8]   ; x
  add  eax, [ebp+12]  ; + y
  mov  [ebp-4], eax  ; --> z

  mov  ecx, [ebp+8]   ; x
  sub  ecx, [ebp+12]  ; - y
  xor  edx, edx       ; (high-order word of dividend = 0)
  mov  eax, [ebp-4]   ; z
  idiv ecx            ; z / (x - y) --> quotient eax, remainder edx

  ; The function epilog
  ; (eax contains the function's return value)
  mov  esp, ebp  ; restore the top of the stack to what it was before allocating space for local variables
  pop  ebp       ; restore the previous function's frame
  ret            ; return to previous function (the cdecl calling convention says
                 ; that the caller must remove the arguments x and y from the stack)

  push [x]
  push [y]
  push [z]

  mov ecx, [x]
  mov edx, [y]
  push [z]
  call @MovePlayerToXYZCoords@12
  ; The function cleaned up its own stack, so we don't need to pop anything here
  ; Also, the function returns nothing, but if it returned an ordinal value it would be in EAX (not on the stack) 

dword_980D84 = player_count (global variable)
dword_7B8440 = ?
sub_658FB0   = adjust_player_hitpoints (function name) [It should be obvious that I am making these names up]
...

  jz short return_label
  ...

  return_label:
  ; do your prolog
  retn