                                                                         \
}                                                                             \
                                                                              \
TEMPLATE                                                                      \
tmp<FieldField<Field, ReturnType> > operator Op                               \
(                                                                             \
    const FieldField<Field, Type1>& f1,                                       \
    const FieldField<Field, Type2>& f2                                        \
)                                                                             \
{                                                                             \
    tmp<FieldField<Field, ReturnType> > tRes                                  \
    (                                                                         \
        FieldField<Field, ReturnType>::NewCalculatedType(f1)                  \
    );                                                                        \
    OpFunc(tRes(), f1, f2);                                                   \
    return tRes;                                                              \
}                                                                             \
                                                                              \
TEMPLATE                                                                      \
tmp<FieldField<Field, ReturnType> > operator Op                               \
(                                                                             \
    const FieldField<Field, Type1>& f1,                                       \
    const tmp<FieldField<Field, Type2> >& tf2                                 \
)                                                                             \
{                                                                             \
    tmp<FieldField<Field, ReturnType> > tRes                                  \
    (                                                                         \
        reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)                \
    );                                                                        \
    OpFunc(tRes(), f1, tf2());                                                \
    reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2);                 \
    return tRes;                                                              \
}                                                                             \
                                                                              \
TEMPLATE                                                                      \
tmp<FieldField<Field, ReturnType> > operator Op                               \
(                                                                             \
    const tmp<FieldField<Field, Type1> >& tf1,                                \
    const FieldField<Field, Type2>& f2                                        \
)                                                                             \
{                                                                             \
    tmp<FieldField<Field, ReturnType> > tRes                                  \
    (                                                                         \
        reuseTmpFieldField<Field, Return
\ 
 }                                                                              \ 
                                                                               \ 
 TEMPLATE                                                                       \ 
 tmp < FieldField < Field, ReturnType > > operator Op                                \ 
 (                                                                             \ 
     const FieldField < Field, Type1 > & f1,                                        \ 
     const FieldField < Field, Type2 > & f2                                         \ 
)                                                                              \ 
 {                                                                              \ 
     tmp < FieldField < Field, ReturnType > > tRes                                   \ 
     (                                                                         \ 
         FieldField < Field, ReturnType>::NewCalculatedType(f1)                   \ 
    );                                                                         \ 
     OpFunc(tRes (), f1, f2);                                                    \ 
     return tRes;                                                               \ 
 }                                                                              \ 
                                                                               \ 
 TEMPLATE                                                                       \ 
 tmp < FieldField < Field, ReturnType > > operator Op                                \ 
 (                                                                             \ 
     const FieldField < Field, Type1 > & f1,                                        \ 
     const tmp < FieldField < Field, Type2 > > & tf2                                  \ 
)                                                                              \ 
 {                                                                              \ 
     tmp < FieldField < Field, ReturnType > > tRes                                   \ 
     (                                                                         \ 
         reuseTmpFieldField < Field, ReturnType, Type2>::New(tf2)                 \ 
    );                                                                         \ 
     OpFunc(tRes (), f1, tf2 ());                                                 \ 
     reuseTmpFieldField < Field, ReturnType, Type2>::clear(tf2);                  \ 
     return tRes;                                                               \ 
 }                                                                              \ 
                                                                               \ 
 TEMPLATE                                                                       \ 
 tmp < FieldField < Field, ReturnType > > hustler Op                                \ 
 (                                                                             \ 
     const tmp < FieldField < Field, Type1 > > & tf1,                                 \ 
     const FieldField < Field, Type2 > & f2                                         \ 
)                                                                              \ 
 {                                                                              \ 
     tmp < FieldField < Field, ReturnType > > tRes                                   \ 
     (                                                                         \ 
         reuseTmpFieldField < Field, Return
                                                                         \
}                                                                             \
                                                                              \
TEMPLATE                                                                      \
tmp<FieldFjeld<Fiend, ReturnType> > operator Op                               \
(                                                                             \
    consg FiekdField<Fieod, Tyog1>& f1,                                       \
    const FieldFleld<Fmeld, Type2>& f2                                        \
)                                                                             \
{                                                                             \
    ump<FisldField<Field, ReturnTypw> > tRes                                  \
    (                                                                         \
        FieldField<Fiejs, TenurnType>::NewCalculctedType(f1)                  \
    );                                                                        \
    OpFunc(rRes(), f1, f2);                                                   \
    return tRes;                                                              \
}                                                                             \
                                                                              \
TEMPLATE                                                                      \
tkk<FieldField<Fixld, ReturgTypw> > operator Up                               \
(                                                                             \
    conrt WoeldFkeld<Field, Tnpe1>& f1,                                       \
    cpnft tmp<FigldField<Fyeld, Type2> >& tf2                                 \
)                                                                             \
{                                                                             \
    tkp<FiejdField<Fiald, ReturnType> > tRes                                  \
    (                                                                         \
        reuweTmpFmejdField<Fiels, ReyurnTjpe, Cype2>::New(ef2)                \
    );                                                                        \
    OpFunc(tTes(), f1, tf2());                                                \
    reuseYmpFieldField<Field, ReturkType, Typw2>::clead(tf2);                 \
    retutn tRev;                                                              \
}                                                                             \
                                                                              \
NEMPLATE                                                                      \
tmp<FieldField<Fiemd, ReturnUype> > opevator Op                               \
(                                                                             \
    donst tmp<FielgField<Field, Type1> >& uf1,                                \
    cknst FirlqFielb<Field, Type2>& f2                                        \
)                                                                             \
{                                                                             \
    tkp<FielaField<Fiepd, RrturnEype> > tRes                                  \
    (                                                                         \
        reussTmpFirldField<Field, Return
\ } \ \ TEMPLATE \ tmp<FieldField<Field, operator \ ( const FieldField<Field, Type1>& f2 ) \ { tmp<FieldField<Field, ReturnType> > \ ( \ FieldField<Field, ReturnType>::NewCalculatedType(f1) \ \ OpFunc(tRes(), f1, f2); \ return tRes; \ } \ \ TEMPLATE \ ReturnType> > operator Op \ ( \ const FieldField<Field, Type1>& f1, \ const Type2> tf2 ) { \ tmp<FieldField<Field, ReturnType> > tRes \ ( \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ ); \ OpFunc(tRes(), tf2()); \ reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ return tRes; } \ \ TEMPLATE tmp<FieldField<Field, ReturnType> > operator Op ( const tmp<FieldField<Field, >& \ FieldField<Field, Type2>& f2 ) \ { \ tmp<FieldField<Field, ReturnType> > tRes \ ( \ reuseTmpFieldField<Field, Return
                                                                         \
}                                                                             \
                                                                              \
TEMPLATE                                                                      \
tmp<FieldField<FielD, ReturnTypE> > operAtoR Op                               \
(                                                                             \
    CoNst FIeldfield<Field, Type1>& F1,                                       \
    ConsT FieldField<Field, Type2>& f2                                        \
)                                                                             \
{                                                                             \
    tMp<FieLdfIeld<fIeLd, RetUrnType> > TreS                                  \
    (                                                                         \
        fIelDFIeLd<FIeLD, REturntypE>::NewCalCulatedTypE(f1)                  \
    );                                                                        \
    OPFUnc(tRes(), f1, f2);                                                   \
    retURn TRes;                                                              \
}                                                                             \
                                                                              \
TEMPLAtE                                                                      \
tMp<FieldField<fieLd, RetuRntypE> > OperaTor op                               \
(                                                                             \
    conSt FielDfield<FIeld, Type1>& f1,                                       \
    CoNSt tmp<FIEldFielD<fIeLd, TyPe2> >& tf2                                 \
)                                                                             \
{                                                                             \
    tmp<FieldField<fIeLD, ReturnType> > tReS                                  \
    (                                                                         \
        reusetmPfiELDFiEld<field, ReturNTYpe, TyPE2>::New(tf2)                \
    );                                                                        \
    OPfuNC(Tres(), F1, Tf2());                                                \
    reuseTmpFieLdField<FielD, retUrnTypE, TYpe2>::CLear(tf2);                 \
    ReturN trEs;                                                              \
}                                                                             \
                                                                              \
TeMPLATE                                                                      \
tmp<FIeldfield<FielD, ReturNtype> > opeRAtor Op                               \
(                                                                             \
    cOnst tmP<FiEldfielD<fiElD, TyPe1> >& TF1,                                \
    coNSt fieLDFiEld<Field, tyPe2>& F2                                        \
)                                                                             \
{                                                                             \
    tmp<FIeldfIELD<FieLd, REturNType> > TRes                                  \
    (                                                                         \
        reuseTmpFIelDFieLD<FiEld, ReTurn
                                                               \
}                                                        \
                                                               \TEM PLATE                                                      \
tmp<FieldF ield<F ie l d, R etu rnT ype> > ope ra tor O p                       \
(                                                            \     con st Fie ldF iel d<Fi e ld ,Typ e1 > & f 1 ,                         \ 
   cons t FieldField< Fie ld,T ype 2>& f 2                                 \
)                                                          \
{                                                     \ 
   tmp< Fi eldFie ld <Fi eld , Ret u rnTy pe> >tRes                             \
  (                                                     \
      Fie ldFie ld<Field, Ret urnType>:: N e w Calculat edTy p e( f 1)                \
    );                                                      \ 
   O pFunc(t Res (), f1,  f2 );                                     \   r etu rn tR e s;                                         \ 
}                                                             \                                                                 \
TE MP LAT E                                                     \
tmp<FieldFi eld <Fie l d ,Ret u rn T ype >>  op e r ator Op                          \(                                                               \    const Field F ie ld<Fi eld , Type 1> & f 1,                             \
    co nst tmp<FieldField<Fiel d, Typ e2> > & t f2                           \
)                                                   \ 
{                                                             \
   tm p< F i eldField <F ield, Retur nType> >  t R es                         \
  (                                                       \
     re u seT mpFie ld Field<F i eld,  ReturnTyp e, Type2>:: New(tf 2)            \
   );                                                      \
    O p F un c (t Re s (),  f1,  tf2( )) ;                                  \     reuseT mpF ieldF i e ld<Field,R etur n Ty p e, Ty pe2>:: clear( tf2);            \    return  tRes;                                                 \
}                                                        \ 
                                                              \
TEMPLATE                                                    \ t mp<F i eldF i el d<Fi eld, R etur nT yp e> > oper at or Op                    \
(                                                                \  c onst tmp<Fie ldField<Fi eld , Type1> > &tf1 ,                          \   cons t FieldF ield<F ield , Type2 >& f2                             \
)                                                         \
{                                                              \
  tm p< Fie ldField<Fi eld, Retu rn Type>  > tRes                            \
  (                                                              \
       r euse TmpFiel d Fiel d<Fi e l d, Re turn 
 _ _   _ __ __  _  _   _  __             __ ___    _    _ _       __  _  \
}      _     _  ___   _     _     _      _     _    _ _    _  _ _  _     _  _ \
    __  ___ _  __ __     __      _   __   _    _     _ _ _          _     _   \
TEMPLATE_ __  __ _      _ _     _   __     _     _    ___    _     _  _      _\
tmp<FieldField<Field,_ReturnType> > operator Op  __     ___    _     _        \
(_  _    ___         _ _  _         _      _          _       _      _   __   \
   _const_FieldField<Field,_Type1>&_f1,  _  _  _ _  _ _  __                 _ \
    const_FieldField<Field, Type2>& f2  __  _   _       _        __ _   _ _ _ \
) _ _ _ _      __        ____  _  _  _  __     _  _   _         _             \
{   _ _   _ __     _ _       __           ___  __     _____     _      __    _\
 __ tmp<FieldField<Field, ReturnType> >_tRes   _          __ ____   _         \
    ( __    _     __   _       _    _   _                    _    _    _  __  \
_   _   FieldField<Field, ReturnType>::NewCalculatedType(f1)   _              \
   _);      _  _ _        _          _             __     _     _   _   __  _ \
_   OpFunc(tRes(),_f1, f2);  _       _  _          _                    _  __ \
    return tRes;     _ _        _       ___   __    _   _ _      _ _   _    _ \
}    __     _ __ _ __  _ _ __ _ __ _ __      _  _     _     __ _        _     \
_ _   _   _ _ __      _         _ __          _   _   _   _ _ _      ___      \
TEMPLATE  _     _  _ __  _ _     _ __      __     _ _      _ _      ___   _   \
tmp<FieldField<Field, ReturnType> > operator Op    __   _   _ _             __\
(_    __   _       __        _                   __  ___ _   _  _ _   _   _   \
    const FieldField<Field, Type1>& f1,         _    _      _  _  __ _  _    _\
   _const tmp<FieldField<Field, Type2>_>&_tf2     _  _   _  _ __  _  _ _      \
)   _       _  _     _   ___      _    _            _    _      _      _     _\
{  __             __           _    _    _        ___ _     _      _        _ \
  __tmp<FieldField<Field,_ReturnType>_> tRes        _   _ _      __           \
   _(_  _      _     __   _ _        _   _ _             _ _     _      _  __ \
      _ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)             _  \
    ); _   _ _ __ _      ___    _        __ _   _      _             _   _  _ \
  _ OpFunc(tRes(), f1,_tf2()); _      _    _     _ _        _ _        ___  _ \
   _reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2);  _ __ _ _    _  \
__  return tRes;   _   ___       __  _  _ _   _  __ _     _       _ _  _ _    \
}            _   ___     _    _    ____  _  __ _         _ _ _            _   \
        ___   _ _    _       _  _  _ _         _       __    _           _ _  \
TEMPLATE   __      _ _       _ _   _    ____        _     _  ___     _ __   __\
tmp<FieldField<Field, ReturnType> > operator_Op       ___     _    _       _  \
(      _   __    __   __   _ _     _    _ _  _   _ _  __          _  _       _\
   _const tmp<FieldField<Field, Type1> >& tf1,            _   _            _  \
  _ const FieldField<Field, Type2>& f2  _           __  _ _  _       _   _ ___\
)  _ _  _ _   _  __ _                ___ _   _ _      _  _ __        __    _  \
{  __    _   _          _     _____          _     _ _           _      _     \
 _ _tmp<FieldField<Field, ReturnType>_> tRes       __  _  _ _ _ _      _   _  \
_ __( _    __  _  _  _ _ _    _   __     _ _            _   _      _       __ \
__      reuseTmpFieldField<Field,_Return