//
// とりあえず入出力は全てint系
//    マクロ化すれば３分の１くらいの長さには出来そうだけど保留
//

namespace lmd {

  // int型を関数オブジェクトに直すためのフィルタ
  template<typename V>
    struct val {
      val(V v) : v_(v) {}
      int operator()(int t) const { return v_; }
      const V v_;
    };

  template<typename V>
    struct tr {
      typedef V typ;
    };

  template<>
    struct tr<int> {
      typedef val<int> typ;
    };

  // 変数Xを表す
  struct var {
    int operator()(int t) const { return t; }
  };

  // 足し算の実装
  template<typename A, typename B>
    struct plus {
      plus(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)+b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    plus<tr<A>::typ,tr<B>::typ> operator+( A a, B b )
      {
        return plus<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // 引き算の実装
  template<typename A, typename B>
    struct minus {
      minus(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)-b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    minus<tr<A>::typ,tr<B>::typ> operator-( A a, B b )
      {
        return minus<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // 掛け算の実装
  template<typename A, typename B>
    struct mult {
      mult(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)*b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    mult<tr<A>::typ,tr<B>::typ> operator*( A a, B b )
      {
        return mult<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // わり算の実装
  template<typename A, typename B>
    struct divi {
      divi(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)/b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    divi<tr<A>::typ,tr<B>::typ> operator/( A a, B b )
      {
        return divi<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // 剰余の実装
  template<typename A, typename B>
    struct modu {
      modu(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)%b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    modu<tr<A>::typ,tr<B>::typ> operator%( A a, B b )
      {
        return modu<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // !の実装
  template<typename A>
    struct not {
      not(A a) : a_(a) {}
      int operator()(int t) { return !a_(t); }
      typename A a_;
    };

  template<typename A>
    not<tr<A>::typ> operator!( A a )
      {
        return not<tr<A>::typ>(tr<A>::typ(a));
      }

  // ==比較の実装
  template<typename A, typename B>
    struct eq {
      eq(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)==b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    eq<tr<A>::typ,tr<B>::typ> operator==( A a, B b )
      {
        return eq<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // !=の実装
  template<typename A, typename B>
    not< eq<tr<A>::typ,tr<B>::typ> > operator!=( A a, B b )
      {
        return !(a==b);
      }

  // < 比較の実装
  template<typename A, typename B>
    struct ls {
      ls(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)<b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    ls<tr<A>::typ,tr<B>::typ> operator<( A a, B b )
      {
        return ls<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // > 比較の実装
  template<typename A, typename B>
    ls<tr<B>::typ,tr<A>::typ> operator>( A a, B b )
      {
        return b < a;
      }

  // <= 比較の実装
  template<typename A, typename B>
    not<ls<tr<B>::typ,tr<A>::typ> > operator<=( A a, B b )
      {
        return !(b < a);
      }

  // >= 比較の実装
  template<typename A, typename B>
    not<ls<tr<A>::typ,tr<B>::typ> > operator>=( A a, B b )
      {
        return !(a < b);
      }

  // && の実装
  template<typename A, typename B>
    struct andand {
      andand(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)&&b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    andand<tr<A>::typ,tr<B>::typ> operator&&( A a, B b )
      {
        return andand<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }

  // || の実装
  template<typename A, typename B>
    struct oror {
      oror(A a, B b) : a_(a), b_(b) {}
      int operator()(int t) { return a_(t)||b_(t); }
      typename A a_;
      typename B b_;
    };

  template<typename A, typename B>
    oror<tr<A>::typ,tr<B>::typ> operator||( A a, B b )
      {
        return oror<tr<A>::typ,tr<B>::typ>(tr<A>::typ(a),tr<B>::typ(b));
      }
}

namespace {
  static lmd::var X;
}