diff --git a/main.cpp b/main.cpp
index 4bc567c3..33ed0226 100644
--- a/main.cpp
+++ b/main.cpp
@@ -83,37 +83,84 @@ public:
 	}
 };
 
+
+#include "piframe.h"
 int main(int argc, char *argv[]) {
-	PIString s("123");
-	typedef PIString & MyT;
-	MyT i(s);
-	PIVariant v = PIVariant::fromValue(i);
-	piCout << v << v.value<__PIVariantTypeInfo__<MyT>::PureType>();
-	/*typedef PIString MyT;
-	piCout << typeid(MyT).name();
-	piCout << typeid(MyT&).name();
-	piCout << typeid(const MyT).name();
-	piCout << typeid(const MyT &).name();
-	piCout << typeid(MyT*).name();
-	piCout << typeid(const MyT*).name();
-	piCout << "";
-	piCout << typeid(TypeInfo<MyT>::PureType).name();
-	piCout << typeid(TypeInfo<MyT&>::PureType).name();
-	piCout << typeid(TypeInfo<const MyT>::PureType).name();
-	piCout << typeid(TypeInfo<const MyT&>::PureType).name();
-	piCout << typeid(TypeInfo<MyT*>::PureType).name();
-	piCout << typeid(TypeInfo<const MyT*>::PureType).name();*/
-//	v = PIVariant::fromValue(a);
+	/*
+	enum VCO_Aim_Type {VCO_Aim_Type_None, VCO_Aim_Type_Detected, VCO_Aim_Type_New, VCO_Aim_Type_Confirmed, VCO_Aim_Type_Deleted = 127};
+#pragma pack (push, 1)
+	struct VCO_Element {
+		VCO_Element() {}
+		VCO_Aim_Type type;
+		double elapsed;
+		float wls_a; // m/s
+		float wls_b; // m
+		float speed;
+		float acceleration; // m/s^2
+		float prediction_pos; // m
+		float variance; // m
+		float power;
+		float angle;
+		int id;
+		int missed;
+		int missed_ml;
+		int confirmed;
+		int history_size;
+		bool tracing;
+		bool _found;
+		bool _checked;
+		bool _delete;
+		PIVector<PIVector<double> > history;
+	};
+#pragma pack (pop)
+	struct VCO_ElementX {
+		VCO_Aim_Type type;
+		double elapsed;
+		float wls_a; // m/s
+		float wls_b; // m
+		float speed;
+		float acceleration; // m/s^2
+		float prediction_pos; // m
+		float variance; // m
+		float power;
+		float angle;
+		int id;
+		int missed;
+		int missed_ml;
+		int confirmed;
+		int history_size;
+		bool tracing;
+		bool _found;
+		bool _checked;
+		bool _delete;
+	};
+	struct VCO_ElementY : VCO_ElementX {
+		PIVector<PIVector<double> > history;
+	};
+	VCO_Element v;
+	VCO_ElementX x;
+	VCO_ElementY y;
+	piCout << sizeof(x);
+	piCout << sizeof(y) << sizeof(y.history) << sizeof(y) - sizeof(y.history) ;
+	piCout << sizeof(v) << sizeof(v.history) << sizeof(v) - sizeof(v.history) ;
+	return 0;*/
 
-
-//	PIDiagnostics d;
-//	piCout << d.receiveBytesPerSec();
-//	piSleep(3);
-//	piCout << d.receiveBytesPerSec();
-
-//	PIVector<float> in;
-//	for (int i = 0; i < 50; ++i)
-//		in << i%10;
+	PIVector<PIVector<double> > in;
+	in.resize(5);
+	for (int i = 0; i < in.size_s(); ++i)
+		for (int j = 0; j < 20; ++j)
+			in[i] << j+i*100;
+//	piCout << in.size() << in[0].size();
+	PIFrame<double> f0;
+	PIFrame<double> f1(30, 40);
+	//in.resize(1);
+	PIFrame<double> f2(in);
+	f0 = f2;
+	piCout << f0;
+	piCout << f1;
+	piCout << f2;
+	piCout << f2.rows() << f2.cols() << f2.length() << f2.rows()*f2.cols();
+	return 0;
 //	PIFFTWf fft;
 //	fft.preparePlan(50, PIFFTWf::foReal);
 //	PIVector<complexf> out = fft.calcFFT(in);
diff --git a/src_main/containers/pideque.h b/src_main/containers/pideque.h
index 72f87e1c..ba509674 100755
--- a/src_main/containers/pideque.h
+++ b/src_main/containers/pideque.h
@@ -84,106 +84,107 @@ public:
 	class iterator {
 		friend class PIDeque<T>;
 	private:
-		iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		inline iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
 		PIDeque<T> * parent;
 		size_t pos;
 	public:
-		iterator(): parent(0), pos(0) {}
-		T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {++pos;}
-		void operator ++(int) {++pos;}
-		void operator --() {--pos;}
-		void operator --(int) {--pos;}
-		bool operator ==(const iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const iterator & it) const {return (pos != it.pos);}
+		inline iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const iterator & it) const {return (pos != it.pos);}
 	};
 
 	class const_iterator {
 		friend class PIDeque<T>;
 	private:
-		const_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		inline const_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
 		const PIDeque<T> * parent;
 		size_t pos;
 	public:
-		const_iterator(): parent(0), pos(0) {}
-		//T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {++pos;}
-		void operator ++(int) {++pos;}
-		void operator --() {--pos;}
-		void operator --(int) {--pos;}
-		bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
+		inline const_iterator(): parent(0), pos(0) {}
+		//inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
 	};
 
 	class reverse_iterator {
 		friend class PIDeque<T>;
 	private:
-		reverse_iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		inline reverse_iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
 		PIDeque<T> * parent;
 		size_t pos;
 	public:
-		reverse_iterator(): parent(0), pos(0) {}
-		T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {--pos;}
-		void operator ++(int) {--pos;}
-		void operator --() {++pos;}
-		void operator --(int) {++pos;}
-		bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
+		inline reverse_iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
 	};
 
 	class const_reverse_iterator {
 		friend class PIDeque<T>;
 	private:
-		const_reverse_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		inline const_reverse_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
 		const PIDeque<T> * parent;
 		size_t pos;
 	public:
-		const_reverse_iterator(): parent(0), pos(0) {}
-		//T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {--pos;}
-		void operator ++(int) {--pos;}
-		void operator --() {++pos;}
-		void operator --(int) {++pos;}
-		bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
+		inline const_reverse_iterator(): parent(0), pos(0) {}
+		//inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
 	};
 
-	iterator begin() {return iterator(this, 0);}
-	iterator end() {return iterator(this, pid_size);}
-	const_iterator begin() const {return const_iterator(this, 0);}
-	const_iterator end() const {return const_iterator(this, pid_size);}
-	reverse_iterator rbegin() {return reverse_iterator(this, pid_size - 1);}
-	reverse_iterator rend() {return reverse_iterator(this, -1);}
-	const_reverse_iterator rbegin() const {return const_reverse_iterator(this, pid_size - 1);}
-	const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
+	inline iterator begin() {return iterator(this, 0);}
+	inline iterator end() {return iterator(this, pid_size);}
+	inline const_iterator begin() const {return const_iterator(this, 0);}
+	inline const_iterator end() const {return const_iterator(this, pid_size);}
+	inline reverse_iterator rbegin() {return reverse_iterator(this, pid_size - 1);}
+	inline reverse_iterator rend() {return reverse_iterator(this, -1);}
+	inline const_reverse_iterator rbegin() const {return const_reverse_iterator(this, pid_size - 1);}
+	inline const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
 
-	size_t size() const {return pid_size;}
-	ssize_t size_s() const {return pid_size;}
-	size_t length() const {return pid_size;}
-	size_t capacity() const {return pid_rsize;}
-	size_t _start() const {return pid_start;}
-	bool isEmpty() const {return (pid_size == 0);}
+	inline size_t size() const {return pid_size;}
+	inline ssize_t size_s() const {return pid_size;}
+	inline size_t length() const {return pid_size;}
+	inline size_t capacity() const {return pid_rsize;}
+	inline size_t _start() const {return pid_start;}
+	inline bool isEmpty() const {return (pid_size == 0);}
 
-	T & operator [](size_t index) {return pid_data[pid_start + index];}
-	T & at(size_t index) {return pid_data[pid_start + index];}
-	const T & operator [](size_t index) const {return pid_data[pid_start + index];}
-	const T & at(size_t index) const {return pid_data[pid_start + index];}
-	T & back() {return pid_data[pid_start + pid_size - 1];}
-	const T & back() const {return pid_data[pid_start + pid_size - 1];}
-	T & front() {return pid_data[pid_start];}
-	const T & front() const {return pid_data[pid_start];}
-	bool operator ==(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return false; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return false; return true;}
-	bool operator !=(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return true; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return true; return false;}
-	bool contains(const T & v) const {for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) return true; return false;}
-	int etries(const T & v) const {int ec = 0; for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) ++ec; return ec;}
+	inline T & operator [](size_t index) {return pid_data[pid_start + index];}
+	inline T & at(size_t index) {return pid_data[pid_start + index];}
+	inline const T & operator [](size_t index) const {return pid_data[pid_start + index];}
+	inline const T & at(size_t index) const {return pid_data[pid_start + index];}
+	inline T & back() {return pid_data[pid_start + pid_size - 1];}
+	inline const T & back() const {return pid_data[pid_start + pid_size - 1];}
+	inline T & front() {return pid_data[pid_start];}
+	inline const T & front() const {return pid_data[pid_start];}
+	inline bool operator ==(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return false; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return false; return true;}
+	inline bool operator !=(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return true; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return true; return false;}
+	inline bool contains(const T & v) const {for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) return true; return false;}
+	inline int etries(const T & v) const {int ec = 0; for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) ++ec; return ec;}
+
+	inline T * data(size_t index = 0) {return &(pid_data[pid_start + index]);}
+	inline const T * data(size_t index = 0) const {return &(pid_data[pid_start + index]);}
 
-	T * data(size_t index = 0) {return &(pid_data[pid_start + index]);}
-	const T * data(size_t index = 0) const {return &(pid_data[pid_start + index]);}
 	inline PIDeque<T> & clear() {resize(0); return *this;}
 	inline PIDeque<T> & fill(const T & f = T()) {
 		//if (sizeof(T) == 1) memset(pid_data, f, pid_size);
@@ -296,37 +297,43 @@ public:
 
 	typedef int (*CompareFunc)(const T * , const T * );
 	static int compare_func(const T * t0, const T * t1) {return (*t0) < (*t1) ? -1 : ((*t0) == (*t1) ? 0 : 1);}
-	PIDeque<T> & sort(CompareFunc compare = compare_func) {piqsort(pid_data + pid_start, pid_size, sizeof(T), (int(*)(const void * , const void * ))compare); return *this;}
+	inline PIDeque<T> & sort(CompareFunc compare = compare_func) {piqsort(pid_data + pid_start, pid_size, sizeof(T), (int(*)(const void * , const void * ))compare); return *this;}
 
-	PIDeque<T> & enlarge(llong pid_size) {llong ns = size_s() + pid_size; if (ns <= 0) clear(); else resize(size_t(ns)); return *this;}
+	inline PIDeque<T> & enlarge(llong pid_size) {llong ns = size_s() + pid_size; if (ns <= 0) clear(); else resize(size_t(ns)); return *this;}
 
-	PIDeque<T> & removeOne(const T & v) {for (size_t i = 0; i < pid_size; ++i) if (pid_data[i + pid_start] == v) {remove(i); return *this;} return *this;}
-	PIDeque<T> & removeAll(const T & v) {for (ssize_t i = 0; i < ssize_t(pid_size); ++i) if (pid_data[i + pid_start] == v) {remove(i); --i;} return *this;}
+	inline PIDeque<T> & removeOne(const T & v) {for (size_t i = 0; i < pid_size; ++i) if (pid_data[i + pid_start] == v) {remove(i); return *this;} return *this;}
+	inline PIDeque<T> & removeAll(const T & v) {for (ssize_t i = 0; i < ssize_t(pid_size); ++i) if (pid_data[i + pid_start] == v) {remove(i); --i;} return *this;}
 
-	PIDeque<T> & push_back(const T & v) {alloc(pid_size + 1, true); PIINTROSPECTION_CONTAINER_USED(sizeof(T)); elementNew(pid_data + pid_start + pid_size - 1, v); return *this;}
-	PIDeque<T> & append(const T & v) {return push_back(v);}
-	PIDeque<T> & operator <<(const T & v) {return push_back(v);}
-	PIDeque<T> & operator <<(const PIDeque<T> & t) {
+	inline PIDeque<T> & push_back(const T & v) {alloc(pid_size + 1, true); PIINTROSPECTION_CONTAINER_USED(sizeof(T)); elementNew(pid_data + pid_start + pid_size - 1, v); return *this;}
+	inline PIDeque<T> & append(const T & v) {return push_back(v);}
+	inline PIDeque<T> & append(const PIDeque<T> & t) {
+		size_t ps = pid_size;
+		alloc(pid_size + t.pid_size, true);
+		newT(pid_data + ps + pid_start, t.pid_data + t.pid_start, t.pid_size);
+		return *this;
+	}
+	inline PIDeque<T> & operator <<(const T & v) {return push_back(v);}
+	inline PIDeque<T> & operator <<(const PIDeque<T> & t) {
 		size_t ps = pid_size;
 		alloc(pid_size + t.pid_size, true);
 		newT(pid_data + ps + pid_start, t.pid_data + t.pid_start, t.pid_size);
 		return *this;
 	}
 
-	PIDeque<T> & push_front(const T & v) {insert(0, v); return *this;}
-	PIDeque<T> & prepend(const T & v) {return push_front(v);}
+	inline PIDeque<T> & push_front(const T & v) {insert(0, v); return *this;}
+	inline PIDeque<T> & prepend(const T & v) {return push_front(v);}
 
-	PIDeque<T> & pop_back() {if (pid_size == 0) return *this; resize(pid_size - 1); return *this;}
-	PIDeque<T> & pop_front() {if (pid_size == 0) return *this; remove(0); return *this;}
+	inline PIDeque<T> & pop_back() {if (pid_size == 0) return *this; resize(pid_size - 1); return *this;}
+	inline PIDeque<T> & pop_front() {if (pid_size == 0) return *this; remove(0); return *this;}
 
-	T take_back() {T t(back()); pop_back(); return t;}
-	T take_front() {T t(front()); pop_front(); return t;}
+	inline T take_back() {T t(back()); pop_back(); return t;}
+	inline T take_front() {T t(front()); pop_front(); return t;}
 
 	template <typename ST>
 	PIDeque<ST> toType() const {PIDeque<ST> ret(pid_size); for (uint i = 0; i < pid_size; ++i) ret[i] = ST(pid_data[i + pid_start]); return ret;}
 
 private:
-	void _reset() {pid_size = pid_rsize = pid_start = 0; pid_data = 0;}
+	inline void _reset() {pid_size = pid_rsize = pid_start = 0; pid_data = 0;}
 	/*void * qmemmove(void * dst, void * src, size_t size) {
 		if (piAbs<ssize_t>(ssize_t(dst) - ssize_t(src)) >= size)
 			memcpy(dst, src, size);
@@ -356,7 +363,7 @@ private:
 		for (size_t i = 0; i < s; ++i)
 			elementNew(dst + i, src[i]);
 	}
-	static T * newRaw(size_t s) {
+	inline static T * newRaw(size_t s) {
 		//std::cout << std::dec << "  ![("<<this<<")newRaw " << s << " elements ... <" << std::endl;
 		//uchar * ret = new uchar[s * sizeof(T)];
 		uchar * ret = (uchar*)(malloc(s * sizeof(T)));//new uchar[];
@@ -378,13 +385,13 @@ private:
 		}
 		//cout << "  > ok]~" << endl;
 	}
-	static void deleteRaw(T *& d) {
+	inline static void deleteRaw(T *& d) {
 		//cout << "  ~[("<<this<<")deleteRaw " << std::dec << pid_rsize << " elements " << std::hex << "0x" << (llong)d << " ... <\n" << endl;
 		if ((uchar*)d != 0) free((uchar*)d);
 		d = 0;
 		//cout << "  > ok]~" << endl;
 	}
-	static void zeroRaw(T * d, size_t s) {
+	inline static void zeroRaw(T * d, size_t s) {
 		//cout << "  ~[("<<this<<")zeroRaw " << std::dec << s << " elements " << std::hex << "0x" << (llong)d << " ... <\n" << endl;
 		if ((uchar*)d != 0) memset(d, 0, s*sizeof(T));
 		//cout << "  > ok]~" << endl;
diff --git a/src_main/containers/piframe.h b/src_main/containers/piframe.h
new file mode 100644
index 00000000..eb2f5df9
--- /dev/null
+++ b/src_main/containers/piframe.h
@@ -0,0 +1,86 @@
+#ifndef PIFRAME_H
+#define PIFRAME_H
+#include "pivector.h"
+
+template <typename T>
+class PIFrame {
+public:
+	inline PIFrame() {rows_ = cols_ = 0;}
+	inline PIFrame(size_t rows, size_t cols, const T & f = T()) {
+		rows_ = rows;
+		cols_ = cols;
+		mat.resize(rows*cols, f);
+	}
+	inline PIFrame(const PIVector<PIVector<T> > & v) {
+		rows_ = v.size();
+		if (rows_) {
+			cols_ = v[0].size();
+			for (size_t i = 0; i < rows_; i++) {
+				mat.append(v[i]);
+			}
+			mat.resize(rows_*cols_);
+		}
+		if (mat.isEmpty()) rows_ = cols_ = 0;
+	}
+
+	inline size_t rows() const {return rows_;}
+	inline size_t cols() const {return cols_;}
+//	inline size_t size() const {return mat.size();}
+//	inline ssize_t size_s() const {return mat.size_s();}
+	inline size_t length() const {return mat.length();}
+	inline bool isEmpty() const {return mat.isEmpty();}
+
+	class PIFrameRow {
+		friend class PIFrame<T>;
+	private:
+		inline PIFrameRow(PIFrame<T> * p, size_t row) : p_(p) {st_ = p_->cols_ * row;}
+		PIFrame<T> * p_;
+		size_t st_;
+	public:
+		inline size_t size() const {return p_->cols_;}
+		inline T & operator [](size_t index) {return p_->mat[st_ + index];}
+		inline const T & operator [](size_t index) const {return p_->mat[st_ + index];}
+	};
+
+	class PIFrameRowConst {
+		friend class PIFrame<T>;
+	private:
+		inline PIFrameRowConst(const PIFrame<T> * p, size_t row) : p_(p) {st_ = p_->cols_ * row;}
+		const PIFrame<T> * p_;
+		size_t st_;
+	public:
+		inline size_t size() const {return p_->cols_;}
+		inline const T & operator [](size_t index) const {return p_->mat[st_ + index];}
+	};
+
+
+	inline PIFrameRow operator[](size_t index) {return PIFrameRow(this, index);}
+	inline PIFrameRowConst operator[](size_t index) const {return PIFrameRowConst(this, index);}
+
+
+
+private:
+	size_t rows_, cols_;
+	PIVector<T> mat;
+};
+
+template<typename T>
+inline PICout operator <<(PICout s, const PIFrame<T> & v) {
+	s.setControl(0, true);
+	s << "{";
+	for (size_t i = 0; i < v.rows(); ++i) {
+		s << "{ ";
+		for (size_t j = 0; j < v.cols(); ++j) {
+			s << v[i][j];
+			if (j < v.cols() - 1) s << ", ";
+		}
+		s << " }";
+		if (i < v.rows() - 1) s << PICoutManipulators::NewLine ;
+	}
+	if (v.isEmpty()) s << "{ }";
+	s << "}";
+	s.restoreControl();
+	return s;
+}
+
+#endif // PIFRAME_H
diff --git a/src_main/containers/pivector.h b/src_main/containers/pivector.h
index 8d960b84..5a0ff2c7 100755
--- a/src_main/containers/pivector.h
+++ b/src_main/containers/pivector.h
@@ -77,107 +77,108 @@ public:
 	class iterator {
 		friend class PIVector<T>;
 	private:
-		iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		inline iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
 		PIVector<T> * parent;
 		size_t pos;
 	public:
-		iterator(): parent(0), pos(0) {}
-		T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {++pos;}
-		void operator ++(int) {++pos;}
-		void operator --() {--pos;}
-		void operator --(int) {--pos;}
-		bool operator ==(const iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const iterator & it) const {return (pos != it.pos);}
+		inline iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const iterator & it) const {return (pos != it.pos);}
 	};
 
 	class const_iterator {
 		friend class PIVector<T>;
 	private:
-		const_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		inline const_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
 		const PIVector<T> * parent;
 		size_t pos;
 	public:
-		const_iterator(): parent(0), pos(0) {}
+		inline const_iterator(): parent(0), pos(0) {}
 		//T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {++pos;}
-		void operator ++(int) {++pos;}
-		void operator --() {--pos;}
-		void operator --(int) {--pos;}
-		bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
 	};
 
 	class reverse_iterator {
 		friend class PIVector<T>;
 	private:
-		reverse_iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		inline reverse_iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
 		PIVector<T> * parent;
 		size_t pos;
 	public:
-		reverse_iterator(): parent(0), pos(0) {}
-		T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {--pos;}
-		void operator ++(int) {--pos;}
-		void operator --() {++pos;}
-		void operator --(int) {++pos;}
-		bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
+		inline reverse_iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
 	};
 
 	class const_reverse_iterator {
 		friend class PIVector<T>;
 	private:
-		const_reverse_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		inline const_reverse_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
 		const PIVector<T> * parent;
 		size_t pos;
 	public:
-		const_reverse_iterator(): parent(0), pos(0) {}
+		inline const_reverse_iterator(): parent(0), pos(0) {}
 		//T & operator *() {return (*parent)[pos];}
-		const T & operator *() const {return (*parent)[pos];}
-		void operator ++() {--pos;}
-		void operator ++(int) {--pos;}
-		void operator --() {++pos;}
-		void operator --(int) {++pos;}
-		bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
-		bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
 	};
 
-	iterator begin() {return iterator(this, 0);}
-	iterator end() {return iterator(this, piv_size);}
-	const_iterator begin() const {return const_iterator(this, 0);}
-	const_iterator end() const {return const_iterator(this, piv_size);}
-	reverse_iterator rbegin() {return reverse_iterator(this, piv_size - 1);}
-	reverse_iterator rend() {return reverse_iterator(this, -1);}
-	const_reverse_iterator rbegin() const {return const_reverse_iterator(this, piv_size - 1);}
-	const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
+	inline iterator begin() {return iterator(this, 0);}
+	inline iterator end() {return iterator(this, piv_size);}
+	inline const_iterator begin() const {return const_iterator(this, 0);}
+	inline const_iterator end() const {return const_iterator(this, piv_size);}
+	inline reverse_iterator rbegin() {return reverse_iterator(this, piv_size - 1);}
+	inline reverse_iterator rend() {return reverse_iterator(this, -1);}
+	inline const_reverse_iterator rbegin() const {return const_reverse_iterator(this, piv_size - 1);}
+	inline const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
 
-	size_t size() const {return piv_size;}
-	ssize_t size_s() const {return piv_size;}
-	size_t length() const {return piv_size;}
-	size_t capacity() const {return piv_rsize;}
-	bool isEmpty() const {return (piv_size == 0);}
+	inline size_t size() const {return piv_size;}
+	inline ssize_t size_s() const {return piv_size;}
+	inline size_t length() const {return piv_size;}
+	inline size_t capacity() const {return piv_rsize;}
+	inline bool isEmpty() const {return (piv_size == 0);}
 
-	T & operator [](size_t index) {return piv_data[index];}
-	T & at(size_t index) {return piv_data[index];}
-	const T & operator [](size_t index) const {return piv_data[index];}
-	const T & at(size_t index) const {return piv_data[index];}
-	T & back() {return piv_data[piv_size - 1];}
-	const T & back() const {return piv_data[piv_size - 1];}
-	T & front() {return piv_data[0];}
-	const T & front() const {return piv_data[0];}
-	bool operator ==(const PIVector<T> & t) const {if (piv_size != t.piv_size) return false; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return false; return true;}
-	bool operator !=(const PIVector<T> & t) const {if (piv_size != t.piv_size) return true; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return true; return false;}
-	bool contains(const T & v) const {for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return true; return false;}
-	int etries(const T & v) const {int ec = 0; for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) ++ec; return ec;}
-	ssize_t indexOf(const T & v) const {for (ssize_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return i; return -1;}
-	ssize_t lastIndexOf(const T & v) const {for (ssize_t i = piv_size - 1; i >= 0; --i) if (v == piv_data[i]) return i; return -1;}
+	inline T & operator [](size_t index) {return piv_data[index];}
+	inline T & at(size_t index) {return piv_data[index];}
+	inline const T & operator [](size_t index) const {return piv_data[index];}
+	inline const T & at(size_t index) const {return piv_data[index];}
+	inline T & back() {return piv_data[piv_size - 1];}
+	inline const T & back() const {return piv_data[piv_size - 1];}
+	inline T & front() {return piv_data[0];}
+	inline const T & front() const {return piv_data[0];}
+	inline bool operator ==(const PIVector<T> & t) const {if (piv_size != t.piv_size) return false; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return false; return true;}
+	inline bool operator !=(const PIVector<T> & t) const {if (piv_size != t.piv_size) return true; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return true; return false;}
+	inline bool contains(const T & v) const {for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return true; return false;}
+	inline int etries(const T & v) const {int ec = 0; for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) ++ec; return ec;}
+	inline ssize_t indexOf(const T & v) const {for (ssize_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return i; return -1;}
+	inline ssize_t lastIndexOf(const T & v) const {for (ssize_t i = piv_size - 1; i >= 0; --i) if (v == piv_data[i]) return i; return -1;}
+
+	inline T * data(size_t index = 0) {return &(piv_data[index]);}
+	inline const T * data(size_t index = 0) const {return &(piv_data[index]);}
 
-	T * data(size_t index = 0) {return &(piv_data[index]);}
-	const T * data(size_t index = 0) const {return &(piv_data[index]);}
 	inline PIVector<T> & clear() {resize(0); return *this;}
 	inline PIVector<T> & fill(const T & f = T()) {
 		//if (sizeof(T) == 1) memset(piv_data, f, piv_size);
@@ -230,7 +231,7 @@ public:
 		elementNew(piv_data + index, v);
 		return *this;
 	}
-	PIVector<T> & insert(size_t index, const PIVector<T> & other) {
+	inline PIVector<T> & insert(size_t index, const PIVector<T> & other) {
 		if (other.isEmpty()) return *this;
 		ssize_t os = piv_size - index;
 		alloc(piv_size + other.piv_size);
@@ -270,6 +271,12 @@ public:
 
 	inline PIVector<T> & push_back(const T & v) {alloc(piv_size + 1); elementNew(piv_data + piv_size - 1, v); return *this;}
 	inline PIVector<T> & append(const T & v) {return push_back(v);}
+	inline PIVector<T> & append(const PIVector<T> & other) {
+			size_t ps = piv_size;
+			alloc(piv_size + other.piv_size);
+			newT(piv_data + ps, other.piv_data, other.piv_size);
+			return *this;
+	}
 	inline PIVector<T> & operator <<(const T & v) {return push_back(v);}
 	inline PIVector<T> & operator <<(const PIVector<T> & other) {
 		size_t ps = piv_size;
diff --git a/src_main/io/pibinarylog.h b/src_main/io/pibinarylog.h
index 1b004eda..4c474df5 100644
--- a/src_main/io/pibinarylog.h
+++ b/src_main/io/pibinarylog.h
@@ -268,7 +268,7 @@ public:
 	static BinLogInfo getLogInfo(const PIString & path);
 
 protected:
-	PIString fullPathPrefix() const {return "binlog";}
+	PIString fullPathPrefix() const {return PIStringAscii("binlog");}
 	PIString constructFullPathDevice() const;
 	void configureFromFullPathDevice(const PIString & full_path);
 	int readDevice(void *read_to, int max_size);
diff --git a/src_main/io/pifile.h b/src_main/io/pifile.h
index 71bfd5ce..93b698f4 100755
--- a/src_main/io/pifile.h
+++ b/src_main/io/pifile.h
@@ -286,7 +286,7 @@ public:
 //! \}
 
 protected:
-	PIString fullPathPrefix() const {return "file";}
+	PIString fullPathPrefix() const {return PIStringAscii("file");}
 	PIString constructFullPathDevice() const;
 	void configureFromFullPathDevice(const PIString & full_path);
 	int readDevice(void * read_to, int max_size);
diff --git a/src_main/io/pipacketextractor.h b/src_main/io/pipacketextractor.h
index 3f1f0dec..4061430b 100755
--- a/src_main/io/pipacketextractor.h
+++ b/src_main/io/pipacketextractor.h
@@ -157,7 +157,7 @@ private:
 	int readDevice(void * read_to, int max_size) {if (dev == 0) return -1; return dev->read(read_to, max_size);}
 	int writeDevice(const void * data, int max_size) {if (dev == 0) return -1; return dev->write(data, max_size);}
 	bool threadedRead(uchar * readed, int size);
-	PIString fullPathPrefix() const {return "pckext";}
+	PIString fullPathPrefix() const {return PIStringAscii("pckext");}
 	PIString constructFullPathDevice() const;
 	bool openDevice() {if (dev == 0) return false; return dev->open();}
 
diff --git a/src_main/io/pipeer.cpp b/src_main/io/pipeer.cpp
index 335d87d3..99a73657 100755
--- a/src_main/io/pipeer.cpp
+++ b/src_main/io/pipeer.cpp
@@ -448,11 +448,12 @@ bool PIPeer::sendInternal(const PIString & to, const PIByteArray & data) {
 
 
 void PIPeer::dtReceived(const PIString & from, const PIByteArray & data) {
+	PIByteArray ba = data;
 	dataReceived(from, data);
 	dataReceivedEvent(from, data);
 	if (trust_peer.isEmpty() || trust_peer == from) {
 		read_buffer_mutex.lock();
-		if (read_buffer.size_s() < read_buffer_size) read_buffer.enqueue(data);
+		if (read_buffer.size_s() < read_buffer_size) read_buffer.enqueue(ba);
 		read_buffer_mutex.unlock();
 	}
 }
@@ -860,10 +861,11 @@ bool PIPeer::openDevice() {
 	diag_d.reset();
 	diag_s.reset();
 	//piCoutObj << "open...";
-	PIMutexLocker ml(peers_mutex);
-	if (trust_peer.isEmpty())
-		return !peers.isEmpty();
-	return hasPeer(trust_peer);
+	return true;
+//	PIMutexLocker ml(peers_mutex);
+//	if (trust_peer.isEmpty())
+//		return !peers.isEmpty();
+//	return hasPeer(trust_peer);
 }
 
 
diff --git a/src_main/io/pipeer.h b/src_main/io/pipeer.h
index d860126a..540d8673 100755
--- a/src_main/io/pipeer.h
+++ b/src_main/io/pipeer.h
@@ -166,7 +166,7 @@ private:
 
 	bool openDevice();
 	bool closeDevice();
-	PIString fullPathPrefix() const {return "peer";}
+	PIString fullPathPrefix() const {return PIStringAscii("peer");}
 	PIString constructFullPathDevice() const;
 	void configureFromFullPathDevice(const PIString &full_path);
 	int readDevice(void * read_to, int max_size);
diff --git a/src_main/io/piserial.h b/src_main/io/piserial.h
index bbf06766..6a45d7c3 100755
--- a/src_main/io/piserial.h
+++ b/src_main/io/piserial.h
@@ -205,7 +205,7 @@ public:
 //! \}
 	
 protected:
-	PIString fullPathPrefix() const {return "ser";}
+	PIString fullPathPrefix() const {return PIStringAscii("ser");}
 	PIString constructFullPathDevice() const;
 	void configureFromFullPathDevice(const PIString & full_path);
 	bool configureDevice(const void * e_main, const void * e_parent = 0);
diff --git a/src_main/io/pisharedmemory.cpp b/src_main/io/pisharedmemory.cpp
index c0aa08ae..ca3a4550 100644
--- a/src_main/io/pisharedmemory.cpp
+++ b/src_main/io/pisharedmemory.cpp
@@ -54,7 +54,7 @@
  * 
  */
 
-//REGISTER_DEVICE(PISharedMemory);
+REGISTER_DEVICE(PISharedMemory)
 
 PRIVATE_DEFINITION_START(PISharedMemory)
 	PIByteArray name;
@@ -71,7 +71,7 @@ PRIVATE_DEFINITION_END(PISharedMemory)
 
 PISharedMemory::PISharedMemory(): PIIODevice() {
 	initPrivate();
-	dsize = -1;
+	dsize = 65536;
 }
 
 
@@ -93,6 +93,7 @@ PISharedMemory::PISharedMemory(const PISharedMemory & other) {
 
 bool PISharedMemory::openDevice() {
 	close();
+	piCoutObj << "try open" << path() << dsize;
 #ifdef WINDOWS
 	DWORD m = PAGE_READWRITE;
 	if (!isWriteable()) m = PAGE_READONLY;
@@ -100,14 +101,14 @@ bool PISharedMemory::openDevice() {
 	PRIVATE->name.push_back(0);
 	PRIVATE->map = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, m, 0, (DWORD)dsize, (const char *)PRIVATE->name.data());
 	if (!PRIVATE->map) {
-		piCoutObj << "CreateFileMapping error," << errorString();
+		piCoutObj << path() << dsize << "CreateFileMapping error," << errorString();
 		return false;
 	}
 	if (!isWriteable()) m = FILE_MAP_READ;
 	else m = FILE_MAP_ALL_ACCESS;
 	PRIVATE->data = MapViewOfFile(PRIVATE->map, m, 0, 0, dsize);
 	if (!PRIVATE->data) {
-		piCoutObj << "MapViewOfFile error," << errorString();
+		piCoutObj << path() << dsize << "MapViewOfFile error," << errorString();
 		CloseHandle(PRIVATE->map);
 		return false;
 	}
@@ -166,6 +167,26 @@ bool PISharedMemory::closeDevice() {
 }
 
 
+PIString PISharedMemory::constructFullPathDevice() const {
+	PIString ret;
+	ret << path() << ":" << dsize;
+	return ret;
+}
+
+
+void PISharedMemory::configureFromFullPathDevice(const PIString & full_path) {
+	initPrivate();
+	PIStringList pl = full_path.split(":");
+	for (int i = 0; i < pl.size_s(); ++i) {
+		PIString p(pl[i]);
+		switch (i) {
+			case 0: setPath(p); break;
+			case 1: dsize = p.toInt(); break;
+		}
+	}
+}
+
+
 void PISharedMemory::initPrivate() {
 #ifdef WINDOWS
 	PRIVATE->map = 0;
diff --git a/src_main/io/pisharedmemory.h b/src_main/io/pisharedmemory.h
index 1e885165..9144ed46 100644
--- a/src_main/io/pisharedmemory.h
+++ b/src_main/io/pisharedmemory.h
@@ -71,6 +71,9 @@ public:
 protected:
 	bool openDevice();
 	bool closeDevice();
+	PIString fullPathPrefix() const {return PIStringAscii("shm");}
+	PIString constructFullPathDevice() const;
+	void configureFromFullPathDevice(const PIString & full_path);
 	int readDevice(void * read_to, int max_size) {return read(read_to, max_size, 0);}
 	int writeDevice(const void * data, int max_size) {return write(data, max_size, 0);}
 
diff --git a/src_main/io/pitransparentdevice.cpp b/src_main/io/pitransparentdevice.cpp
index a252b74c..70dacee5 100644
--- a/src_main/io/pitransparentdevice.cpp
+++ b/src_main/io/pitransparentdevice.cpp
@@ -61,9 +61,7 @@ int PITransparentDevice::writeDevice(const void * data, int max_size) {
 }
 
 
-PIString PITransparentDevice::fullPathPrefix() const {
-	return PIStringAscii("tr");
-}
+
 
 
 bool PITransparentDevice::openDevice() {
diff --git a/src_main/io/pitransparentdevice.h b/src_main/io/pitransparentdevice.h
index c6020eac..1d6fa894 100644
--- a/src_main/io/pitransparentdevice.h
+++ b/src_main/io/pitransparentdevice.h
@@ -41,7 +41,7 @@ protected:
 	bool closeDevice();
 	int readDevice(void * read_to, int max_size);
 	int writeDevice(const void * data, int max_size);
-	PIString fullPathPrefix() const;
+	PIString fullPathPrefix() const {return PIStringAscii("tr");}
 
 	PIMutex que_mutex;
 	PIQueue<PIByteArray> que;
diff --git a/src_main/io/piusb.h b/src_main/io/piusb.h
index ad30f8f6..31ece53e 100755
--- a/src_main/io/piusb.h
+++ b/src_main/io/piusb.h
@@ -126,7 +126,7 @@ public:
 	void flush();
 
 protected:
-	PIString fullPathPrefix() const {return "usb";}
+	PIString fullPathPrefix() const {return PIStringAscii("usb");}
 	bool configureDevice(const void * e_main, const void * e_parent = 0);
 	PIString constructFullPathDevice() const;
 	void configureFromFullPathDevice(const PIString & full_path);