var TAG_CONS = 0;
var TAG_SYMBOL = 1;
var TAG_NUM = 2;
var TAG_SUBR = 3;
var TAG_FSUBR = 4;
var TAG_SPECIAL = 5;
var TAG_EXPR = 6;
var TAG_FEXPR = 7;
var symbol_table = new Array();
var nil = CreateSymbol("nil");
var sharp_t = CreateSymbol("#t");
var sharp_f = CreateSymbol("#f");
var topEnv = null;

function CAR(x) {
  if (x == nil)
    return nil;
  return x.data.CAR();
}
function CDR(x) {
  if (x == nil)
    return nil;
  return x.data.CDR();
}
function SetCAR(x, val) {
  x.data.car = val;
}
function SetCDR(x, val) {
  x.data.cdr = val;
}

function CreateCons() {
  return new LObject(TAG_CONS);
}
function Cons() {
  this.car = nil;
  this.cdr = nil;
  this.SetCAR = function(val) {this.car = val;};
  this.SetCDR = function(val) {this.cdr = val;};
  this.CAR = function() {return this.car;}
  this.CDR = function() {return this.cdr;}
}
function Symbol(str) {
  this.name = str;
  this.GetName = function() {return this.name;};
}

function CreateSymbol(str) {
  var i, ret;
  for (i=0; i<symbol_table.length; i++) {
    if (str == symbol_table[i].data.GetName())
      return symbol_table[i];
  }
  ret = new LObject(TAG_SYMBOL);
  ret.data = new Symbol(str)
  symbol_table[i] = ret;
  return ret;
}

function GetNum(n) {
  return n.data.GetNum();
}

function CreateNum(val) {
  var ret = new LObject(TAG_NUM);
  ret.data = new Num(val);
  return ret;
}
function Num(val) {
  this.num = val;
  this.GetNum = function() {return this.num;};
}
function CreateSUBR(f) {
  var ret = new LObject(TAG_SUBR);
  ret.data = new SUBR(f);
  return ret;
}
function SUBR(f) {
  this.func = f;
  this.Call = function(args) {return this.func(args);};
}
function CreateFSUBR(f) {
  var ret = new LObject(TAG_FSUBR);
  ret.data = new FSUBR(f);
  return ret;
}
function FSUBR(f) {
  this.func = f;
  this.Call = function(args, env) {return this.func(args, env);};
}
function CreateEXPR(f, a, e) {
  var ret = new LObject(TAG_EXPR);
  ret.data = new EXPR(f, a, e);
  return ret;
}
function EXPR(f, a, e) {
  this.forms = f;
  this.args = a;
  this.env = e;
  this.GetForms = function() {return this.forms;};
  this.GetArgs = function() {return this.args;};
  this.GetEnv = function() {return this.env;};
}
function CreateFEXPR(f, a, e) {
  var ret = new LObject(TAG_FEXPR);
  ret.data = new FEXPR(f, a, e);
  return ret;
}
function FEXPR(f, a, e) {
  this.forms = f;
  this.args = a;
  this.env = e;
  this.GetForms = function() {return this.forms;};
  this.GetArgs = function() {return this.args;};
  this.GetEnv = function() {return this.env;};
}
function LObject(tag) {
  this.flag = 0;
  this.tag = tag;
  if (tag == TAG_CONS)
    this.data = new Cons();
  else
    this.data = null;
  this.toString = function() {
    var ret = this.data;
    return ret;
  };
}
function MakeReader(src) {
  return function () {
      var i = 0, j;
      var ret;
      if (src == "")
        return "";
      while (src.charAt(i) == ' ' || src.charAt(i) == '\r' ||
          src.charAt(i) == '\n' || src.charAt(i) == '\t') {
        i++;
      }
      if (src.charAt(i) == '(' || src.charAt(i) == ')' || src.charAt(i) == '.' || src.charAt(i) == '\'') {
        ret = src.substring(i, i+1);
        src = src.substring(i+1, src.length);
        return ret;
      }
      j = i;
      while ((src.charAt(j) != '(' && src.charAt(j) != ')' &&  src.charAt(j) != '\'' &&
          src.charAt(j) != ' ' && src.charAt(j) != '\t' && src.charAt(j) != '\r' && src.charAt(j) != '\n') &&
          j < src.length)
        j++;
      ret = src.substring(i, j);
      src = src.substring(j, src.length);
      return ret;
    };
}

function CreateSpecial(str) {
  var ret = new LObject(TAG_SPECIAL);
  ret.data = str;
  return ret;
}

function isNumber(str) {
  var i = 0;
  if (str.charAt(0) == '-') {
    i++;
    if (str.length == 1)
      return false;
  }
  for ( ; i<str.length; i++) {
    if (str.charAt(i) != '0' && str.charAt(i) != '1' &&
        str.charAt(i) != '2' && str.charAt(i) != '3' &&
        str.charAt(i) != '4' && str.charAt(i) != '5' &&
        str.charAt(i) != '6' && str.charAt(i) != '7' &&
        str.charAt(i) != '8' && str.charAt(i) != '9')
      return false;
  }
  return true
}

function TranslateInput(str) {
  var r = MakeReader(str);
  return InputToLObject(r);
}

function InputToLObject(r) {
  var x = r();

  if (x == "(")
    return InputToList(r);
  if (x == "\'") {
    var tmp1 = CreateCons();
    var tmp2 = CreateCons();
    SetCAR(tmp1, CreateSymbol("quote"));
    SetCDR(tmp1, tmp2);
    SetCAR(tmp2, InputToLObject(r));
    SetCDR(tmp2, nil);
    return tmp1;
  }
  if (x == ")" || x == ".")
    return CreateSpecial(x);
  if (isNumber(x))
    return CreateNum(parseInt(x));
  return CreateSymbol(x);
}

function InputToList(r) {
  var ret = CreateCons();
  var current = ret;
  var tmp, elm;
  for (;;) {
    elm = InputToLObject(r);
    if (elm.tag == TAG_SPECIAL) {
      if (elm.data == ")") {
        SetCDR(current, nil);
        return CDR(ret);
      }
      if (elm.data == ".") {
        SetCDR(current, InputToLObject(r));
        r(); /* must be ')' */
        return CDR(ret);
      }        
    }
    tmp = CreateCons();
    SetCAR(tmp, elm);
    SetCDR(current, tmp);
    current = tmp;
  }
  return nil;
}

function CreateNewEnv() {
  var ret, tmp;
  ret = CreateCons();
  tmp = CreateCons();
  SetCAR(tmp, CreateSymbol("environment"));
  SetCDR(tmp, CreateSymbol("dummy"));
  SetCAR(ret, tmp);
  SetCDR(ret, nil);
  return ret;
}

function AddBindToEnv(env, name, val) {
  var rest, tmp, pair;
  rest = CDR(env);
  tmp = CreateCons();
  SetCDR(env, tmp);
  SetCDR(tmp, rest);
  pair = CreateCons();
  SetCAR(pair, name);
  SetCDR(pair, val);
  SetCAR(tmp, pair);
  return env;
}

function Assoc(key, lst) {
  ret = nil;
  while (lst != nil) {
    if (key == CAR(CAR(lst)))
      return CAR(lst);
    lst = CDR(lst)
  }
  return nil;
}

function Nconc(lst, x) {
  p = lst
  while (CDR(p) != nil)
    p = CDR(p);
  SetCDR(p, x);
}

function Eval(s, env) {
  if (s.tag == TAG_NUM)
    return s;
  if (s.tag == TAG_SYMBOL)
    return CDR(Assoc(s, env));
  if (s.tag == TAG_CONS)
    return Apply(Eval(CAR(s), env), CDR(s), env);
}

function Apply(fn, args, env) {
  if (fn.tag == TAG_SUBR || fn.tag == TAG_EXPR)
    args = Evlis(args, env);
  if (fn.tag == TAG_SUBR)
    return fn.data.Call(args);
  if (fn.tag == TAG_FSUBR) {
    return fn.data.Call(args, env);
  }
  if (fn.tag == TAG_EXPR) {
    var new_env = CreateEXPREnv(args, fn);
    return LF_begin(fn.data.GetForms(), new_env);
  }
  if (fn.tag == TAG_FEXPR) {
    var new_env = CreateFEXPREnv(args, fn, env);
    return LF_begin(fn.data.GetForms(), new_env);
  }
  return nil;
}

function Evlis(args, env) {
  var p = args, tmp;
  var ret = CreateCons();
  var current = ret;
  while (p != nil) {
    tmp = CreateCons();
    SetCAR(tmp, Eval(CAR(p), env));
    SetCDR(current, tmp);
    current = tmp;
    p = CDR(p);
  }
  SetCDR(current, nil);
  return CDR(ret);
}

function CreateEXPREnv(args, fn) {
  var ret = CreateNewEnv();
  var p = fn.data.GetArgs();
  var q = args;
  while (p != nil) {
    if (p.tag == TAG_SYMBOL) {
      AddBindToEnv(ret, p, q);
      break;
    }
    AddBindToEnv(ret, CAR(p), CAR(q));
    p = CDR(p);
    q = CDR(q);
  }
  Nconc(ret, fn.data.GetEnv());
  return ret;
}

function CreateFEXPREnv(args, fn, env) {
  var ret = CreateNewEnv();
  var p = fn.data.GetArgs();
  AddBindToEnv(ret, CAR(p), args);
  p = CDR(p);
  AddBindToEnv(ret, CAR(p), env);
  Nconc(ret, fn.data.GetEnv());
  return ret;
}

function LF_car(s) {
  var x = CAR(s);
  if (x == nil)
    return nil;
  return CAR(x);
}
function LF_cdr(s) {
  var x = CAR(s);
  if (x == nil)
    return nil;
  return CDR(x);
}
function LF_cons(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  var ret = CreateCons();
  SetCAR(ret, x);
  SetCDR(ret, y);
  return ret;
}
function LF_eq(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  if (x.tag == TAG_NUM && y.tag == TAG_NUM && GetNum(x) == GetNum(y))
    return sharp_t;
  if (x == y)
    return sharp_t;
  return sharp_f;
}
function LF_atom(s) {
  var x = CAR(s);
  if (x.tag != TAG_CONS)
    return sharp_t;
  return sharp_f;
}
function LF_booleanp(s) {
  var x = CAR(s);
  if (x == sharp_t || x == sharp_f)
    return sharp_t;
  return sharp_f;
}
function LF_pairp(s) {
  var x = CAR(s);
  if (x.tag == TAG_CONS)
    return sharp_t;
  return sharp_f;
}
function LF_listp(s) {
  var x = CAR(s);
  while (x.tag == TAG_CONS)
    x = CDR(x);
  if (x == nil);
    return sharp_t;
  return sharp_f;
}
function LF_numberp(s) {
  var x = CAR(s);
  if (x.tag == TAG_NUM)
    return sharp_t;
  return sharp_f;
}
function LF_procedurep(s) {
  var x = CAR(s);
  if (x.tag == TAG_SUBR || x.tag == TAG_FSUBR || x.tag == TAG_EXPR || x.tag == TAG_FEXPR)
    return sharp_t;
  return sharp_f;
}
function LF_symbolp(s) {
  var x = CAR(s);
  if (x.tag == TAG_SYMBOL && x != sharp_t && x != sharp_f)
    return sharp_t;
  return sharp_f;
}
function LF_set_car(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  if (x.tag != TAG_CONS)
    return sharp_f;
  SetCAR(x, y);
  return sharp_t;
}
function LF_set_cdr(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  if (x.tag != TAG_CONS)
    return sharp_f;
  SetCDR(x, y);
  return sharp_t;
}
function LF_add(s) {
  var n = 0
  while (s != nil) {
    n += GetNum(CAR(s));
    s = CDR(s);
  }
  return CreateNum(n);
}
function LF_sub(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  return CreateNum(GetNum(x) - GetNum(y));
}
function LF_mul(s) {
  var n = 1;
  while (s != nil) {
    n *= GetNum(CAR(s));
    s = CDR(s);
  }
  return CreateNum(n);
}
function LF_div(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  return CreateNum(GetNum(x) / GetNum(y));
}
function LF_mod(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  return CreateNum(GetNum(x) & GetNum(y));
}
function LF_gt(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  if (GetNum(x) > GetNum(y))
    return sharp_t;
  return sharp_f;
}
function LF_ge(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  if (GetNum(x) >= GetNum(y))
    return sharp_t;
  return sharp_f;
}
function LF_ls(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  if (GetNum(x) < GetNum(y))
    return sharp_t;
  return sharp_f;
}
function LF_le(s) {
  var x = CAR(s);
  var y = CAR(CDR(s));
  if (GetNum(x) <= GetNum(y))
    return sharp_t;
  return sharp_f;
}
function LF_quote(s, env) {
  return CAR(s);
}
function LF_begin(s, env) {
  var ret = nil;
  while (s != nil) {
    ret = Eval(CAR(s), env);
    s = CDR(s);
  }
  return ret;
}
function LF_lambda(s, env) {
  var a = CAR(s);
  var f = CDR(s);
  return CreateEXPR(f, a, env);
}
function LF_nlambda(s, env) {
  var a = CAR(s);
  var f = CDR(s);
  return CreateFEXPR(f, a, env);
}
function LF_cond(s, env) {
  while (s != nil) {
    if (Eval(CAR(CAR(s)), env) != sharp_f)
      return LF_begin(CDR(CAR(s)), env);
    s = CDR(s);
  }
  return nil;
}
function LF_if(s, env) {
  if (Eval(CAR(s), env) != sharp_f)
    return Eval(CAR(CDR(s)), env);
   return Eval(CAR(CDR(CDR(s))), env);
}
function LF_define(s, env) {
  var name = CAR(s);
  var val = CAR(CDR(s));
  var bind;
  val = Eval(val, env);
  bind = CreateCons();
  SetCAR(bind, name);
  SetCDR(bind, val);
  AddBindToEnv(env, name, val);
  return name;
}
function LF_set(s, env) {
  var name = CAR(s);
  var val = CAR(CDR(s));
  var bind = Assoc(name, env);
  if (bind == nil)
    return LF_define(s, env);
  val = Eval(val, env);
  SetCDR(bind, val);
  return name;
}
function LF_eval(s, env) {
  var f = CAR(s);
  var e = CDR(s);
  if (e == nil)
    e = env;
  else {
    e = CAR(e);
    e = Eval(e, env);
  }
  f = Eval(f, env);
  return Eval(f, e);
}
function LF_apply(s, env) {
  var fn = CAR(s);
  var args = CAR(CDR(s));
  var e = CDR(CDR(s));
  if (e == nil)
    e = env;
  else {
    e = CAR(e);
    e = Eval(e, env);
  }
  fn = Eval(fn, env);
  args = Eval(args, env);
  return Apply(fn, args, env);
}

function LObjectToString(s)
{
  if (s.tag == TAG_NUM)
    return ""+GetNum(s);
  if (s.tag == TAG_SYMBOL)
    return s.data.GetName();
  if (s.tag == TAG_CONS)
    return ConsToString(s);
  if (s.tag == TAG_SUBR)
    return "SUBR";
  if (s.tag == TAG_FSUBR)
    return "FSUBR";
  if (s.tag == TAG_EXPR)
    return "EXPR";
  if (s.tag == TAG_FEXPR)
    return "FEXPR";
  return "";
}

function ConsToString(s) {
  var ret = "(";
  var tmp1, tmp2;
  for (;;) {
    tmp1 = LObjectToString(CAR(s));
    if (CDR(s).tag != TAG_CONS) {
      if (CDR(s) == nil)
        ret += tmp1;
      else {
        tmp2 = LObjectToString(CDR(s));
        ret += tmp1 + " . " + tmp2;
      }
      break;
    }
    ret += tmp1 + " ";
    s = CDR(s);
  }
  ret += ")";
  return ret;
}

topEnv = CreateNewEnv();
AddBindToEnv(topEnv, CreateSymbol("nil"), CreateSymbol("nil"));
AddBindToEnv(topEnv, CreateSymbol("#t"), CreateSymbol("#t"));
AddBindToEnv(topEnv, CreateSymbol("#f"), CreateSymbol("#f"));
AddBindToEnv(topEnv, CreateSymbol("else"), CreateSymbol("#t"));
AddBindToEnv(topEnv, CreateSymbol("car"), CreateSUBR(LF_car));
AddBindToEnv(topEnv, CreateSymbol("cdr"), CreateSUBR(LF_cdr));
AddBindToEnv(topEnv, CreateSymbol("cons"), CreateSUBR(LF_cons));
AddBindToEnv(topEnv, CreateSymbol("eq?"), CreateSUBR(LF_eq));
AddBindToEnv(topEnv, CreateSymbol("atom?"), CreateSUBR(LF_atom));
AddBindToEnv(topEnv, CreateSymbol("boolean?"), CreateSUBR(LF_booleanp));
AddBindToEnv(topEnv, CreateSymbol("pair?"), CreateSUBR(LF_pairp));
AddBindToEnv(topEnv, CreateSymbol("list?"), CreateSUBR(LF_listp));
AddBindToEnv(topEnv, CreateSymbol("number?"), CreateSUBR(LF_numberp));
AddBindToEnv(topEnv, CreateSymbol("procedure?"), CreateSUBR(LF_procedurep));
AddBindToEnv(topEnv, CreateSymbol("symbol?"), CreateSUBR(LF_booleanp));
AddBindToEnv(topEnv, CreateSymbol("set-car!"), CreateSUBR(LF_set_car));
AddBindToEnv(topEnv, CreateSymbol("set-cdr!"), CreateSUBR(LF_set_cdr));
AddBindToEnv(topEnv, CreateSymbol("+"), CreateSUBR(LF_add));
AddBindToEnv(topEnv, CreateSymbol("-"), CreateSUBR(LF_sub));
AddBindToEnv(topEnv, CreateSymbol("*"), CreateSUBR(LF_mul));
AddBindToEnv(topEnv, CreateSymbol("/"), CreateSUBR(LF_div));
AddBindToEnv(topEnv, CreateSymbol("mod"), CreateSUBR(LF_mod));
AddBindToEnv(topEnv, CreateSymbol(">"), CreateSUBR(LF_gt));
AddBindToEnv(topEnv, CreateSymbol(">="), CreateSUBR(LF_ge));
AddBindToEnv(topEnv, CreateSymbol("<"), CreateSUBR(LF_ls));
AddBindToEnv(topEnv, CreateSymbol("<="), CreateSUBR(LF_le));
AddBindToEnv(topEnv, CreateSymbol("quote"), CreateFSUBR(LF_quote));
AddBindToEnv(topEnv, CreateSymbol("lambda"), CreateFSUBR(LF_lambda));
AddBindToEnv(topEnv, CreateSymbol("nlambda"), CreateFSUBR(LF_nlambda));
AddBindToEnv(topEnv, CreateSymbol("cond"), CreateFSUBR(LF_cond));
AddBindToEnv(topEnv, CreateSymbol("if"), CreateFSUBR(LF_if));
AddBindToEnv(topEnv, CreateSymbol("begin"), CreateFSUBR(LF_begin));
AddBindToEnv(topEnv, CreateSymbol("define"), CreateFSUBR(LF_define));
AddBindToEnv(topEnv, CreateSymbol("set!"), CreateFSUBR(LF_set));
AddBindToEnv(topEnv, CreateSymbol("eval"), CreateFSUBR(LF_eval));
AddBindToEnv(topEnv, CreateSymbol("apply"), CreateFSUBR(LF_apply));

Eval(TranslateInput("(define = eq?)"), topEnv);
Eval(TranslateInput("(define caar (lambda (x) (car (car x))))"), topEnv);
Eval(TranslateInput("(define cadr (lambda (x) (car (cdr x))))"), topEnv);
Eval(TranslateInput("(define cdar (lambda (x) (cdr (car x))))"), topEnv);
Eval(TranslateInput("(define cddr (lambda (x) (cdr (cdr x))))"), topEnv);
Eval(TranslateInput("(define null? (lambda (x) (eq? x nil)))"), topEnv);
Eval(TranslateInput("(define not (lambda (x) (eq? x #f)))"), topEnv);
Eval(TranslateInput("(define list (lambda x x))"), topEnv);
Eval(TranslateInput("(define not (lambda (x) (eq? x #f)))"), topEnv);
Eval(TranslateInput("(define assoc (lambda (key lst) (cond ((eq? lst nil) nil)((eq? key (caar lst)) (car lst)) (else (assoc key (cdr lst))))))"), topEnv);
Eval(TranslateInput("(define length (lambda (lst) (length-iter 0 lst)))"), topEnv);
Eval(TranslateInput("(define length-iter (lambda (n lst) (cond ((null? lst) n) (else (length-iter (+ n 1) (cdr lst))))))"), topEnv);
Eval(TranslateInput("(define append (lambda (x y) (cond ((null? x) y) (else (cons (car x) (append (cdr x) y))))))"), topEnv);
Eval(TranslateInput("(define list-tail (lambda (lst n) (cond ((eq? n 0) lst) (else (list-tail (cdr lst) (- n 1))))))"), topEnv);
Eval(TranslateInput("(define list-ref (lambda (lst n) (car (list-tail lst n))))"), topEnv);
Eval(TranslateInput("(define and (nlambda (s env) (cond ((null? s) #t) (else (and-iter (cdr s) (eval (car s) env) env)))))"), topEnv);
Eval(TranslateInput("(define and-iter (lambda (lst result env) (cond ((null? lst) result) ((not result) #f) (else (and-iter (cdr lst) (eval (car lst) env) env)))))"), topEnv);
Eval(TranslateInput("(define or (nlambda (s env) (cond ((null? s) #t) (else (or-iter (cdr s) (eval (car s) env) env)))))"), topEnv);
Eval(TranslateInput("(define or-iter (lambda (lst result env) (cond ((null? lst) result) (result result) (else (or-iter (cdr lst) (eval (car lst) env) env)))))"), topEnv);
Eval(TranslateInput("(define equal? (lambda (x y) (or (eq? x y) (and (pair? x) (pair? y) (equal? (car x) (car y)) (equal? (cdr x) (cdr y))))))"), topEnv);
Eval(TranslateInput("(define map-get-arg (lambda (lst) (cond ((null? lst) nil) (else (cons (caar lst) (map-get-arg (cdr lst)))))))"), topEnv);
Eval(TranslateInput("(define map-get-next-list-iter (lambda (lst) (cond ((null? lst) nil) (else (cons (cdar lst) (map-get-next-list-iter (cdr lst)))))))"), topEnv);
Eval(TranslateInput("(define map-get-next-list (lambda (lst) (let ((x (map-get-next-list-iter lst))) (cond ((memq nil x) nil) (else x)))))"), topEnv);
Eval(TranslateInput("(define map (nlambda (s env) (let ((fn (car s)) (lst (cdr s))) (apply map-iter (cons fn (eval-car lst env)) env))))"), topEnv);
Eval(TranslateInput("(define map-iter (nlambda (s env) (let ((fn (car s)) (lst (cdr s))) (cond ((null? lst) nil) (else (cons (apply (eval fn) (map-get-arg lst) env) (apply map-iter (cons fn (map-get-next-list lst)) env)))))))"), topEnv);
Eval(TranslateInput("(define let-get-formarg (lambda (lst) (cond ((null? lst) nil) (else (cons (caar lst) (let-get-formarg (cdr lst)))))))"), topEnv);
Eval(TranslateInput("(define let-get-actarg (lambda (lst) (cond ((null? lst) nil) (else (cons (car (cdar lst)) (let-get-actarg (cdr lst)))))))"), topEnv);
Eval(TranslateInput("(define let (nlambda (s env) ((lambda (def actarg) (apply def actarg env)) (apply lambda  (cons (let-get-formarg (car s)) (cdr s)) env) (let-get-actarg (car s)))))"), topEnv);
//Eval(TranslateInput("(define if (nlambda (s env) (apply cond (list (list (car s) (cadr s)) (list 'else (car (cddr s)))) env)))"), topEnv);
//Eval(TranslateInput("(define if_ (lambda (s env) (list (list (car s) (cadr s)) (list 'else (car (cddr s)))) ))"), topEnv);

function EvalButton() {
  str = document.getElementById("inp").value;
  document.getElementById("oup").innerHTML =
    LObjectToString(Eval(TranslateInput(str), topEnv)) + "<br>" + document.getElementById("oup").innerHTML
  document.getElementById("inp").value = "";
}