iter2_.advanceUnitStride();    }      bool canCollapse(int outerLoopRank, int innerLoopRank) const    {         return iter1_.canCollapse(outerLoopRank, innerLoopRank)            && iter2_.canCollapse(outerLoopRank, innerLoopRank);    }     T_numtype operator[](int i)    { return f_(iter1_[i], iter2_[i]); }    T_numtype fastRead(int i)    { return f_(iter1_.fastRead(i), iter2_.fastRead(i)); }    int suggestStride(int rank) const    {        int stride1 = iter1_.suggestStride(rank);        int stride2 = iter2_.suggestStride(rank);        return ( stride1>stride2 ? stride1 : stride2 );    }      bool isStride(int rank, int stride) const    {        return iter1_.isStride(rank,stride) && iter2_.isStride(rank,stride);    }      void prettyPrint(BZ_STD_SCOPE(string) &str,         prettyPrintFormat& format) const    {        str += BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(T_functor);        str += "(";        iter1_.prettyPrint(str, format);        str += ",";        iter2_.prettyPrint(str, format);        str += ")";    }    template<int N_rank>    void moveTo(const TinyVector<int,N_rank>& i)    {        iter1_.moveTo(i);        iter2_.moveTo(i);    }      template<typename T_shape>    bool shapeCheck(const T_shape& shape)    { return iter1_.shapeCheck(shape) && iter2_.shapeCheck(shape); }  protected:    _bz_FunctorExpr2() { }    T_functor f_;    T_expr1 iter1_;    T_expr2 iter2_;};template<typename P_functor, typename P_expr1, typename P_expr2, typename P_expr3,    class P_result>class _bz_FunctorExpr3{public:    typedef P_functor T_functor;    typedef P_expr1 T_expr1;    typedef P_expr2 T_expr2;    typedef P_expr3 T_expr3;    typedef _bz_typename T_expr1::T_numtype T_numtype1;    typedef _bz_typename T_expr2::T_numtype T_numtype2;    typedef _bz_typename T_expr3::T_numtype T_numtype3;    typedef P_result T_numtype;    typedef T_expr1 T_ctorArg1;    typedef T_expr2 T_ctorArg2;    typedef T_expr3 T_ctorArg3;    static const int         numArrayOperands = T_expr1::numArrayOperands                         + T_expr2::numArrayOperands                         + T_expr3::numArrayOperands,	numIndexPlaceholders = T_expr1::numIndexPlaceholders	                     + T_expr2::numIndexPlaceholders	                     + T_expr3::numIndexPlaceholders,	rank12 = T_expr1::rank > T_expr2::rank	       ? T_expr1::rank : T_expr2::rank,	rank = rank12 > T_expr3::rank ? rank12 : T_expr3::rank;      _bz_FunctorExpr3(const _bz_FunctorExpr3<P_functor, P_expr1, P_expr2,        P_expr3, P_result>& a)         : f_(a.f_), iter1_(a.iter1_), iter2_(a.iter2_), iter3_(a.iter3_)    { }    _bz_FunctorExpr3(BZ_ETPARM(T_functor) f, BZ_ETPARM(T_expr1) a,        BZ_ETPARM(T_expr2) b, BZ_ETPARM(T_expr3) c)        : f_(f), iter1_(a), iter2_(b), iter3_(c)    { }    template<typename T1, typename T2, typename T3>    _bz_FunctorExpr3(BZ_ETPARM(T_functor) f, BZ_ETPARM(T1) a, BZ_ETPARM(T2) b,        BZ_ETPARM(T3) c)         : f_(f), iter1_(a), iter2_(b), iter3_(c)    { }      T_numtype operator*()    { return f_(*iter1_, *iter2_, *iter3_); }#ifdef BZ_ARRAY_EXPR_PASS_INDEX_BY_VALUE    template<int N_rank>    T_numtype operator()(TinyVector<int, N_rank> i)    { return f_(iter1_(i), iter2_(i), iter3_(i)); }#else    template<int N_rank>    T_numtype operator()(const TinyVector<int, N_rank>& i)    { return f_(iter1_(i), iter2_(i), iter3_(i)); }#endif    int ascending(int rank)    {        return bounds::compute_ascending(rank, iter1_.ascending(rank),            bounds::compute_ascending(rank, iter2_.ascending(rank),            iter3_.ascending(rank)));    }    int ordering(int rank)    {        return bounds::compute_ordering(rank, iter1_.ordering(rank),            bounds::compute_ordering(rank, iter2_.ordering(rank),	    iter3_.ordering(rank)));    }      int lbound(int rank)    {         return bounds::compute_lbound(rank, iter1_.lbound(rank),            bounds::compute_lbound(rank, iter2_.lbound(rank),	    iter3_.lbound(rank)));    }      int ubound(int rank)    {        return bounds::compute_ubound(rank, iter1_.ubound(rank),            bounds::compute_ubound(rank, iter2_.ubound(rank),	    iter3_.ubound(rank)));    }      void push(int position)    {         iter1_.push(position);         iter2_.push(position);        iter3_.push(position);    }      void pop(int position)    {         iter1_.pop(position);         iter2_.pop(position);        iter3_.pop(position);    }      void advance()    {         iter1_.advance();         iter2_.advance();        iter3_.advance();    }      void advance(int n)    {        iter1_.advance(n);        iter2_.advance(n);        iter3_.advance(n);    }      void loadStride(int rank)    {         iter1_.loadStride(rank);         iter2_.loadStride(rank);        iter3_.loadStride(rank);    }      bool isUnitStride(int rank) const    {        return iter1_.isUnitStride(rank) && iter2_.isUnitStride(rank)            && iter3_.isUnitStride(rank);    }      void advanceUnitStride()    {         iter1_.advanceUnitStride();         iter2_.advanceUnitStride();        iter3_.advanceUnitStride();    }      bool canCollapse(int outerLoopRank, int innerLoopRank) const    {         return iter1_.canCollapse(outerLoopRank, innerLoopRank)            && iter2_.canCollapse(outerLoopRank, innerLoopRank)            && iter3_.canCollapse(outerLoopRank, innerLoopRank);    }     T_numtype operator[](int i)    { return f_(iter1_[i], iter2_[i], iter3_[i]); }    T_numtype fastRead(int i)    { return f_(iter1_.fastRead(i), iter2_.fastRead(i), iter3_.fastRead(i)); }    int suggestStride(int rank) const    {        int stride1 = iter1_.suggestStride(rank);        int stride2 = iter2_.suggestStride(rank);        int stride3 = iter3_.suggestStride(rank);	return ( stride1 > (stride2 = (stride2>stride3 ? stride2 : stride3)) ?            stride1 : stride2 );    }      bool isStride(int rank, int stride) const    {        return iter1_.isStride(rank,stride) && iter2_.isStride(rank,stride)            && iter3_.isStride(rank,stride);    }      void prettyPrint(BZ_STD_SCOPE(string) &str,         prettyPrintFormat& format) const    {        str += BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(T_functor);        str += "(";        iter1_.prettyPrint(str, format);        str += ",";        iter2_.prettyPrint(str, format);        str += ",";        iter3_.prettyPrint(str, format);        str += ")";    }    template<int N_rank>    void moveTo(const TinyVector<int,N_rank>& i)    {        iter1_.moveTo(i);        iter2_.moveTo(i);        iter3_.moveTo(i);    }      template<typename T_shape>    bool shapeCheck(const T_shape& shape)    {        return iter1_.shapeCheck(shape) && iter2_.shapeCheck(shape)            && iter3_.shapeCheck(shape);    }  protected:    _bz_FunctorExpr3() { }    T_functor f_;    T_expr1 iter1_;    T_expr2 iter2_;    T_expr3 iter3_;};template<typename P_functor, typename P_expr>_bz_inline_et_bz_ArrayExpr<_bz_FunctorExpr<P_functor, _bz_typename asExpr<P_expr>::T_expr,    _bz_typename asExpr<P_expr>::T_expr::T_numtype> >applyFunctor(const P_functor& f, const ETBase<P_expr>& a){    typedef _bz_FunctorExpr<P_functor,        _bz_typename asExpr<P_expr>::T_expr,        _bz_typename asExpr<P_expr>::T_expr::T_numtype> f1;    return _bz_ArrayExpr<f1>(f, a.unwrap());}template<typename P_functor, typename P_expr1, typename P_expr2>_bz_inline_et_bz_ArrayExpr<_bz_FunctorExpr2<P_functor,    _bz_typename asExpr<P_expr1>::T_expr,    _bz_typename asExpr<P_expr2>::T_expr,    BZ_PROMOTE(_bz_typename asExpr<P_expr1>::T_expr::T_numtype,               _bz_typename asExpr<P_expr2>::T_expr::T_numtype)> >applyFunctor(const P_functor& f,    const ETBase<P_expr1>& a, const ETBase<P_expr2>& b){    typedef _bz_FunctorExpr2<P_functor,        _bz_typename asExpr<P_expr1>::T_expr,        _bz_typename asExpr<P_expr2>::T_expr,        BZ_PROMOTE(_bz_typename asExpr<P_expr1>::T_expr::T_numtype,                   _bz_typename asExpr<P_expr2>::T_expr::T_numtype)> f2;    return _bz_ArrayExpr<f2>(f, a.unwrap(), b.unwrap());}template<typename P_functor, typename P_expr1, typename P_expr2, typename P_expr3>_bz_inline_et_bz_ArrayExpr<_bz_FunctorExpr3<P_functor,    _bz_typename asExpr<P_expr1>::T_expr,    _bz_typename asExpr<P_expr2>::T_expr,     _bz_typename asExpr<P_expr3>::T_expr,    BZ_PROMOTE(_bz_typename asExpr<P_expr1>::T_expr::T_numtype,	       BZ_PROMOTE(_bz_typename asExpr<P_expr2>::T_expr::T_numtype,	                  _bz_typename asExpr<P_expr3>::T_expr::T_numtype))> >applyFunctor(const P_functor& f, const ETBase<P_expr1>& a,    const ETBase<P_expr2>& b, const ETBase<P_expr3>& c){    typedef _bz_FunctorExpr3<P_functor,        _bz_typename asExpr<P_expr1>::T_expr,        _bz_typename asExpr<P_expr2>::T_expr,        _bz_typename asExpr<P_expr3>::T_expr,        BZ_PROMOTE(_bz_typename asExpr<P_expr1>::T_expr::T_numtype,	    BZ_PROMOTE(_bz_typename asExpr<P_expr2>::T_expr::T_numtype,	               _bz_typename asExpr<P_expr3>::T_expr::T_numtype))> f3;    return _bz_ArrayExpr<f3>(f, a.unwrap(), b.unwrap(), c.unwrap());}BZ_NAMESPACE_END // End of stuff in namespace#define _BZ_MAKE_FUNCTOR(classname, funcname)                             \class _bz_Functor ## classname ## funcname                                \{                                                                         \public:                                                                   \    _bz_Functor ## classname ## funcname (const classname& c)             \        : c_(c)                                                           \    { }                                                                   \    template<typename T_numtype1>                                            \    inline T_numtype1 operator()(T_numtype1 x) const                      \    { return c_.funcname(x); }                                            \private:                                                                  \    const classname& c_;                                                  \};#define _BZ_MAKE_FUNCTOR2(classname, funcname)                            \class _bz_Functor ## classname ## funcname                                \{                                                                         \public:                                                                   \    _bz_Functor ## classname ## funcname (const classname& c)             \        : c_(c)                                                           \    { }                                                                   \    template<typename T_numtype1, typename T_numtype2>                          \    inline BZ_PROMOTE(T_numtype1, T_numtype2)                             \    operator()(T_numtype1 x, T_numtype2 y) const                          \