(define (simple exp)
  (define (flat lst op)
    (append-map! (lambda (x)
                   (if (and (pair? x) (eq? (car x) op))
                       (flat (cdr x) op)
                       (list x)))
                 lst))
 
  (define (constant-fold args init op)
    (define (cf args num acc)
      (cond ((null? args)
             (values acc num))
            ((number? (car args))
             (cf (cdr args) (op num (car args)) acc))
            (else
             (cf (cdr args) num (append! acc (list (car args)))))))
    (cf args init '() ))
 
  (define (simple-+ args)
    (set! args (map simple args))
    (set! args (flat args '+))
    (receive (exps num) (constant-fold args 0 +)
     (cond ((null? exps) num)
           (else `(+ ,@args num)))))
 
  (define (simple-* args)
    (call/cc
     (lambda (c)
       (set! args (map simple args))
       (set! args (flat args '*))
       (map (lambda (x)
              (when (and (number? x) (= x 0))
                    (c 0)))
            args)
       (set! args (constant-fold args 1 *))
       (set! args (remove (lambda (x)
                            (and (number? x)(= x 1)))
                          args))
       (if (= 1 (length args))
           (car args)
           `(* ,@args)))))
 
  (define (simple-expt base ex)
    (set! base (simple base))
    (set! ex (simple ex))
    (cond ((or (and (number? base) (= base 1))
               (and (number? ex) (= ex 0)))
           1)
          ((or (and (number? base) (= base 0))
               (and (number? ex) (= ex 1)))
           base)
          (else
           `(expt ,base ,ex))))
 
  (define (simple-- arg)
    (cond ((number? arg) (- arg))
          ((and (pair? arg)
                (eq? (car arg) '+))
           (simple-+ (map (lambda (x) (list '- x))
                          (cdr arg))))
          ((and (pair? arg)
                (eq? (car arg) '*))
           (simple-* (map (lambda (x) (list '- x))
                          (cdr arg))))
          (else
           `(- ,arg))))
 
  (cond ((not (pair? exp)) exp)
        ((eq? (car exp) '-)
         (simple-- (cadr exp)))
        ((eq? (car exp) '+)
         (simple-+ (cdr exp)))
        ((eq? (car exp) '*)
         (simple-* (cdr exp)))
        ((eq? (car exp) 'expt)
         (simple-expt (cadr exp) (caddr exp)))
        (else
         `(,(car exp) ,@(map simple (cdr exp))))))

(define (deriv exp var)
  (cond ((eq? exp var) 1)
	((not (pair? exp)) 0)
	((eq? (car exp) '-)
	 `(- ,(deriv (cadr exp) var)))
	((eq? (car exp) '+)
	 `(+ ,(deriv (cadr exp) var) ,(deriv (caddr exp) var)))
	((eq? (car exp) '*)
	 `(+ (* ,(deriv (cadr exp) var)
		,(caddr exp))
	     (* ,(cadr exp)
		,(deriv (caddr exp) var))))
	((eq? (car exp) 'expt)
	 (let ((g (cadr exp))
	       (n (caddr exp)))
	   `(* (* ,n (expt ,g ,(- n 1))) ,(deriv g var))))
	((eq? (car exp) 'sin)
	 `(* (cos ,(cadr exp)) ,(deriv (cadr exp) var)))
	((eq? (car exp) 'cos)
	 `(* (- (sin ,(cadr exp))) ,(deriv (cadr exp) var)))
        ((eq? (car exp) 'tan)
         `(* (+ 1 (expt ,exp 2)) ,(deriv (cadr exp) var)))
	(else (error "not yet."))))

var b64_table = [
    '\x00','\x01','\x02','\x03','\x04','\x05','\x06','\x07',
    '\x08','\x09','\x0A','\x0B','\x0C','\x0D','\x0E','\x0F',
    '\x10','\x11','\x12','\x13','\x14','\x15','\x16','\x17',
    '\x18','\x19','\x1A','\x1B','\x1C','\x1D','\x1E','\x1F',
    '\x20','\x21','\x22','\x23','\x24','\x25','\x26','\x27',
    '\x28','\x29','\x2A','\x2B','\x2C','\x2D','\x2E','\x2F',
    '\x30','\x31','\x32','\x33','\x34','\x35','\x36','\x37',
    '\x38','\x39','\x3A','\x3B','\x3C','\x3D','\x3E','\x3F',
    '\x40','\x41','\x42','\x43','\x44','\x45','\x46','\x47',
    '\x48','\x49','\x4A','\x4B','\x4C','\x4D','\x4E','\x4F',
    '\x50','\x51','\x52','\x53','\x54','\x55','\x56','\x57',
    '\x58','\x59','\x5A','\x5B','\x5C','\x5D','\x5E','\x5F',
    '\x60','\x61','\x62','\x63','\x64','\x65','\x66','\x67',
    '\x68','\x69','\x6A','\x6B','\x6C','\x6D','\x6E','\x6F',
    '\x70','\x71','\x72','\x73','\x74','\x75','\x76','\x77',
    '\x78','\x79','\x7A','\x7B','\x7C','\x7D','\x7E','\x7F',
    '\x80','\x81','\x82','\x83','\x84','\x85','\x86','\x87',
    '\x88','\x89','\x8A','\x8B','\x8C','\x8D','\x8E','\x8F',
    '\x90','\x91','\x92','\x93','\x94','\x95','\x96','\x97',
    '\x98','\x99','\x9A','\x9B','\x9C','\x9D','\x9E','\x9F',
    '\xA0','\xA1','\xA2','\xA3','\xA4','\xA5','\xA6','\xA7',
    '\xA8','\xA9','\xAA','\xAB','\xAC','\xAD','\xAE','\xAF',
    '\xB0','\xB1','\xB2','\xB3','\xB4','\xB5','\xB6','\xB7',
    '\xB8','\xB9','\xBA','\xBB','\xBC','\xBD','\xBE','\xBF',
    '\xC0','\xC1','\xC2','\xC3','\xC4','\xC5','\xC6','\xC7',
    '\xC8','\xC9','\xCA','\xCB','\xCC','\xCD','\xCE','\xCF',
    '\xD0','\xD1','\xD2','\xD3','\xD4','\xD5','\xD6','\xD7',
    '\xD8','\xD9','\xDA','\xDB','\xDC','\xDD','\xDE','\xDF',
    '\xE0','\xE1','\xE2','\xE3','\xE4','\xE5','\xE6','\xE7',
    '\xE8','\xE9','\xEA','\xEB','\xEC','\xED','\xEE','\xEF',
    '\xF0','\xF1','\xF2','\xF3','\xF4','\xF5','\xF6','\xF7',
    '\xF8','\xF9','\xFA','\xFB','\xFC','\xFD','\xFE','\xFF'
];
 
function b64_decode_char(c){
    if('A' <= c && c <= 'Z'){
        return c.charCodeAt(0) - 'A'.charCodeAt(0);
    }
    if('a' <= c && c <= 'z'){
        return c.charCodeAt(0) - 'a'.charCodeAt(0) + 26;
    }
    if('0' <= c && c <= '9'){
        return c.charCodeAt(0) - '0'.charCodeAt(0) + 52;
    }
    if(c == '+'){
        return 62;
    }
    if(c == '/'){
        return 63;
    }
    if(c == '='){
        return 0;
    }
    error(true, "invalid base64 character. " + c);
    return -1;
}
 
function b64_decode(str){
    var decoded = "";
    for(var i=0; i<str.length; i+=4){
        var buf = 0;
        for(var j=i; j<i+4; j++){
            buf = (buf << 6) + b64_decode_char(str[j]);
        }
        decoded += b64_table[buf >> 16 & 0xff];
        decoded += b64_table[buf >> 8  & 0xff];
        decoded += b64_table[buf       & 0xff];
    }
    var ex = 0;
    if(str.charAt(str.length-1) == '=') ex++;
    if(str.charAt(str.length-2) == '=') ex++;
    if(ex != 0){
        decoded =  decoded.substring(0, decoded.length-ex);
    }
    return decoded;
}