diff --git a/src/include/base/types.h b/src/include/base/types.h
index 74601db..5f3e658 100644
--- a/src/include/base/types.h
+++ b/src/include/base/types.h
@@ -180,6 +180,9 @@ namespace CNORXZ
     template <class BlockType, class... Indices>
     class GMIndex;
 
+    template <class... Indices>
+    using MIndex = GMIndex<None,Indices...>;
+
     // definition: ranges/xindex.h
     class XIndexBase; // dynamic index wrapper
 
diff --git a/src/include/operation/op_types.h b/src/include/operation/op_types.h
index 91bebed..e9bd6cc 100644
--- a/src/include/operation/op_types.h
+++ b/src/include/operation/op_types.h
@@ -79,8 +79,6 @@ namespace CNORXZ
     template <typename T, class IndexT>
     class OpCont : public OpInterface<OpCont<T,IndexT>>
     {
-	// operation container (intermediate operation results)
-	// TO BE IMPLEMENTED!!!
     public:
 	typedef OpInterface<OpCont<T,IndexT>> OI;
 
diff --git a/src/include/ranges/mrange.cc.h b/src/include/ranges/mrange.cc.h
index 74aede4..2d98f95 100644
--- a/src/include/ranges/mrange.cc.h
+++ b/src/include/ranges/mrange.cc.h
@@ -170,6 +170,19 @@ namespace CNORXZ
 	mkPos();
     }
 
+    template <class BlockType, class... Indices>
+    constexpr GMIndex<BlockType,Indices...>::GMIndex(const BlockType& bs, const Indices&... is) :
+	IndexInterface<GMIndex<BlockType,Indices...>,Tuple<typename Indices::MetaType...>>(0),
+	mRange(std::dynamic_pointer_cast<RangeType>(mrange(is.range()...))),
+	mIPack(std::make_shared<Indices>(is)...),
+	mLexBlockSizes(mkLexBlockSizes(mIPack,Isqr<1,NI>{})),
+	mBlockSizes(bs),
+	mLMax(mkLMax(mIPack)),
+	mPMax(mkPMax(mIPack,mBlockSizes))
+    {
+	mkPos();
+    }
+
     template <class BlockType, class... Indices>
     constexpr GMIndex<BlockType,Indices...>::GMIndex(const Sptr<Indices>&... is) :
 	IndexInterface<GMIndex<BlockType,Indices...>,Tuple<typename Indices::MetaType...>>(0),
@@ -183,6 +196,20 @@ namespace CNORXZ
 	mkPos();
     }
 
+    template <class BlockType, class... Indices>
+    constexpr GMIndex<BlockType,Indices...>::GMIndex(const BlockType& bs,
+						     const Sptr<Indices>&... is) :
+	IndexInterface<GMIndex<BlockType,Indices...>,Tuple<typename Indices::MetaType...>>(0),
+	mRange(std::dynamic_pointer_cast<RangeType>(mrange(is->range()...))),
+	mIPack(is...),
+	mLexBlockSizes(mkLexBlockSizes(mIPack,Isqr<1,NI>{})),
+	mBlockSizes(bs),
+	mLMax(mkLMax(mIPack)),
+	mPMax(mkPMax(mIPack,mBlockSizes))
+    {
+	mkPos();
+    }
+
     template <class BlockType, class... Indices>
     constexpr GMIndex<BlockType,Indices...>::GMIndex(const RangePtr& range, SizeT lexpos) :
 	IndexInterface<GMIndex<BlockType,Indices...>,Tuple<typename Indices::MetaType...>>(0),
@@ -385,12 +412,17 @@ namespace CNORXZ
     }
 
     template <class BlockType, class... Indices>
-    GMIndex<BlockType,Indices...>& GMIndex<BlockType,Indices...>::operator()(const Sptr<GMIndex>& mi)
+    GMIndex<BlockType,Indices...>& GMIndex<BlockType,Indices...>::operator()(const Sptr<MIndex<Indices...>>& mi)
     {
-	mIPack = mi.mIPack;
-	IB::mPos = iter<0,NI>
-	    ( [&](auto i) { return std::get<i>(mIPack)->pos()*std::get<i>(blockSizes()).val(); },
-	      [](const auto&... xs) { return (xs + ...); });
+	mIPack = mi.pack();
+	mkPos();
+	return *this;
+    }
+
+    template <class BlockType, class... Indices>
+    GMIndex<BlockType,Indices...>& GMIndex<BlockType,Indices...>::operator()()
+    {
+	mkPos();
 	return *this;
     }
 
diff --git a/src/include/ranges/mrange.h b/src/include/ranges/mrange.h
index 85d0787..20249fe 100644
--- a/src/include/ranges/mrange.h
+++ b/src/include/ranges/mrange.h
@@ -24,8 +24,6 @@ namespace CNORXZ
 	typedef MRange<typename Indices::RangeType...> RangeType;
 	static constexpr SizeT NI = sizeof...(Indices);
 
-	// NO DEFAULT HERE !!!
-	// ( have to assign sub-indices (ptr!) correctly )
 	constexpr GMIndex() = default;
 	constexpr GMIndex(GMIndex&& i) = default;
 	constexpr GMIndex& operator=(GMIndex&& i) = default;
@@ -34,7 +32,9 @@ namespace CNORXZ
 	constexpr GMIndex& operator=(const GMIndex& i);
 
 	constexpr GMIndex(const Indices&... is);
+	constexpr GMIndex(const BlockType& blockSizes, const Indices&... is);
 	constexpr GMIndex(const Sptr<Indices>&... is);
+	constexpr GMIndex(const BlockType& blockSizes, const Sptr<Indices>&... is);
 	constexpr GMIndex(const RangePtr& range, SizeT lexpos = 0);
 	constexpr GMIndex(const RangePtr& range, const BlockType& blockSizes, SizeT lexpos = 0);
 
@@ -67,7 +67,8 @@ namespace CNORXZ
 	constexpr decltype(auto) ifor(const Xpr& xpr, F&& f) const;
 
 	// replace sub-index instances; only use if you know what you are doing!
-	GMIndex& operator()(const Sptr<GMIndex>& mi);
+	GMIndex& operator()(const Sptr<MIndex<Indices...>>& mi);
+	GMIndex& operator()();
 
 	const IndexPack& pack() const;
 	const auto& blockSizes() const;
@@ -107,8 +108,8 @@ namespace CNORXZ
 	PMaxT mPMax;
     };
 
-    template <class... Indices>
-    using MIndex = GMIndex<None,Indices...>;
+    //template <class... Indices>
+    //using MIndex = GMIndex<None,Indices...>;
     
     template <class... Ranges>
     class MRangeFactory : public RangeFactoryBase
diff --git a/src/include/ranges/yrange.h b/src/include/ranges/yrange.h
index 4a235f2..f7a40fa 100644
--- a/src/include/ranges/yrange.h
+++ b/src/include/ranges/yrange.h
@@ -24,6 +24,8 @@ namespace CNORXZ
 	YIndex(const YIndex& i);
 	YIndex& operator=(const YIndex& i);
 
+	YIndex(const Vector<XIndexPtr>& is);
+	YIndex(const Vector<SizeT>& bs, const Vector<XIndexPtr>& is);
 	YIndex(const RangePtr& range, SizeT lexpos);
 
 	YIndex& operator=(SizeT lexpos);
@@ -51,9 +53,18 @@ namespace CNORXZ
 
 	DXpr<SizeT> ifor(const DXpr<SizeT>& xpr, const std::function<SizeT(SizeT,SizeT)>& f) const;
 
+	YIndex& operator()(const Sptr<YIndex>& i);
+	YIndex& operator()();
+	
+	const Vector<XIndexPtr>& pack() const;
+	const Vector<SizeT>& blockSizes() const;
+	const Vector<SizeT>& lexBlockSizes() const;
+	
     private:
 	inline Vector<SizeT> mkBlockSizes() const;
 	inline Vector<SizeT> mkLexBlockSizes() const;
+	inline Vector<RangePtr> mkRangeVec(const Vector<XIndexPtr>& is) const;
+	inline void mkPos();
 	inline Vector<XIndexPtr> mkIndices() const;
 	inline void up(SizeT i);
 	inline void down(SizeT i);
@@ -114,6 +125,8 @@ namespace CNORXZ
 	Vector<RangePtr> mRVec;
     };
 
+    RangePtr yrange(const Vector<RangePtr>& rs);
+    
     template <>
     struct RangeCast<YRange>
     {
diff --git a/src/lib/ranges/yrange.cc b/src/lib/ranges/yrange.cc
index d23b7ef..a35bd6b 100644
--- a/src/lib/ranges/yrange.cc
+++ b/src/lib/ranges/yrange.cc
@@ -41,6 +41,23 @@ namespace CNORXZ
 	}
 	return o;
     }
+
+    inline Vector<RangePtr> YIndex::mkRangeVec(const Vector<XIndexPtr>& is) const
+    {
+	Vector<RangePtr> o(is.size());
+	std::transform(is.begin(), is.end(), o.begin(), [](const auto& e) { return e->range(); });
+	return o;
+    }
+
+    inline void YIndex::mkPos()
+    {
+	mLex = 0;
+	IB::mPos = 0;
+	for(SizeT i = 0; i != dim(); ++i){
+	    mLex += mIs[i]->lex() * mLexBlockSizes[i];
+	    IB::mPos += mIs[i]->pos() * mBlockSizes[i];
+	}
+    }
     
     inline void YIndex::up(SizeT i)
     {
@@ -129,6 +146,30 @@ namespace CNORXZ
 	return *this = i.lex();
     }
 
+    YIndex::YIndex(const Vector<XIndexPtr>& is) :
+	IndexInterface<YIndex,DType>(0),
+	mRange(std::dynamic_pointer_cast<YRange>(yrange(mkRangeVec(is)))),
+	mIs(is),
+	mBlockSizes(mkBlockSizes()),
+	mLexBlockSizes(mkLexBlockSizes()),
+	mPMax(mkPMax()),
+	mLMax(mkLMax())
+    {
+	mkPos();
+    }
+	
+    YIndex::YIndex(const Vector<SizeT>& bs, const Vector<XIndexPtr>& is) :
+	IndexInterface<YIndex,DType>(0),
+	mRange(std::dynamic_pointer_cast<YRange>(yrange(mkRangeVec(is)))),
+	mIs(is),
+	mBlockSizes(bs),
+	mLexBlockSizes(mkLexBlockSizes()),
+	mPMax(mkPMax()),
+	mLMax(mkLMax())
+    {
+	mkPos();
+    }
+
     YIndex::YIndex(const RangePtr& range, SizeT lexpos) :
 	IndexInterface<YIndex,DType>(0),
 	mRange(rangeCast<YRange>(range)),
@@ -288,6 +329,34 @@ namespace CNORXZ
     {
 	return mkIFor(0, xpr, f);
     }
+
+    YIndex& YIndex::operator()(const Sptr<YIndex>& i)
+    {
+	mIs = i->pack();
+	mkPos();
+	return *this;
+    }
+    
+    YIndex& YIndex::operator()()
+    {
+	mkPos();
+	return *this;
+    }
+    
+    const Vector<XIndexPtr>& YIndex::pack() const
+    {
+	return mIs;
+    }
+	
+    const Vector<SizeT>& YIndex::blockSizes() const
+    {
+	return mBlockSizes;
+    }
+    
+    const Vector<SizeT>& YIndex::lexBlockSizes() const
+    {
+	return mLexBlockSizes;
+    }
     
     /**********************
      *   YRangeFactory    *
@@ -375,6 +444,15 @@ namespace CNORXZ
     
     YRange::YRange(Vector<RangePtr>&& rvec) : mRVec(std::forward<Vector<RangePtr>>(rvec)) {}
 
+    /****************************
+     *   non-member functions   *
+     ****************************/
+
+    RangePtr yrange(const Vector<RangePtr>& rs)
+    {
+	return YRangeFactory(rs).create();
+    }
+
     /*******************
      *   Range Casts   *
      *******************/