class cl_e(object):
  def __init__(self):
    pass
  def interpret(*args):
    raise CEKError("class e does not implement a method")
  def pprint(self, indent):
    return ' ' * indent + '(e)'
class cl_var(cl_e):
  def __init__(self):
    pass
  def interpret(self, e, k):
    try:
      if isinstance(self, cl_var):
        var = self
        if isinstance(e, cl_env):
          env_0 = e
          if isinstance(k, cl_k):
            k = k
            w_tmp0_lookup0 = env_0
            w_tmp0_lookup1 = var
            w_tmp0 = lookup(w_tmp0_lookup0, w_tmp0_lookup1)
            if isinstance(w_tmp0, cl_clo):
              w_tmp0_v0 = w_tmp0.v0
              w_tmp0_env1 = w_tmp0.env1
              if isinstance(w_tmp0_v0, cl_v):
                v = w_tmp0_v0
                if isinstance(w_tmp0_env1, cl_env):
                  env = w_tmp0_env1
                  c_result = v
                  e_result = env
                  k_result = k
                  return c_result, e_result, k_result
                else:
                  raise CEKMatchFailure("Expected w_tmp0_env1 to be an env")
              else:
                raise CEKMatchFailure("Expected w_tmp0_v0 to be an v")
            else:
              raise CEKMatchFailure("Expected w_tmp0 to be an clo")
          else:
            raise CEKMatchFailure("Expected k to be an k")
        else:
          raise CEKMatchFailure("Expected e to be an env")
      else:
        raise CEKMatchFailure("Expected self to be an var")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class var")
  def pprint(self, indent):
    return ' ' * indent + '(var)'
class cl_v(cl_e):
  def __init__(self):
    pass
  def interpret(self, e, k):
    try:
      if isinstance(self, cl_v):
        v = self
        if isinstance(e, cl_env):
          env_0 = e
          if isinstance(k, cl_k):
            k = k
            return k.interpret(self, e)
          else:
            raise CEKMatchFailure("Expected k to be an k")
        else:
          raise CEKMatchFailure("Expected e to be an env")
      else:
        raise CEKMatchFailure("Expected self to be an v")
    except CEKMatchFailure as matchf:
      pass
    try:
      if isinstance(self, cl_v):
        v = self
        if isinstance(e, cl_env):
          env_0 = e
          if isinstance(k, cl_k):
            k = k
            return k.interpret(self, e)
          else:
            raise CEKMatchFailure("Expected k to be an k")
        else:
          raise CEKMatchFailure("Expected e to be an env")
      else:
        raise CEKMatchFailure("Expected self to be an v")
    except CEKMatchFailure as matchf:
      pass
    try:
      if isinstance(self, cl_v):
        v = self
        if isinstance(e, cl_env):
          env_0 = e
          if isinstance(k, cl_k):
            k = k
            return k.interpret(self, e)
          else:
            raise CEKMatchFailure("Expected k to be an k")
        else:
          raise CEKMatchFailure("Expected e to be an env")
      else:
        raise CEKMatchFailure("Expected self to be an v")
    except CEKMatchFailure as matchf:
      pass
    try:
      if isinstance(self, cl_v):
        v = self
        if isinstance(e, cl_env):
          env_0 = e
          if isinstance(k, cl_k):
            k = k
            return k.interpret(v, env_0)
          else:
            raise CEKMatchFailure("Expected k to be an k")
        else:
          raise CEKMatchFailure("Expected e to be an env")
      else:
        raise CEKMatchFailure("Expected self to be an v")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class v")
  def pprint(self, indent):
    return ' ' * indent + '(v)'
class cl_bool(cl_v):
  def __init__(self):
    pass
  # method inherited from super class
  def pprint(self, indent):
    return ' ' * indent + '(bool)'
class cl_int(cl_v):
  def __init__(self):
    pass
  # method inherited from super class
  def pprint(self, indent):
    return ' ' * indent + '(int)'
class cl_w(object):
  def __init__(self):
    pass
  def interpret(*args):
    raise CEKError("class w does not implement a method")
  def pprint(self, indent):
    return ' ' * indent + '(w)'
class cl_env(object):
  def __init__(self):
    pass
  def interpret(*args):
    raise CEKError("class env does not implement a method")
  def pprint(self, indent):
    return ' ' * indent + '(env)'
class cl_k(object):
  def __init__(self):
    pass
  def interpret(*args):
    raise CEKError("class k does not implement a method")
  def pprint(self, indent):
    return ' ' * indent + '(k)'
class cl_variable(cl_var):
  def __init__(self):
    pass
  # method inherited from super class
  def pprint(self, indent):
    return ' ' * indent + '(variable)'
class cl_integer(cl_int):
  def __init__(self):
    pass
  # method inherited from super class
  def pprint(self, indent):
    return ' ' * indent + '(integer)'
class cl_if(cl_e):
  def __init__(self, e0, e1, e2):
    self.e0 = e0
    self.e1 = e1
    self.e2 = e2
  def interpret(self, e, k):
    try:
      if isinstance(self, cl_if):
        self_e0 = self.e0
        self_e1 = self.e1
        self_e2 = self.e2
        if isinstance(self_e0, cl_e):
          e_test = self_e0
          if isinstance(self_e1, cl_e):
            e_then = self_e1
            if isinstance(self_e2, cl_e):
              e_else = self_e2
              if isinstance(e, cl_env):
                env = e
                if isinstance(k, cl_k):
                  k = k
                  c_result = e_test
                  e_result = env
                  k_result_e0 = e_then
                  k_result_e1 = e_else
                  k_result_env2 = env
                  k_result_k3 = k
                  k_result = cl_sel(k_result_e0, k_result_e1, k_result_env2, k_result_k3)
                  return c_result, e_result, k_result
                else:
                  raise CEKMatchFailure("Expected k to be an k")
              else:
                raise CEKMatchFailure("Expected e to be an env")
            else:
              raise CEKMatchFailure("Expected self_e2 to be an e")
          else:
            raise CEKMatchFailure("Expected self_e1 to be an e")
        else:
          raise CEKMatchFailure("Expected self_e0 to be an e")
      else:
        raise CEKMatchFailure("Expected self to be an if")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class if")
  def pprint(self, indent):
    return ' ' * indent + '(if %s %s %s)' % (self.e0.pprint(0), self.e1.pprint(0), self.e2.pprint(0))
class cl_sel(cl_k):
  def __init__(self, e0, e1, env2, k3):
    self.e0 = e0
    self.e1 = e1
    self.env2 = env2
    self.k3 = k3
  def interpret(self, c_arg, e_arg):
    try:
      if isinstance(self, cl_sel):
        self_e0 = self.e0
        self_e1 = self.e1
        self_env2 = self.env2
        self_k3 = self.k3
        if isinstance(self_e0, cl_e):
          e_then = self_e0
          if isinstance(self_e1, cl_e):
            e_else = self_e1
            if isinstance(self_env2, cl_env):
              env = self_env2
              if isinstance(self_k3, cl_k):
                k = self_k3
                if isinstance(c_arg, cl_false):
                  if isinstance(e_arg, cl_env):
                    env_0 = e_arg
                    c_result = e_else
                    e_result = env
                    k_result = k
                    return c_result, e_result, k_result
                  else:
                    raise CEKMatchFailure("Expected e_arg to be an env")
                else:
                  raise CEKMatchFailure("Expected c_arg to be an false")
              else:
                raise CEKMatchFailure("Expected self_k3 to be an k")
            else:
              raise CEKMatchFailure("Expected self_env2 to be an env")
          else:
            raise CEKMatchFailure("Expected self_e1 to be an e")
        else:
          raise CEKMatchFailure("Expected self_e0 to be an e")
      else:
        raise CEKMatchFailure("Expected self to be an sel")
    except CEKMatchFailure as matchf:
      pass
    try:
      if isinstance(self, cl_sel):
        self_e0 = self.e0
        self_e1 = self.e1
        self_env2 = self.env2
        self_k3 = self.k3
        if isinstance(self_e0, cl_e):
          e_then = self_e0
          if isinstance(self_e1, cl_e):
            e_else = self_e1
            if isinstance(self_env2, cl_env):
              env = self_env2
              if isinstance(self_k3, cl_k):
                k = self_k3
                if isinstance(c_arg, cl_v):
                  v = c_arg
                  if isinstance(e_arg, cl_env):
                    env_0 = e_arg
                    w_tmp0 = v
                    try:
                      if isinstance(w_tmp0, cl_false):
                        raise CEKUnlessFailure()
                      else:
                        raise CEKMatchFailure("Expected w_tmp0 to be an false")
                    except CEKMatchFailure as matchf:
                      c_result = e_then
                      e_result = env
                      k_result = k
                      return c_result, e_result, k_result
                    except CEKUnlessFailure:
                      pass
                  else:
                    raise CEKMatchFailure("Expected e_arg to be an env")
                else:
                  raise CEKMatchFailure("Expected c_arg to be an v")
              else:
                raise CEKMatchFailure("Expected self_k3 to be an k")
            else:
              raise CEKMatchFailure("Expected self_env2 to be an env")
          else:
            raise CEKMatchFailure("Expected self_e1 to be an e")
        else:
          raise CEKMatchFailure("Expected self_e0 to be an e")
      else:
        raise CEKMatchFailure("Expected self to be an sel")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class sel")
  def pprint(self, indent):
    return ' ' * indent + '(sel %s %s %s %s)' % (self.e0.pprint(0), self.e1.pprint(0), self.env2.pprint(0), self.k3.pprint(0))
class cl_app(cl_e):
  def __init__(self, e0, e1):
    self.e0 = e0
    self.e1 = e1
  def interpret(self, e, k):
    try:
      if isinstance(self, cl_app):
        self_e0 = self.e0
        self_e1 = self.e1
        if isinstance(self_e0, cl_e):
          e_1 = self_e0
          if isinstance(self_e1, cl_e):
            e_2 = self_e1
            if isinstance(e, cl_env):
              env = e
              if isinstance(k, cl_k):
                k = k
                c_result = e_1
                e_result = env
                k_result_e0 = e_2
                k_result_env1 = env
                k_result_k2 = k
                k_result = cl_arg(k_result_e0, k_result_env1, k_result_k2)
                return c_result, e_result, k_result
              else:
                raise CEKMatchFailure("Expected k to be an k")
            else:
              raise CEKMatchFailure("Expected e to be an env")
          else:
            raise CEKMatchFailure("Expected self_e1 to be an e")
        else:
          raise CEKMatchFailure("Expected self_e0 to be an e")
      else:
        raise CEKMatchFailure("Expected self to be an app")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class app")
  def pprint(self, indent):
    return ' ' * indent + '(app %s %s)' % (self.e0.pprint(0), self.e1.pprint(0))
class cl_clo(cl_w):
  def __init__(self, v0, env1):
    self.v0 = v0
    self.env1 = env1
  def interpret(*args):
    raise CEKError("class clo does not implement a method")
  def pprint(self, indent):
    return ' ' * indent + '(clo %s %s)' % (self.v0.pprint(0), self.env1.pprint(0))
class cl_fn(cl_k):
  def __init__(self, v0, env1, k2):
    self.v0 = v0
    self.env1 = env1
    self.k2 = k2
  def interpret(self, c_arg, e_arg):
    try:
      if isinstance(self, cl_fn):
        self_v0 = self.v0
        self_env1 = self.env1
        self_k2 = self.k2
        if isinstance(self_v0, cl_lam):
          self_v0_var0 = self_v0.var0
          self_v0_e1 = self_v0.e1
          if isinstance(self_v0_var0, cl_var):
            var = self_v0_var0
            if isinstance(self_v0_e1, cl_e):
              e = self_v0_e1
              if isinstance(self_env1, cl_env):
                env = self_env1
                if isinstance(self_k2, cl_k):
                  k = self_k2
                  if isinstance(c_arg, cl_v):
                    v = c_arg
                    if isinstance(e_arg, cl_env):
                      env_0 = e_arg
                      c_result = e
                      e_result_extend0 = env
                      e_result_extend1 = var
                      e_result_extend2_v0 = v
                      e_result_extend2_env1 = env_0
                      e_result_extend2 = cl_clo(e_result_extend2_v0, e_result_extend2_env1)
                      e_result = extend(e_result_extend0, e_result_extend1, e_result_extend2)
                      k_result = k
                      return c_result, e_result, k_result
                    else:
                      raise CEKMatchFailure("Expected e_arg to be an env")
                  else:
                    raise CEKMatchFailure("Expected c_arg to be an v")
                else:
                  raise CEKMatchFailure("Expected self_k2 to be an k")
              else:
                raise CEKMatchFailure("Expected self_env1 to be an env")
            else:
              raise CEKMatchFailure("Expected self_v0_e1 to be an e")
          else:
            raise CEKMatchFailure("Expected self_v0_var0 to be an var")
        else:
          raise CEKMatchFailure("Expected self_v0 to be an lam")
      else:
        raise CEKMatchFailure("Expected self to be an fn")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class fn")
  def pprint(self, indent):
    return ' ' * indent + '(fn %s %s %s)' % (self.v0.pprint(0), self.env1.pprint(0), self.k2.pprint(0))
class cl_arg(cl_k):
  def __init__(self, e0, env1, k2):
    self.e0 = e0
    self.env1 = env1
    self.k2 = k2
  def interpret(self, c_arg, e_arg):
    try:
      if isinstance(self, cl_arg):
        self_e0 = self.e0
        self_env1 = self.env1
        self_k2 = self.k2
        if isinstance(self_e0, cl_e):
          e = self_e0
          if isinstance(self_env1, cl_env):
            env = self_env1
            if isinstance(self_k2, cl_k):
              k = self_k2
              if isinstance(c_arg, cl_v):
                v = c_arg
                if isinstance(e_arg, cl_env):
                  env_0 = e_arg
                  c_result = e
                  e_result = env
                  k_result_v0 = v
                  k_result_env1 = env_0
                  k_result_k2 = k
                  k_result = cl_fn(k_result_v0, k_result_env1, k_result_k2)
                  return c_result, e_result, k_result
                else:
                  raise CEKMatchFailure("Expected e_arg to be an env")
              else:
                raise CEKMatchFailure("Expected c_arg to be an v")
            else:
              raise CEKMatchFailure("Expected self_k2 to be an k")
          else:
            raise CEKMatchFailure("Expected self_env1 to be an env")
        else:
          raise CEKMatchFailure("Expected self_e0 to be an e")
      else:
        raise CEKMatchFailure("Expected self to be an arg")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class arg")
  def pprint(self, indent):
    return ' ' * indent + '(arg %s %s %s)' % (self.e0.pprint(0), self.env1.pprint(0), self.k2.pprint(0))
class cl_lam(cl_v):
  def __init__(self, var0, e1):
    self.var0 = var0
    self.e1 = e1
  # method inherited from super class
  def pprint(self, indent):
    return ' ' * indent + '(lam %s %s)' % (self.var0.pprint(0), self.e1.pprint(0))
class cl_false(cl_bool):
  def __init__(self):
    self.literal = "false"
  def interpret(self, e, k):
    try:
      if isinstance(self, cl_false):
        if isinstance(e, cl_env):
          env_0 = e
          if isinstance(k, cl_k):
            k = k
            return k.interpret(self, e)
          else:
            raise CEKMatchFailure("Expected k to be an k")
        else:
          raise CEKMatchFailure("Expected e to be an env")
      else:
        raise CEKMatchFailure("Expected self to be an false")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class false")
  def pprint(self, indent):
    return ' ' * indent + 'false'
class cl_true(cl_bool):
  def __init__(self):
    self.literal = "true"
  # method inherited from super class
  def pprint(self, indent):
    return ' ' * indent + 'true'
class cl_dummy(cl_env):
  def __init__(self):
    self.literal = "dummy"
  def interpret(*args):
    raise CEKError("class dummy does not implement a method")
  def pprint(self, indent):
    return ' ' * indent + 'dummy'
class cl_mt(cl_k):
  def __init__(self):
    self.literal = "mt"
  def interpret(self, c_arg, e_arg):
    try:
      if isinstance(self, cl_mt):
        if isinstance(c_arg, cl_v):
          v = c_arg
          if isinstance(e_arg, cl_env):
            env_0 = e_arg
            result_pprint0 = v
            result = pprint(result_pprint0)
            dummy = ret(result)
            raise CEKError("Failed to halt the program in a final state")
          else:
            raise CEKMatchFailure("Expected e_arg to be an env")
        else:
          raise CEKMatchFailure("Expected c_arg to be an v")
      else:
        raise CEKMatchFailure("Expected self to be an mt")
    except CEKMatchFailure as matchf:
      pass
    raise CEKError("No cases matched for method in class mt")
  def pprint(self, indent):
    return ' ' * indent + 'mt'
def init(p):
  if isinstance(p, cl_e):
    e = p
    c_init_e0_e0_e0_e0_e0_e0_var0 = mkvariable("iszero")
    c_init_e0_e0_e0_e0_e0_e0_e1_var0 = mkvariable("succ")
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_var0 = mkvariable("pred")
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_var0 = mkvariable("+")
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_var0 = mkvariable("-")
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_e1_var0 = mkvariable("*")
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_e1_e1 = e
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_e1 = cl_lam(c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_e1_var0, c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_e1_e1)
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1 = cl_lam(c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_var0, c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1_e1)
    c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1 = cl_lam(c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_var0, c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1_e1)
    c_init_e0_e0_e0_e0_e0_e0_e1_e1 = cl_lam(c_init_e0_e0_e0_e0_e0_e0_e1_e1_var0, c_init_e0_e0_e0_e0_e0_e0_e1_e1_e1)
    c_init_e0_e0_e0_e0_e0_e0_e1 = cl_lam(c_init_e0_e0_e0_e0_e0_e0_e1_var0, c_init_e0_e0_e0_e0_e0_e0_e1_e1)
    c_init_e0_e0_e0_e0_e0_e0 = cl_lam(c_init_e0_e0_e0_e0_e0_e0_var0, c_init_e0_e0_e0_e0_e0_e0_e1)
    c_init_e0_e0_e0_e0_e0_e1_var0 = mkvariable("n")
    c_init_e0_e0_e0_e0_e0_e1_e1_zeropimpl0 = mkvariable("n")
    c_init_e0_e0_e0_e0_e0_e1_e1 = zeropimpl(c_init_e0_e0_e0_e0_e0_e1_e1_zeropimpl0)
    c_init_e0_e0_e0_e0_e0_e1 = cl_lam(c_init_e0_e0_e0_e0_e0_e1_var0, c_init_e0_e0_e0_e0_e0_e1_e1)
    c_init_e0_e0_e0_e0_e0 = cl_app(c_init_e0_e0_e0_e0_e0_e0, c_init_e0_e0_e0_e0_e0_e1)
    c_init_e0_e0_e0_e0_e1_var0 = mkvariable("n")
    c_init_e0_e0_e0_e0_e1_e1_succimpl0 = mkvariable("n")
    c_init_e0_e0_e0_e0_e1_e1 = succimpl(c_init_e0_e0_e0_e0_e1_e1_succimpl0)
    c_init_e0_e0_e0_e0_e1 = cl_lam(c_init_e0_e0_e0_e0_e1_var0, c_init_e0_e0_e0_e0_e1_e1)
    c_init_e0_e0_e0_e0 = cl_app(c_init_e0_e0_e0_e0_e0, c_init_e0_e0_e0_e0_e1)
    c_init_e0_e0_e0_e1_var0 = mkvariable("n")
    c_init_e0_e0_e0_e1_e1_predimpl0 = mkvariable("n")
    c_init_e0_e0_e0_e1_e1 = predimpl(c_init_e0_e0_e0_e1_e1_predimpl0)
    c_init_e0_e0_e0_e1 = cl_lam(c_init_e0_e0_e0_e1_var0, c_init_e0_e0_e0_e1_e1)
    c_init_e0_e0_e0 = cl_app(c_init_e0_e0_e0_e0, c_init_e0_e0_e0_e1)
    c_init_e0_e0_e1_var0 = mkvariable("m")
    c_init_e0_e0_e1_e1_var0 = mkvariable("n")
    c_init_e0_e0_e1_e1_e1_addimpl0 = mkvariable("m")
    c_init_e0_e0_e1_e1_e1_addimpl1 = mkvariable("n")
    c_init_e0_e0_e1_e1_e1 = addimpl(c_init_e0_e0_e1_e1_e1_addimpl0, c_init_e0_e0_e1_e1_e1_addimpl1)
    c_init_e0_e0_e1_e1 = cl_lam(c_init_e0_e0_e1_e1_var0, c_init_e0_e0_e1_e1_e1)
    c_init_e0_e0_e1 = cl_lam(c_init_e0_e0_e1_var0, c_init_e0_e0_e1_e1)
    c_init_e0_e0 = cl_app(c_init_e0_e0_e0, c_init_e0_e0_e1)
    c_init_e0_e1_var0 = mkvariable("m")
    c_init_e0_e1_e1_var0 = mkvariable("n")
    c_init_e0_e1_e1_e1_subimpl0 = mkvariable("m")
    c_init_e0_e1_e1_e1_subimpl1 = mkvariable("n")
    c_init_e0_e1_e1_e1 = subimpl(c_init_e0_e1_e1_e1_subimpl0, c_init_e0_e1_e1_e1_subimpl1)
    c_init_e0_e1_e1 = cl_lam(c_init_e0_e1_e1_var0, c_init_e0_e1_e1_e1)
    c_init_e0_e1 = cl_lam(c_init_e0_e1_var0, c_init_e0_e1_e1)
    c_init_e0 = cl_app(c_init_e0_e0, c_init_e0_e1)
    c_init_e1_var0 = mkvariable("m")
    c_init_e1_e1_var0 = mkvariable("n")
    c_init_e1_e1_e1_multimpl0 = mkvariable("m")
    c_init_e1_e1_e1_multimpl1 = mkvariable("n")
    c_init_e1_e1_e1 = multimpl(c_init_e1_e1_e1_multimpl0, c_init_e1_e1_e1_multimpl1)
    c_init_e1_e1 = cl_lam(c_init_e1_e1_var0, c_init_e1_e1_e1)
    c_init_e1 = cl_lam(c_init_e1_var0, c_init_e1_e1)
    c_init = cl_app(c_init_e0, c_init_e1)
    e_init = emptyenv()
    k_init = cl_mt()
    return c_init, e_init, k_init
  else:
    raise CEKMatchFailure("Expected p to be an e")
class CEKError(Exception):
  def __init__(self, message):
    self.message = message
  def __str__(self):
    return self.message
class CEKMatchFailure(CEKError):
  pass
class CEKUnlessFailure(CEKError):
  def __init__(self):
    pass
class CEKDone(Exception):
  def __init__(self, result):
    self.result = result

def mkvariable(name):
  return PrimVariable(name)
class PrimVariable(cl_variable):
  def __init__(self, name):
    self.literal = name
  def pprint(self, indent):
    return self.literal

def mkint(n):
  return Integer(n)
class Integer(cl_integer):
  def __init__(self, n):
    self.value = n
  def eq(self, other):
    return isinstance(other, Integer) and self.value == other.value
  def ne(self, other):
    return not self.eq(other)
  def pprint(self, indent):
    return ' ' * indent + '%s' % self.value

class UnaryPrimK(cl_k):
  def __init__(self, opname, op, ret):
    self.opname = opname
    self.op = op
    self.ret = ret
  def interpret(self, v, env):
    return self.op(v), env, self.ret
  def pprint(self, indent):
    return ' ' * indent + '(%s %s)' % (self.opname, self.ret.pprint(0))
class UnaryPrim(cl_e):
  def __init__(self, arg, opname, op):
    self.arg = arg
    self.opname = opname
    self.op = op
  def interpret(self, env, k):
    return self.arg, env, UnaryPrimK(self.opname, self.op, k)
  def pprint(self, indent):
    return ' ' * indent + '(%s %s)' % (self.opname, self.arg.pprint(0))

def zeropimpl(n):
  return UnaryPrim(n, 'zerop', lambda n: cl_true() if n.value == 0 else cl_false())
def succimpl(n):
  return UnaryPrim(n, 'succ', lambda n: Integer(n.value + 1))
def predimpl(n):
  return UnaryPrim(n, 'pred', lambda n: Integer(n.value - 1))

class BinaryPrimK1(cl_k):
  def __init__(self, arg2, env, k, opname, op):
    self.arg2 = arg2
    self.env = env
    self.k = k
    self.opname = opname
    self.op = op
  def interpret(self, v1, env):
    return self.arg2, self.env, BinaryPrimK2(v1, env, self.k, self.opname, self.op)
  def pprint(self, indent):
    return ' ' * indent + '(%s1 %s %s %s)' % (self.opname, self.arg2.pprint(0), self.env.pprint(0), self.k.pprint(0))
class BinaryPrimK2(cl_k):
  def __init__(self, v1, env, k, opname, op):
    self.v1 = v1
    self.env = env
    self.k = k
    self.opname = opname
    self.op = op
  def interpret(self, v2, env):
    return self.op(self.v1, v2), env, self.k
  def pprint(self, indent):
    return ' ' * indent + '(%s2 %s %s %s)' % (self.opname, self.v1.pprint(0), self.env.pprint(0), self.k.pprint(0))
class BinaryPrim(cl_e):
  def __init__(self, arg1, arg2, opname, op):
    self.arg1 = arg1
    self.arg2 = arg2
    self.opname = opname
    self.op = op
  def interpret(self, env, k):
    return self.arg1, env, BinaryPrimK1(self.arg2, env, k, self.opname, self.op)
def addimpl(n1, n2):
  return BinaryPrim(n1, n2, '+', lambda n1, n2: Integer(n1.value + n2.value))
def subimpl(n1, n2):
  return BinaryPrim(n1, n2, '-', lambda n1, n2: Integer(n1.value - n2.value))
def multimpl(n1, n2):
  return BinaryPrim(n1, n2, '*', lambda n1, n2: Integer(n1.value * n2.value))

class Env(cl_env):
  def __init__(self):
    pass
  def lookup(self, x):
    raise Exception("subclass responsibility")
class EmptyEnv(Env):
  def __init__(self):
    pass
  def lookup(self, y):
    raise CEKError("Variable %s not found" % y)
class ExtendedEnv(Env):
  def __init__(self, x, v, e):
    self.x = x
    self.v = v
    self.e = e
  def lookup(self, y):
    if self.x.literal == y.literal:
      return self.v
    else:
      return self.e.lookup(y)

def emptyenv():
  return EmptyEnv()
def lookup(e, x):
  return e.lookup(x)
def extend(e, x, v):
  return ExtendedEnv(x, v, e)

def pprint(v):
  print v.pprint(0)
  return v

def ret(v):
  raise CEKDone(v)

from rpython.rlib import jit
driver = jit.JitDriver(reds = ['e', 'k'],
                       greens = ['c'],
                       get_printable_location=lambda c: c.pprint(0))
def run(p):
  c, e, k = init(p)
  while True:
    driver.jit_merge_point(c = c, e = e, k = k)
    # print "c: %s, e: %s, k: %s" % (c.pprint(0), e.pprint(0), k.pprint(0))
    try:
      c, e, k = c.interpret(e, k)
      if isinstance(c, cl_app):
        driver.can_enter_jit(c = c, e = e, k = k)
    except CEKDone as d:
      return d.result
    except CEKError as err:
      print err.__str__()
      print c.pprint(0)
      return c
def main():
  program_ast_e0_var0 = mkvariable("Z")
  program_ast_e0_e1_e0_var0 = mkvariable("fib")
  program_ast_e0_e1_e0_e1_e0_e0 = mkvariable("iszero")
  program_ast_e0_e1_e0_e1_e0_e1_e0_e0 = mkvariable("-")
  program_ast_e0_e1_e0_e1_e0_e1_e0_e1_e0 = mkvariable("fib")
  program_ast_e0_e1_e0_e1_e0_e1_e0_e1_e1 = mkint(15)
  program_ast_e0_e1_e0_e1_e0_e1_e0_e1 = cl_app(program_ast_e0_e1_e0_e1_e0_e1_e0_e1_e0, program_ast_e0_e1_e0_e1_e0_e1_e0_e1_e1)
  program_ast_e0_e1_e0_e1_e0_e1_e0 = cl_app(program_ast_e0_e1_e0_e1_e0_e1_e0_e0, program_ast_e0_e1_e0_e1_e0_e1_e0_e1)
  program_ast_e0_e1_e0_e1_e0_e1_e1 = mkint(610)
  program_ast_e0_e1_e0_e1_e0_e1 = cl_app(program_ast_e0_e1_e0_e1_e0_e1_e0, program_ast_e0_e1_e0_e1_e0_e1_e1)
  program_ast_e0_e1_e0_e1_e0 = cl_app(program_ast_e0_e1_e0_e1_e0_e0, program_ast_e0_e1_e0_e1_e0_e1)
  program_ast_e0_e1_e0_e1_e1_var0 = mkvariable("success")
  program_ast_e0_e1_e0_e1_e1_e1 = mkvariable("success")
  program_ast_e0_e1_e0_e1_e1 = cl_lam(program_ast_e0_e1_e0_e1_e1_var0, program_ast_e0_e1_e0_e1_e1_e1)
  program_ast_e0_e1_e0_e1_e2_var0 = mkvariable("failure")
  program_ast_e0_e1_e0_e1_e2_e1 = mkvariable("failure")
  program_ast_e0_e1_e0_e1_e2 = cl_lam(program_ast_e0_e1_e0_e1_e2_var0, program_ast_e0_e1_e0_e1_e2_e1)
  program_ast_e0_e1_e0_e1 = cl_if(program_ast_e0_e1_e0_e1_e0, program_ast_e0_e1_e0_e1_e1, program_ast_e0_e1_e0_e1_e2)
  program_ast_e0_e1_e0 = cl_lam(program_ast_e0_e1_e0_var0, program_ast_e0_e1_e0_e1)
  program_ast_e0_e1_e1_e0 = mkvariable("Z")
  program_ast_e0_e1_e1_e1_var0 = mkvariable("fib0")
  program_ast_e0_e1_e1_e1_e1_var0 = mkvariable("n")
  program_ast_e0_e1_e1_e1_e1_e1_e0_e0 = mkvariable("iszero")
  program_ast_e0_e1_e1_e1_e1_e1_e0_e1 = mkvariable("n")
  program_ast_e0_e1_e1_e1_e1_e1_e0 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e0_e0, program_ast_e0_e1_e1_e1_e1_e1_e0_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e1 = mkint(0)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e0 = mkvariable("iszero")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e0_e0 = mkvariable("-")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e0_e1 = mkvariable("n")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e0 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e0_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e0_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e1 = mkint(1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e0 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e0_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e1 = mkint(1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e0 = mkvariable("+")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e0 = mkvariable("fib0")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e0_e0 = mkvariable("-")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e0_e1 = mkvariable("n")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e0 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e0_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e0_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e1 = mkint(1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e0 = mkvariable("fib0")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e0_e0 = mkvariable("-")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e0_e1 = mkvariable("n")
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e0 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e0_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e0_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e1 = mkint(2)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2_e2 = cl_app(program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e2_e1)
  program_ast_e0_e1_e1_e1_e1_e1_e2 = cl_if(program_ast_e0_e1_e1_e1_e1_e1_e2_e0, program_ast_e0_e1_e1_e1_e1_e1_e2_e1, program_ast_e0_e1_e1_e1_e1_e1_e2_e2)
  program_ast_e0_e1_e1_e1_e1_e1 = cl_if(program_ast_e0_e1_e1_e1_e1_e1_e0, program_ast_e0_e1_e1_e1_e1_e1_e1, program_ast_e0_e1_e1_e1_e1_e1_e2)
  program_ast_e0_e1_e1_e1_e1 = cl_lam(program_ast_e0_e1_e1_e1_e1_var0, program_ast_e0_e1_e1_e1_e1_e1)
  program_ast_e0_e1_e1_e1 = cl_lam(program_ast_e0_e1_e1_e1_var0, program_ast_e0_e1_e1_e1_e1)
  program_ast_e0_e1_e1 = cl_app(program_ast_e0_e1_e1_e0, program_ast_e0_e1_e1_e1)
  program_ast_e0_e1 = cl_app(program_ast_e0_e1_e0, program_ast_e0_e1_e1)
  program_ast_e0 = cl_lam(program_ast_e0_var0, program_ast_e0_e1)
  program_ast_e1_var0 = mkvariable("f")
  program_ast_e1_e1_e0_var0 = mkvariable("x")
  program_ast_e1_e1_e0_e1_e0 = mkvariable("f")
  program_ast_e1_e1_e0_e1_e1_var0 = mkvariable("v")
  program_ast_e1_e1_e0_e1_e1_e1_e0_e0 = mkvariable("x")
  program_ast_e1_e1_e0_e1_e1_e1_e0_e1 = mkvariable("x")
  program_ast_e1_e1_e0_e1_e1_e1_e0 = cl_app(program_ast_e1_e1_e0_e1_e1_e1_e0_e0, program_ast_e1_e1_e0_e1_e1_e1_e0_e1)
  program_ast_e1_e1_e0_e1_e1_e1_e1 = mkvariable("v")
  program_ast_e1_e1_e0_e1_e1_e1 = cl_app(program_ast_e1_e1_e0_e1_e1_e1_e0, program_ast_e1_e1_e0_e1_e1_e1_e1)
  program_ast_e1_e1_e0_e1_e1 = cl_lam(program_ast_e1_e1_e0_e1_e1_var0, program_ast_e1_e1_e0_e1_e1_e1)
  program_ast_e1_e1_e0_e1 = cl_app(program_ast_e1_e1_e0_e1_e0, program_ast_e1_e1_e0_e1_e1)
  program_ast_e1_e1_e0 = cl_lam(program_ast_e1_e1_e0_var0, program_ast_e1_e1_e0_e1)
  program_ast_e1_e1_e1_var0 = mkvariable("x")
  program_ast_e1_e1_e1_e1_e0 = mkvariable("f")
  program_ast_e1_e1_e1_e1_e1_var0 = mkvariable("v")
  program_ast_e1_e1_e1_e1_e1_e1_e0_e0 = mkvariable("x")
  program_ast_e1_e1_e1_e1_e1_e1_e0_e1 = mkvariable("x")
  program_ast_e1_e1_e1_e1_e1_e1_e0 = cl_app(program_ast_e1_e1_e1_e1_e1_e1_e0_e0, program_ast_e1_e1_e1_e1_e1_e1_e0_e1)
  program_ast_e1_e1_e1_e1_e1_e1_e1 = mkvariable("v")
  program_ast_e1_e1_e1_e1_e1_e1 = cl_app(program_ast_e1_e1_e1_e1_e1_e1_e0, program_ast_e1_e1_e1_e1_e1_e1_e1)
  program_ast_e1_e1_e1_e1_e1 = cl_lam(program_ast_e1_e1_e1_e1_e1_var0, program_ast_e1_e1_e1_e1_e1_e1)
  program_ast_e1_e1_e1_e1 = cl_app(program_ast_e1_e1_e1_e1_e0, program_ast_e1_e1_e1_e1_e1)
  program_ast_e1_e1_e1 = cl_lam(program_ast_e1_e1_e1_var0, program_ast_e1_e1_e1_e1)
  program_ast_e1_e1 = cl_app(program_ast_e1_e1_e0, program_ast_e1_e1_e1)
  program_ast_e1 = cl_lam(program_ast_e1_var0, program_ast_e1_e1)
  program_ast = cl_app(program_ast_e0, program_ast_e1)
  result = run(program_ast)
  return result
if __name__ == "__main__":
  main()