/ input and store x
input
subt one
store x

/ input and store y
input
store y

/ input and store z
input
store z

/ calculate the exponent
jns exponent

/ calculate modulus
jump divide

/ bypass ac crunch
quit_divide, load result
  output

  halt

exponent, hex 0
  load y
  store y_count
_exponent_pass, load x
  / while (counter > 0)
  skipcond 800
  jumpi    exponent
    
  jns _exponent_multiply
    
  / y_count = result
  load  result
  store y_count
    
  / x += 1
  load  x
  subt  one
  store x
    
  jump _exponent_pass
_exponent_multiply, hex 0
  / result = 0
  load  zero
  store result
_exponent_multiplier, load y_count
  / while (y_count > 0)
  skipcond 800
  jumpi    _exponent_multiply
    
  / result += y
  load  result
  add   y
  store result
    
  / y_count += 1
  load  y_count
  subt  one
  store y_count
    
  jump _exponent_multiplier

divide, load dividend
  / dividend += _divide_temporary
  add _divide_temporary
  store dividend
  
  / result -= z
  load result
  subt z
  store result
  
  / while (divide < 0)
  skipcond 000
  jump divide
  
  / dividend -= _divide_temporary
  load dividend
  subt _divide_temporary
  store dividend
  
  / result += z
  load result
  add z
  store result
  
  jump quit_divide

/ constants
one,  dec 1
zero, hex 0

/ mutable variables
x,          hex 0
y,          hex 0
y_count,    hex 0
original_y, hex 0
z,          hex 0
result,     hex 0
dividend,   hex 0
_divide_temporary, dec 1