diff --git a/uppsrc/Core/Color.cpp b/uppsrc/Core/Color.cpp
index 16aaf91fd..2d0fc06cd 100644
--- a/uppsrc/Core/Color.cpp
+++ b/uppsrc/Core/Color.cpp
@@ -90,24 +90,42 @@ Color::Color(RGBA rgba)
 
 void Color::Jsonize(JsonIO& jio)
 {
-	int r = GetR();
-	int g = GetG();
-	int b = GetB();
+	int r, g, b;
+	if(IsNullInstance()) {
+		r = g = b = Null;
+	}
+	else {
+		r = GetR();
+		g = GetG();
+		b = GetB();
+	}
 	jio("red", r)("green", g)("blue", b);
-	*this = Color(r, g, b);	
+	if(IsNull(r))
+		*this = Null;
+	else
+		*this = Color(r, g, b);	
 }
 
 void Color::Xmlize(XmlIO& xio)
 {
-	int r = GetR();
-	int g = GetG();
-	int b = GetB();
+	int r, g, b;
+	if(IsNullInstance()) {
+		r = g = b = Null;
+	}
+	else {
+		r = GetR();
+		g = GetG();
+		b = GetB();
+	}
 	xio
 		.Attr("red", r)
 		.Attr("green", g)
 		.Attr("blue", b)
 	;
-	*this = Color(r, g, b);
+	if(IsNull(r))
+		*this = Null;
+	else
+		*this = Color(r, g, b);	
 }
 
 RGBA operator*(int alpha, Color c)
diff --git a/uppsrc/Core/JSON.cpp b/uppsrc/Core/JSON.cpp
index 6923113a2..79697ba93 100644
--- a/uppsrc/Core/JSON.cpp
+++ b/uppsrc/Core/JSON.cpp
@@ -1,307 +1,310 @@
-#include "Core.h"
-
-NAMESPACE_UPP
-
-Value ParseJSON(CParser& p)
-{
-	p.UnicodeEscape();
-	if(p.IsNumber())
-		return p.ReadDouble();
-	if(p.IsString())
-		return p.ReadString();
-	if(p.Id("null"))
-		return Null;
-	if(p.Id("true"))
-		return true;
-	if(p.Id("false"))
-		return false;
-	if(p.Char('{')) {
-		ValueMap m;
-		if(!p.IsChar('}'))
-			do {
-				String key = p.ReadString();
-				p.PassChar(':');
-				m.Add(key, ParseJSON(p));
-			}
-			while(p.Char(','));
-		p.PassChar('}');
-		return m;
-	}
-	if(p.Char('[')) {
-		ValueArray va;
-		if(!p.IsChar(']'))
-			do
-				va.Add(ParseJSON(p));
-			while(p.Char(','));
-		p.PassChar(']');
-		return va;		
-	}
-	p.ThrowError("Unrecognized JSON element");
-	return Null;
-}
-
-Value ParseJSON(const char *s)
-{
-	try {
-		CParser p(s);
-		return ParseJSON(p);
-	}
-	catch(CParser::Error) {
-		return ErrorValue();
-	}
-}
-
-String AsJSON(const Value& v, const String& sep, bool pretty)
-{
-	String r;
-	if(v.GetType() == VALUEMAP_V) {
-		r << "{";
-		String sep1;
-		if(pretty) {
-			r << "\r\n";
-			sep1 = sep + '\t';
-		}
-		ValueMap m = v;
-		ValueArray va = m.GetValues();
-		for(int i = 0; i < m.GetCount(); i++) {
-			if(i) {
-				r << ",";
-				if(pretty)
-					r << "\r\n";
-			}
-			if(pretty)
-				r << sep1;
-			r << AsCString((String)m.GetKeys()[i]) << (pretty ? ": " : ":")
-			  << AsJSON(va[i], sep1, pretty);
-		}
-		if(pretty)
-			r << "\r\n" << sep;
-		r << "}";
-		return r;
-	}
-	if(v.GetType() == VALUEARRAY_V) {
-		r << "[";
-		String sep1;
-		if(pretty) {
-			r << "\r\n";
-			sep1 = sep + '\t';
-		}
-		ValueArray va = v;
-		for(int i = 0; i < va.GetCount(); i++) {
-			if(i) {
-				r << ",";
-				if(pretty)
-					r << "\r\n";
-			}
-			if(pretty)
-				r << sep1;
-			r << AsJSON(va[i], sep1, pretty);
-		}
-		if(pretty)
-			r << "\r\n" << sep;
-		r << "]";
-		return r;
-	}
-	if(IsNumber(v) && IsNull(v))
-		return "null";
-	if(v.GetType() == INT_V)
-		return Format("%d", (int)v);
-	if(v.GetType() == BOOL_V)
-		return (bool)v ? "true" : "false";
-	if(IsNumber(v))
-		return Format("%.16g", (double)v);
-	if(IsString(v))
-		return AsCString((String)v);
-	if(IsNull(v))
-		return "null";
-	NEVER();
-	return "null";
-}
-
-String AsJSON(const Value& v, bool pretty)
-{
-	return AsJSON(v, String(), pretty);
-}
-
-template<> void Jsonize(JsonIO& io, double& var)
-{
-	if(io.IsLoading()) {
-		const Value& v = io.Get();
-		if(IsNull(v)) {
-			var = Null;
-			return;
-		}
-		if(IsNumber(v)) {
-			var = io.Get();
-			return;
-		}
-		if(IsString(v)) {
-			double h = ScanDouble((String)v);
-			if(!IsNull(h)) {
-				var = h;
-				return;
-			}
-		}
-		throw JsonizeError("number expected");
-	}
-	else
-		io.Set(var);
-}
-
-template<> void Jsonize(JsonIO& io, int& var)
-{
-	double v = IntDbl(var);
-	Jsonize(io, v);
-	if(io.IsLoading())
-		if(IsNull(v))
-			var = Null;
-		else
-		if(v >= INT_MIN && v <= INT_MAX)
-			var = (int)v;
-		else
-			throw JsonizeError("number is not integer");
-}
-
-template<> void Jsonize(JsonIO& io, bool& var)
-{
-	if(io.IsLoading()) {
-		const Value& v = io.Get();
-		if(IsNumber(v) && !IsNull(v))
-			var = (bool)v;
-		else
-			throw JsonizeError("boolean expected");
-	}
-	else
-		io.Set(var);
-}
-
-template<> void Jsonize(JsonIO& io, int64& var)
-{
-	if(io.IsLoading()) {
-		const Value& v = io.Get();
-		if(IsNull(v)) {
-			var = Null;
-			return;
-		}
-		if(v.Is<int64>() || v.Is<int>()) {
-			var = v;
-			return;
-		}
-		if(IsNumber(v)) {
-			double d = v;
-			if(d >= INT64_MIN && d <= INT64_MAX) {
-				var = (int64)d;
-				return;
-			}
-		}
-		else
-		if(IsString(v)) {
-			int64 h = ScanInt64((String)v);
-			if(!IsNull(h)) {
-				var = h;
-				return;
-			}
-		}
-		throw JsonizeError("invalid int64 value");
-	}
-	else
-		if(IsNull(var))
-			io.Set(Null);
-		else
-		if(var >= INT_MIN && var <= INT_MAX)
-			io.Set(var);
-		else
-			io.Set(AsString(var));
-}
-
-template<> void Jsonize(JsonIO& io, String& var)
-{
-	if(io.IsLoading()) {
-		const Value& v = io.Get();
-		if(IsString(v))
-			var = v;
-		else
-			throw JsonizeError("string expected");
-	}
-	else
-		io.Set(var);
-}
-
-template<> void Jsonize(JsonIO& io, WString& var)
-{
-	if(io.IsLoading()) {
-		const Value& v = io.Get();
-		if(IsString(v))
-			var = v;
-		else
-			throw JsonizeError("string expected");
-	}
-	else
-		io.Set(var);
-}
-
-template<> void Jsonize(JsonIO& io, Date& var)
-{
-	if(io.IsLoading()) {
-		const Value& v = io.Get();
-		if(IsNull(v)) {
-			var = Null;
-			return;
-		}
-		if(IsString(v)) {
-			String text = v;
-			if(text.GetCount() > 6) {
-				Date d;
-				d.year = ScanInt(text.Left(4));
-				d.month = ScanInt(text.Mid(4, 2));
-				d.day = ScanInt(text.Mid(6));
-				if(var.IsValid()) {
-					var = d;
-					return;
-				}
-			}
-		}
-		throw JsonizeError("string expected for Date value");
-	}
-	else
-		if(IsNull(var))
-			io.Set(Null);
-		else
-			io.Set(Format("%04d%02d%02d", var.year, var.month, var.day));
-}
-
-template<> void Jsonize(JsonIO& io, Time& var)
-{
-	if(io.IsLoading()) {
-		const Value& v = io.Get();
-		if(IsNull(v)) {
-			var = Null;
-			return;
-		}
-		if(IsString(v)) {
-			String text = v;
-			if(text.GetCount() > 15) {
-				Time tm;
-				tm.year = ScanInt(text.Left(4));
-				tm.month = ScanInt(text.Mid(4, 2));
-				tm.day = ScanInt(text.Mid(6, 2));
-				tm.hour = ScanInt(text.Mid(9, 2));
-				tm.minute = ScanInt(text.Mid(12, 2));
-				tm.second = ScanInt(text.Mid(15));
-				if(var.IsValid()) {
-					var = tm;
-					return;
-				}
-			}
-		}
-		throw JsonizeError("string expected for Time value");
-	}
-	else
-		if(IsNull(var))
-			io.Set(Null);
-		else
-			io.Set(Format("%04d%02d%02d`T%02d:%02d:%02d",
-				          var.year, var.month, var.day, var.hour, var.minute, var.second));
-}
-
-END_UPP_NAMESPACE
+#include "Core.h"
+
+NAMESPACE_UPP
+
+Value ParseJSON(CParser& p)
+{
+	p.UnicodeEscape();
+	if(p.IsNumber())
+		return p.ReadDouble();
+	if(p.IsString())
+		return p.ReadString();
+	if(p.Id("null"))
+		return Null;
+	if(p.Id("true"))
+		return true;
+	if(p.Id("false"))
+		return false;
+	if(p.Char('{')) {
+		ValueMap m;
+		if(!p.IsChar('}'))
+			do {
+				String key = p.ReadString();
+				p.PassChar(':');
+				m.Add(key, ParseJSON(p));
+			}
+			while(p.Char(','));
+		p.PassChar('}');
+		return m;
+	}
+	if(p.Char('[')) {
+		ValueArray va;
+		if(!p.IsChar(']'))
+			do
+				va.Add(ParseJSON(p));
+			while(p.Char(','));
+		p.PassChar(']');
+		return va;		
+	}
+	p.ThrowError("Unrecognized JSON element");
+	return Null;
+}
+
+Value ParseJSON(const char *s)
+{
+	try {
+		CParser p(s);
+		return ParseJSON(p);
+	}
+	catch(CParser::Error) {
+		return ErrorValue();
+	}
+}
+
+String AsJSON(const Value& v, const String& sep, bool pretty)
+{
+	String r;
+	if(v.GetType() == VALUEMAP_V) {
+		r << "{";
+		String sep1;
+		if(pretty) {
+			r << "\r\n";
+			sep1 = sep + '\t';
+		}
+		ValueMap m = v;
+		ValueArray va = m.GetValues();
+		for(int i = 0; i < m.GetCount(); i++) {
+			if(i) {
+				r << ",";
+				if(pretty)
+					r << "\r\n";
+			}
+			if(pretty)
+				r << sep1;
+			r << AsCString((String)m.GetKeys()[i]) << (pretty ? ": " : ":")
+			  << AsJSON(va[i], sep1, pretty);
+		}
+		if(pretty)
+			r << "\r\n" << sep;
+		r << "}";
+		return r;
+	}
+	if(v.GetType() == VALUEARRAY_V) {
+		r << "[";
+		String sep1;
+		if(pretty) {
+			r << "\r\n";
+			sep1 = sep + '\t';
+		}
+		ValueArray va = v;
+		for(int i = 0; i < va.GetCount(); i++) {
+			if(i) {
+				r << ",";
+				if(pretty)
+					r << "\r\n";
+			}
+			if(pretty)
+				r << sep1;
+			r << AsJSON(va[i], sep1, pretty);
+		}
+		if(pretty)
+			r << "\r\n" << sep;
+		r << "]";
+		return r;
+	}
+	if(IsNumber(v) && IsNull(v))
+		return "null";
+	if(v.GetType() == INT_V)
+		return Format("%d", (int)v);
+	if(v.GetType() == BOOL_V)
+		return (bool)v ? "true" : "false";
+	if(IsNumber(v))
+		return Format("%.16g", (double)v);
+	if(IsString(v))
+		return AsCString((String)v);
+	if(IsNull(v))
+		return "null";
+	NEVER();
+	return "null";
+}
+
+String AsJSON(const Value& v, bool pretty)
+{
+	return AsJSON(v, String(), pretty);
+}
+
+template<> void Jsonize(JsonIO& io, double& var)
+{
+	if(io.IsLoading()) {
+		const Value& v = io.Get();
+		if(IsNull(v)) {
+			var = Null;
+			return;
+		}
+		if(IsNumber(v)) {
+			var = io.Get();
+			return;
+		}
+		if(IsString(v)) {
+			double h = ScanDouble((String)v);
+			if(!IsNull(h)) {
+				var = h;
+				return;
+			}
+		}
+		throw JsonizeError("number expected");
+	}
+	else
+		io.Set(var);
+}
+
+template<> void Jsonize(JsonIO& io, int& var)
+{
+	double v = IntDbl(var);
+	Jsonize(io, v);
+	if(io.IsLoading())
+		if(IsNull(v))
+			var = Null;
+		else
+		if(v >= INT_MIN && v <= INT_MAX)
+			var = (int)v;
+		else
+			throw JsonizeError("number is not integer");
+}
+
+template<> void Jsonize(JsonIO& io, bool& var)
+{
+	if(io.IsLoading()) {
+		const Value& v = io.Get();
+		if(IsNumber(v) && !IsNull(v))
+			var = (bool)v;
+		else
+			throw JsonizeError("boolean expected");
+	}
+	else
+		io.Set(var);
+}
+
+template<> void Jsonize(JsonIO& io, int64& var)
+{
+	if(io.IsLoading()) {
+		const Value& v = io.Get();
+		if(IsNull(v)) {
+			var = Null;
+			return;
+		}
+		if(v.Is<int64>() || v.Is<int>()) {
+			var = v;
+			return;
+		}
+		if(IsNumber(v)) {
+			double d = v;
+			if(d >= INT64_MIN && d <= INT64_MAX) {
+				var = (int64)d;
+				return;
+			}
+		}
+		else
+		if(IsString(v)) {
+			int64 h = ScanInt64((String)v);
+			if(!IsNull(h)) {
+				var = h;
+				return;
+			}
+		}
+		throw JsonizeError("invalid int64 value");
+	}
+	else
+		if(IsNull(var))
+			io.Set(Null);
+		else
+		if(var >= INT_MIN && var <= INT_MAX)
+			io.Set(var);
+		else
+			io.Set(AsString(var));
+}
+
+template<> void Jsonize(JsonIO& io, String& var)
+{
+	if(io.IsLoading()) {
+		const Value& v = io.Get();
+		if(IsString(v))
+			var = v;
+		else
+			throw JsonizeError("string expected");
+	}
+	else
+		io.Set(var);
+}
+
+template<> void Jsonize(JsonIO& io, WString& var)
+{
+	if(io.IsLoading()) {
+		const Value& v = io.Get();
+		if(IsString(v))
+			var = v;
+		else
+			throw JsonizeError("string expected");
+	}
+	else
+		io.Set(var);
+}
+
+template<> void Jsonize(JsonIO& io, Date& var)
+{
+	if(io.IsLoading()) {
+		const Value& v = io.Get();
+		if(IsNull(v)) {
+			var = Null;
+			return;
+		}
+		if(IsString(v)) {
+			String text = v;
+			if(text.GetCount() > 6) {
+				DDUMP(text);
+				Date d;
+				d.year = ScanInt(text.Left(4));
+				d.month = ScanInt(text.Mid(4, 2));
+				d.day = ScanInt(text.Mid(6));
+				DDUMP(d);
+				if(d.IsValid()) {
+					var = d;
+					DDUMP(var);
+					return;
+				}
+			}
+		}
+		throw JsonizeError("string expected for Date value");
+	}
+	else
+		if(IsNull(var))
+			io.Set(Null);
+		else
+			io.Set(Format("%04d%02d%02d", var.year, var.month, var.day));
+}
+
+template<> void Jsonize(JsonIO& io, Time& var)
+{
+	if(io.IsLoading()) {
+		const Value& v = io.Get();
+		if(IsNull(v)) {
+			var = Null;
+			return;
+		}
+		if(IsString(v)) {
+			String text = v;
+			if(text.GetCount() > 15) {
+				Time tm;
+				tm.year = ScanInt(text.Left(4));
+				tm.month = ScanInt(text.Mid(4, 2));
+				tm.day = ScanInt(text.Mid(6, 2));
+				tm.hour = ScanInt(text.Mid(9, 2));
+				tm.minute = ScanInt(text.Mid(12, 2));
+				tm.second = ScanInt(text.Mid(15));
+				if(tm.IsValid()) {
+					var = tm;
+					return;
+				}
+			}
+		}
+		throw JsonizeError("string expected for Time value");
+	}
+	else
+		if(IsNull(var))
+			io.Set(Null);
+		else
+			io.Set(Format("%04d%02d%02d`T%02d:%02d:%02d",
+				          var.year, var.month, var.day, var.hour, var.minute, var.second));
+}
+
+END_UPP_NAMESPACE
diff --git a/uppsrc/Core/OldValue.cpp b/uppsrc/Core/OldValue.cpp
index 5a22e9ec4..4aca2d16a 100644
--- a/uppsrc/Core/OldValue.cpp
+++ b/uppsrc/Core/OldValue.cpp
@@ -1,685 +1,685 @@
-#include "Core.h"
-
-#ifndef  SVO_VALUE
-
-NAMESPACE_UPP
-
-#ifndef flagSO
-const Nuller Null;
-#endif
-
-#define LTIMING(x) // RTIMING(x)
-
-unsigned Value::GetHashValue() const {
-	return IsNull() ? 0 : ptr->GetHashValue();
-}
-
-Value& Value::operator=(const Value& v) {
-	if(this == &v) return *this;
-	ptr->Release();
-	ptr = v.ptr;
-	ptr->Retain();
-	return *this;
-}
-
-Value::Value(const Value& v) {
-	ptr = v.ptr;
-	ptr->Retain();
-}
-
-void Value::SetVoidVal()
-{
-	ptr = &Single<Void>();
-	ptr->Retain();
-}
-
-Value::Value() {
-	SetVoidVal();
-}
-
-Value::~Value() {
-	ptr->Release();
-}
-
-bool Value::operator==(const Value& v) const {
-	if(ptr == v.ptr) return true;
-	bool an = IsNull();
-	bool bn = v.IsNull();
-	if(an || bn) return an && bn;
-	if(GetType() == v.GetType())
-		return ptr->IsEqual(v.ptr);
-	return ptr->IsPolyEqual(v) || v.ptr->IsPolyEqual(*this);
-}
-
-Value::Value(const String& s)  { ptr = new RichValueRep<String>(s); }
-Value::Value(const WString& s) { ptr = new RichValueRep<WString>(s); }
-Value::Value(const char *s)    { ptr = new RichValueRep<String>(s); }
-Value::Value(int i)            { ptr = new RichValueRep<int>(i); }
-Value::Value(int64 i)          { ptr = new RichValueRep<int64>(i); }
-Value::Value(double d)         { ptr = new RichValueRep<double>(d); }
-Value::Value(bool b)           { ptr = new RichValueRep<bool>(b); }
-Value::Value(Date d)           { ptr = new RichValueRep<Date>(d); }
-Value::Value(Time t)           { ptr = new RichValueRep<Time>(t); }
-Value::Value(const Nuller&)    { ptr = new RichValueRep<int>(Null); }
-
-Value::operator String() const
-{
-	if(IsNull()) return Null;
-	return GetType() == WSTRING_V ? RichValue<WString>::Extract(*this).ToString()
-		                          : RichValue<String>::Extract(*this);
-}
-
-Value::operator WString() const
-{
-	if(IsNull()) return Null;
-	return GetType() == WSTRING_V ? RichValue<WString>::Extract(*this)
-		                          : RichValue<String>::Extract(*this).ToWString();
-}
-
-Value::operator Date() const
-{
-	if(IsNull()) return Null;
-	return GetType() == DATE_V ? RichValue<Date>::Extract(*this)
-		                       : Date(RichValue<Time>::Extract(*this));
-}
-
-Value::operator Time() const
-{
-	if(IsNull()) return Null;
-	return GetType() == DATE_V ? ToTime(RichValue<Date>::Extract(*this))
-		                       : RichValue<Time>::Extract(*this);
-}
-
-Value::operator double() const
-{
-	if(IsNull()) return Null;
-	return GetType() == INT_V   ? double(RichValue<int>::Extract(*this))
-	     : GetType() == BOOL_V ? double(RichValue<bool>::Extract(*this))
-	     : GetType() == INT64_V ? double(RichValue<int64>::Extract(*this))
-		                        : RichValue<double>::Extract(*this);
-}
-
-Value::operator int() const
-{
-	if(IsNull()) return Null;
-	return GetType() == INT_V   ? RichValue<int>::Extract(*this)
-	     : GetType() == BOOL_V ? int(RichValue<bool>::Extract(*this))
-	     : GetType() == INT64_V ? int(RichValue<int64>::Extract(*this))
-		                        : int(RichValue<double>::Extract(*this));
-}
-
-Value::operator int64() const
-{
-	if(IsNull()) return Null;
-	return GetType() == INT_V   ? int64(RichValue<int>::Extract(*this))
-	     : GetType() == BOOL_V ? int64(RichValue<bool>::Extract(*this))
-	     : GetType() == INT64_V ? RichValue<int64>::Extract(*this)
-		                        : int64(RichValue<double>::Extract(*this));
-}
-
-Value::operator bool() const
-{
-	if(IsNull()) return false;
-	return operator int();
-}
-
-VectorMap<dword, Value::Void *(*)(Stream& s)>& Value::Typemap()
-{
-	static VectorMap<dword, Value::Void *(*)(Stream& s)> x;
-	return x;
-}
-
-Value::Void *ValueArrayDataCreate(Stream& s)
-{
-	ValueArray::Data *a = new ValueArray::Data;
-	a->Serialize(s);
-	return a;
-}
-
-Value::Void *ValueMapDataCreate(Stream& s)
-{
-	ValueMap::Data *a = new ValueMap::Data;
-	a->Serialize(s);
-	return a;
-}
-
-static void sRegisterStd()
-{
-	ONCELOCK {
-		RichValue<int>::Register();
-		RichValue<int64>::Register();
-		RichValue<bool>::Register();
-		RichValue<double>::Register();
-		RichValue<String>::Register();
-		RichValue<WString>::Register();
-		RichValue<Date>::Register();
-		RichValue<Time>::Register();
-		RichValue<Complex>::Register();
-		Value::Register(VALUEARRAY_V, ValueArrayDataCreate);
-		Value::Register(VALUEMAP_V, ValueMapDataCreate);
-	};
-}
-
-INITBLOCK {
-	sRegisterStd();
-}
-
-void Value::Serialize(Stream& s) {
-	sRegisterStd();
-	dword type;
-	if(s.IsLoading()) {
-		s / type;
-		ptr->Release();
-		typedef Void* (*vp)(Stream& s);
-		vp *cr = Typemap().FindPtr(type);
-		if(cr)
-			ptr = (**cr)(s);
-		else {
-			SetVoidVal();
-			if(type != VOID_V && type != ERROR_V)
-				s.LoadError();
-		}
-	}
-	else {
-		type = GetType();
-		ASSERT_(!type || type == ERROR_V || type == UNKNOWN_V || Typemap().Find(type) >= 0, "Missing RichValueType<" + AsString(type) + ">::Register");
-		s / type;
-		ptr->Serialize(s);
-	}
-}
-
-void Value::Register(dword w, Void* (*c)(Stream& s)) init_ {
-#ifdef flagCHECKINIT
-	RLOG("Register valuetype " << w);
-#endif
-	AssertST();
-	ASSERT(w != UNKNOWN_V);
-	ASSERT(w < 0x8000000);
-	CHECK(Typemap().GetAdd(w, c) == c);
-}
-
-String  Value::ToString() const {
-	return ptr->AsString();
-}
-
-class ValueErrorCls : public RichValueRep<String> {
-public:
-	virtual dword      GetType() const             { return ERROR_V; }
-	virtual bool       IsNull() const              { return true; }
-	virtual void       Serialize(Stream& s)        {}
-	virtual String     AsString() const            { return "<error: \'" + v + "\'>"; }
-
-	ValueErrorCls(const String& s) : RichValueRep<String>(s)  {}
-};
-
-Value ErrorValue(const String& s) {
-	return Value(new ValueErrorCls(s));
-}
-
-Value ErrorValue(const char *s) {
-	return ErrorValue(String(s));
-}
-
-const Value& ErrorValue() {
-	static Value *p;
-	ONCELOCK {
-		static Value v = ErrorValue(String());
-		p = &v;
-	}
-	return *p;
-}
-
-String GetErrorText(const Value& v) {
-	ASSERT(IsError(v));
-	return ((RichValueRep<String> *)v.GetVoidPtr())->Get();
-}
-
-// ----------------------------------
-
-struct Ref::ValueRef : public RefManager {
-	virtual int   GetType()                            { return VALUE_V; }
-	virtual Value GetValue(const void *ptr)            { return *(Value *) ptr; }
-	virtual bool  IsNull(const void *ptr)              { return UPP::IsNull(*(Value *) ptr); }
-	virtual void  SetValue(void *ptr, const Value& v)  { *(Value *) ptr = v; }
-	virtual void  SetNull(void *ptr)                   { *(Value *) ptr = Null; }
-};
-
-Ref::Ref(String& s)  { ptr = &s; m = &Single< RichRef<String> >(); }
-Ref::Ref(WString& s) { ptr = &s; m = &Single< RichRef<WString> >(); }
-Ref::Ref(int& i)     { ptr = &i; m = &Single< RichRef<int> >(); }
-Ref::Ref(int64& i)   { ptr = &i; m = &Single< RichRef<int64> >(); }
-Ref::Ref(double& d)  { ptr = &d; m = &Single< RichRef<double> >(); }
-Ref::Ref(bool& b)    { ptr = &b; m = &Single< RichRef<bool> >(); }
-Ref::Ref(Date& d)    { ptr = &d; m = &Single< RichRef<Date> >(); }
-Ref::Ref(Time& t)    { ptr = &t; m = &Single< RichRef<Time> >(); }
-Ref::Ref(Value& v)   { ptr = &v; m = &Single< ValueRef >(); }
-
-// ----------------------------------
-
-bool ValueArray::Data::IsNull() const
-{
-	return this == &Single<ValueArray::NullData>();
-}
-
-void ValueArray::Data::Serialize(Stream& s)
-{
-	s % data;
-}
-
-unsigned ValueArray::Data::GetHashValue() const
-{
-	CombineHash w(data.GetCount());
-	for(int i = 0; i < data.GetCount(); i++)
-		w.Put(data[i].GetHashValue());
-	return w;
-}
-
-static bool sCmp(const Vector<Value>& a, const Vector<Value>& b)
-{
-	if(&a == &b) return true;
-	if(a.GetCount() != b.GetCount()) return false;
-	for(int i = 0; i < a.GetCount(); i++)
-		if(a[i] != b[i]) return false;
-	return true;
-}
-
-bool ValueArray::Data::IsEqual(const Value::Void *p)
-{
-	return sCmp(((Data *)p)->data, data);
-}
-
-bool ValueArray::operator==(const ValueArray& v) const
-{
-	return sCmp(data->data, v.data->data);
-}
-
-static String sAsString(const Vector<Value>& v)
-{
-	String s;
-	s << "[";
-	for(int i = 0; i < v.GetCount(); i++) {
-		if(i) s << ", ";
-		s << v[i];
-	}
-	s << "]";
-	return s;
-}
-
-String ValueArray::Data::AsString() const
-{
-	return sAsString(data);
-}
-
-Vector<Value>& ValueArray::Create()
-{
-	data = new Data;
-	return data->data;
-}
-
-Vector<Value>& ValueArray::Clone() {
-	if(data->GetRefCount() != 1) {
-		Data *d = new Data;
-		d->data <<= data->data;
-		data->Release();
-		data = d;
-	}
-	return data->data;
-}
-
-void ValueArray::Init0()
-{
-	data = &Single<NullData>();
-	data->Retain();
-}
-
-ValueArray::ValueArray(const ValueArray& v) {
-	data = v.data;
-	data->Retain();
-}
-
-ValueArray::ValueArray(pick_ Vector<Value>& v)
-{
-	Create() = v;
-}
-
-ValueArray::ValueArray(const Vector<Value>& v, int deep)
-{
-	Create() <<= v;
-}
-
-ValueArray::operator Value() const {
-	data->Retain();
-	return Value(data);
-}
-
-ValueArray::ValueArray(const Value& src)
-{
-	if(!UPP::IsNull(src)) {
-		if(IsType<ValueMap>(src)) {
-			ValueArray v = ValueMap(src);
-			data = v.data;
-			data->Retain();
-			return;
-		}
-		else {
-			ASSERT(dynamic_cast<const ValueArray::Data *>(src.GetVoidPtr()));
-			data = (ValueArray::Data *)src.GetVoidPtr();
-		}
-	}
-	else
-		data = &Single<NullData>();
-	data->Retain();
-}
-
-void ValueArray::Serialize(Stream& s) {
-	if(s.IsLoading()) {
-		data->Release();
-		Create();
-	}
-	data->Serialize(s);
-}
-
-ValueArray::~ValueArray() {
-	ASSERT(data->GetRefCount() > 0);
-	data->Release();
-}
-
-ValueArray& ValueArray::operator=(const ValueArray& v) {
-	v.data->Retain();
-	data->Release();
-	data = v.data;
-	return *this;
-}
-
-void ValueArray::SetCount(int n) {
-	Clone().SetCount(n);
-}
-
-void ValueArray::SetCount(int n, const Value& v)
-{
-	Clone().SetCount(n, v);
-}
-
-void ValueArray::Clear() {
-	Clone().Clear();
-}
-
-void ValueArray::Add(const Value& v) {
-	Clone().Add(v);
-}
-
-void ValueArray::Set(int i, const Value& v) {
-	ASSERT(i >= 0);
-	Clone().At(i) = v;
-}
-
-void ValueArray::Remove(int i, int count)
-{
-	Clone().Remove(i, count);
-}
-
-void ValueArray::Insert(int i, const ValueArray& va)
-{
-	if(va.data == data) {
-		ValueArray va2 = va;
-		Clone().Insert(i, va2.Get());
-	}
-	else
-		Clone().Insert(i, va.Get());
-}
-
-const Value& ValueArray::Get(int i) const {
-	ASSERT(i >= 0 && i < GetCount());
-	return data->data[i];
-}
-
-template<>
-String AsString(const ValueArray& v) {
-	return sAsString(v.Get());
-}
-
-bool ValueMap::Data::IsNull() const {
-	return this == &Single<ValueMap::NullData>();
-}
-
-void ValueMap::Data::Serialize(Stream& s) {
-	s % key % value;
-}
-
-unsigned ValueMap::Data::GetHashValue() const {
-	CombineHash w(key.GetCount());
-	for(int i = 0; i < key.GetCount(); i++)
-		w.Put(key[i].GetHashValue());
-	w.Put(value.GetHashValue());
-	return w;
-}
-
-static bool sIsEqual(const Index<Value>& a, const Index<Value>& b) {
-	if(&a == &b) return true;
-	if(a.GetCount() != b.GetCount()) return false;
-	for(int i = 0; i < a.GetCount(); i++) {
-		if(a[i] != b[i]) return false;
-	}
-	return true;
-}
-
-bool ValueMap::Data::IsEqual(const Value::Void *p) {
-	return sIsEqual(((Data *)p)->key, key) && ((Data *)p)->value == value;
-}
-
-bool ValueMap::operator==(const ValueMap& v) const {
-	return sIsEqual(data->key, v.data->key) && data->value == v.data->value;
-}
-
-String ValueMap::Data::AsString() const
-{
-	String s;
-	s << "{ ";
-	for(int i = 0; i < key.GetCount(); i++) {
-		if(i) s << ", ";
-		s << key[i] << ": " << value[i];
-	}
-	s << " }";
-	return s;
-}
-
-ValueMap::Data& ValueMap::Create()
-{
-	data = new Data;
-	return *data;
-}
-
-ValueMap::Data& ValueMap::Clone() {
-	if(data->GetRefCount() != 1) {
-		Data *d = new Data;
-		d->key <<= data->key;
-		d->value = data->value;
-		data->Release();
-		data = d;
-	}
-	return *data;
-}
-
-void ValueMap::Init0()
-{
-	data = &Single<NullData>();
-	data->Retain();
-}
-
-ValueMap::ValueMap(const ValueMap& v)
-{
-	data = v.data;
-	data->Retain();
-}
-
-ValueMap::ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v)
-{
-	Data& d = Create();
-	d.key = k;
-	d.value = ValueArray(v);
-}
-
-ValueMap::ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep)
-{
-	Data& d = Create();
-	d.key <<= k;
-	Vector<Value> _v(v, 0);
-	d.value = ValueArray(_v);
-}
-
-ValueMap::operator Value() const {
-	data->Retain();
-	return Value(data);
-}
-
-ValueMap::ValueMap(const Value& src)
-{
-	if(!IsNull(src)) {
-		if(IsType<ValueArray>(src)) {
-			ValueArray va = src;
-			Init0();
-			for(int i = 0; i < va.GetCount(); i++)
-				Add(i, va[i]);
-			return;
-		}
-		else {
-			ASSERT(dynamic_cast<const ValueMap::Data *>(src.GetVoidPtr()));
-			data = (ValueMap::Data *)src.GetVoidPtr();
-		}
-	}
-	else
-		data = &Single<NullData>();
-	data->Retain();
-}
-
-void ValueMap::Serialize(Stream& s) {
-	if(s.IsLoading()) {
-		data->Release();
-		Create();
-	}
-	data->Serialize(s);
-}
-
-ValueMap::~ValueMap() {
-	ASSERT(data->GetRefCount() > 0);
-	data->Release();
-}
-
-ValueMap& ValueMap::operator=(const ValueMap& v) {
-	v.data->Retain();
-	data->Release();
-	data = v.data;
-	return *this;
-}
-
-void ValueMap::Clear() {
-	data->Release();
-	Init0();
-}
-
-void ValueMap::Add(const Value& key, const Value& value) {
-	Data& d = Clone();
-	d.key.Add(key);
-	d.value.Add(value);
-}
-
-void ValueMap::Set(const Value& key, const Value& value)
-{
-	Data& d = Clone();
-	int i = d.key.Find(key);
-	if(i >= 0)
-		d.value.Set(i, value);
-	else {
-		d.key.Add(key);
-		d.value.Add(value);
-	}
-}
-
-void ValueMap::SetAt(int i, const Value& v) {
-	Clone().value.Set(i, v);
-}
-
-void ValueMap::SetKey(int i, const Value& k) {
-	Clone().key.Set(i, k);
-}
-
-void ValueMap::Remove(int i)
-{
-	Data& d = Clone();
-	d.key.Remove(i);
-	d.value.Remove(i);
-}
-
-const Value& ValueMap::operator[](const Value& key) const
-{
-	int q = data->key.Find(key);
-	return q >= 0 ? data->value[q] : ErrorValue();
-}
-
-// ----------------------------------
-
-int StdValueCompare(const Value& a, const Value& b, int language)
-{
-	LTIMING("StdValueCompare");
-
-	bool na = IsNull(a), nb = IsNull(b);
-	if(na || nb)
-		return !na ? 1 : !nb ? -1 : 0;
-	dword ta = a.GetType(), tb = b.GetType();
-	if((ta == INT_V || ta == BOOL_V) && (tb == INT_V || tb == BOOL_V))
-		return cmp<int>(a, b);
-	if((ta == BOOL_V || ta == INT_V || ta == INT64_V || ta == DOUBLE_V)
-	&& (tb == BOOL_V || tb == INT_V || tb == INT64_V || tb == DOUBLE_V))
-		return cmp<double>(a, b);
-	if(ta == DATE_V && tb == DATE_V)
-		return cmp<Date>(a, b);
-	if((ta == DATE_V || ta == TIME_V) && (tb == DATE_V || tb == TIME_V))
-		return cmp<Time>(a, b);
-	if((ta == STRING_V || ta == WSTRING_V) && (tb == STRING_V || tb == WSTRING_V))
-		return GetLanguageInfo(language).Compare(WString(a), WString(b));
-	return cmp<int>(ta, tb);
-}
-
-int StdValueCompare(const Value& a, const Value& b)
-{
-	return StdValueCompare(a, b, GetCurrentLanguage());
-}
-
-int StdValueCompareDesc(const Value& a, const Value& b, int language)
-{
-	return -StdValueCompare(a, b, language);
-}
-
-int StdValueCompareDesc(const Value& a, const Value& b)
-{
-	return -StdValueCompare(a, b);
-}
-
-StdValueOrder::StdValueOrder(int l) : language(l) {}
-
-bool StdValueOrder::operator()(const Value& a, const Value& b) const
-{
-	return StdValueCompare(a, b, language) < 0;
-}
-
-bool FnValueOrder::operator()(const Value& a, const Value& b) const
-{
-	return (*fn)(a, b) < 0;
-}
-
-bool StdValuePairOrder::operator()(const Value& k1, const Value& v1, const Value& k2, const Value& v2) const
-{
-	int q = StdValueCompare(k1, k2, language);
-	if(q) return q < 0;
-	return StdValueCompare(v1, v2, language);
-}
-
-bool FnValuePairOrder::operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const
-{
-	return (*fn)(keya, valuea, keyb, valueb) < 0;
-}
-
-END_UPP_NAMESPACE
-
-#endif
-
+#include "Core.h"
+
+#ifndef  SVO_VALUE
+
+NAMESPACE_UPP
+
+#ifndef flagSO
+const Nuller Null;
+#endif
+
+#define LTIMING(x) // RTIMING(x)
+
+unsigned Value::GetHashValue() const {
+	return IsNull() ? 0 : ptr->GetHashValue();
+}
+
+Value& Value::operator=(const Value& v) {
+	if(this == &v) return *this;
+	ptr->Release();
+	ptr = v.ptr;
+	ptr->Retain();
+	return *this;
+}
+
+Value::Value(const Value& v) {
+	ptr = v.ptr;
+	ptr->Retain();
+}
+
+void Value::SetVoidVal()
+{
+	ptr = &Single<Void>();
+	ptr->Retain();
+}
+
+Value::Value() {
+	SetVoidVal();
+}
+
+Value::~Value() {
+	ptr->Release();
+}
+
+bool Value::operator==(const Value& v) const {
+	if(ptr == v.ptr) return true;
+	bool an = IsNull();
+	bool bn = v.IsNull();
+	if(an || bn) return an && bn;
+	if(GetType() == v.GetType())
+		return ptr->IsEqual(v.ptr);
+	return ptr->IsPolyEqual(v) || v.ptr->IsPolyEqual(*this);
+}
+
+Value::Value(const String& s)  { ptr = new RichValueRep<String>(s); }
+Value::Value(const WString& s) { ptr = new RichValueRep<WString>(s); }
+Value::Value(const char *s)    { ptr = new RichValueRep<String>(s); }
+Value::Value(int i)            { ptr = new RichValueRep<int>(i); }
+Value::Value(int64 i)          { ptr = new RichValueRep<int64>(i); }
+Value::Value(double d)         { ptr = new RichValueRep<double>(d); }
+Value::Value(bool b)           { ptr = new RichValueRep<bool>(b); }
+Value::Value(Date d)           { ptr = new RichValueRep<Date>(d); }
+Value::Value(Time t)           { ptr = new RichValueRep<Time>(t); }
+Value::Value(const Nuller&)    { ptr = new RichValueRep<int>(Null); }
+
+Value::operator String() const
+{
+	if(IsNull()) return Null;
+	return GetType() == WSTRING_V ? RichValue<WString>::Extract(*this).ToString()
+		                          : RichValue<String>::Extract(*this);
+}
+
+Value::operator WString() const
+{
+	if(IsNull()) return Null;
+	return GetType() == WSTRING_V ? RichValue<WString>::Extract(*this)
+		                          : RichValue<String>::Extract(*this).ToWString();
+}
+
+Value::operator Date() const
+{
+	if(IsNull()) return Null;
+	return GetType() == DATE_V ? RichValue<Date>::Extract(*this)
+		                       : Date(RichValue<Time>::Extract(*this));
+}
+
+Value::operator Time() const
+{
+	if(IsNull()) return Null;
+	return GetType() == DATE_V ? ToTime(RichValue<Date>::Extract(*this))
+		                       : RichValue<Time>::Extract(*this);
+}
+
+Value::operator double() const
+{
+	if(IsNull()) return Null;
+	return GetType() == INT_V   ? double(RichValue<int>::Extract(*this))
+	     : GetType() == BOOL_V ? double(RichValue<bool>::Extract(*this))
+	     : GetType() == INT64_V ? double(RichValue<int64>::Extract(*this))
+		                        : RichValue<double>::Extract(*this);
+}
+
+Value::operator int() const
+{
+	if(IsNull()) return Null;
+	return GetType() == INT_V   ? RichValue<int>::Extract(*this)
+	     : GetType() == BOOL_V ? int(RichValue<bool>::Extract(*this))
+	     : GetType() == INT64_V ? int(RichValue<int64>::Extract(*this))
+		                        : int(RichValue<double>::Extract(*this));
+}
+
+Value::operator int64() const
+{
+	if(IsNull()) return Null;
+	return GetType() == INT_V   ? int64(RichValue<int>::Extract(*this))
+	     : GetType() == BOOL_V ? int64(RichValue<bool>::Extract(*this))
+	     : GetType() == INT64_V ? RichValue<int64>::Extract(*this)
+		                        : int64(RichValue<double>::Extract(*this));
+}
+
+Value::operator bool() const
+{
+	if(IsNull()) return false;
+	return operator int();
+}
+
+VectorMap<dword, Value::Void *(*)(Stream& s)>& Value::Typemap()
+{
+	static VectorMap<dword, Value::Void *(*)(Stream& s)> x;
+	return x;
+}
+
+Value::Void *ValueArrayDataCreate(Stream& s)
+{
+	ValueArray::Data *a = new ValueArray::Data;
+	a->Serialize(s);
+	return a;
+}
+
+Value::Void *ValueMapDataCreate(Stream& s)
+{
+	ValueMap::Data *a = new ValueMap::Data;
+	a->Serialize(s);
+	return a;
+}
+
+static void sRegisterStd()
+{
+	ONCELOCK {
+		RichValue<int>::Register();
+		RichValue<int64>::Register();
+		RichValue<bool>::Register();
+		RichValue<double>::Register();
+		RichValue<String>::Register();
+		RichValue<WString>::Register();
+		RichValue<Date>::Register();
+		RichValue<Time>::Register();
+		RichValue<Complex>::Register();
+		Value::Register(VALUEARRAY_V, ValueArrayDataCreate);
+		Value::Register(VALUEMAP_V, ValueMapDataCreate);
+	};
+}
+
+INITBLOCK {
+	sRegisterStd();
+}
+
+void Value::Serialize(Stream& s) {
+	sRegisterStd();
+	dword type;
+	if(s.IsLoading()) {
+		s / type;
+		ptr->Release();
+		typedef Void* (*vp)(Stream& s);
+		vp *cr = Typemap().FindPtr(type);
+		if(cr)
+			ptr = (**cr)(s);
+		else {
+			SetVoidVal();
+			if(type != VOID_V && type != ERROR_V)
+				s.LoadError();
+		}
+	}
+	else {
+		type = GetType();
+		ASSERT_(!type || type == ERROR_V || type == UNKNOWN_V || Typemap().Find(type) >= 0, "Missing RichValueType<" + AsString(type) + ">::Register");
+		s / type;
+		ptr->Serialize(s);
+	}
+}
+
+void Value::Register(dword w, Void* (*c)(Stream& s)) init_ {
+#ifdef flagCHECKINIT
+	RLOG("Register valuetype " << w);
+#endif
+	AssertST();
+	ASSERT(w != UNKNOWN_V);
+	ASSERT(w < 0x8000000);
+	CHECK(Typemap().GetAdd(w, c) == c);
+}
+
+String  Value::ToString() const {
+	return ptr->AsString();
+}
+
+class ValueErrorCls : public RichValueRep<String> {
+public:
+	virtual dword      GetType() const             { return ERROR_V; }
+	virtual bool       IsNull() const              { return true; }
+	virtual void       Serialize(Stream& s)        {}
+	virtual String     AsString() const            { return "<error: \'" + v + "\'>"; }
+
+	ValueErrorCls(const String& s) : RichValueRep<String>(s)  {}
+};
+
+Value ErrorValue(const String& s) {
+	return Value(new ValueErrorCls(s));
+}
+
+Value ErrorValue(const char *s) {
+	return ErrorValue(String(s));
+}
+
+const Value& ErrorValue() {
+	static Value *p;
+	ONCELOCK {
+		static Value v = ErrorValue(String());
+		p = &v;
+	}
+	return *p;
+}
+
+String GetErrorText(const Value& v) {
+	ASSERT(IsError(v));
+	return ((RichValueRep<String> *)v.GetVoidPtr())->Get();
+}
+
+// ----------------------------------
+
+struct Ref::ValueRef : public RefManager {
+	virtual int   GetType()                            { return VALUE_V; }
+	virtual Value GetValue(const void *ptr)            { return *(Value *) ptr; }
+	virtual bool  IsNull(const void *ptr)              { return UPP::IsNull(*(Value *) ptr); }
+	virtual void  SetValue(void *ptr, const Value& v)  { *(Value *) ptr = v; }
+	virtual void  SetNull(void *ptr)                   { *(Value *) ptr = Null; }
+};
+
+Ref::Ref(String& s)  { ptr = &s; m = &Single< RichRef<String> >(); }
+Ref::Ref(WString& s) { ptr = &s; m = &Single< RichRef<WString> >(); }
+Ref::Ref(int& i)     { ptr = &i; m = &Single< RichRef<int> >(); }
+Ref::Ref(int64& i)   { ptr = &i; m = &Single< RichRef<int64> >(); }
+Ref::Ref(double& d)  { ptr = &d; m = &Single< RichRef<double> >(); }
+Ref::Ref(bool& b)    { ptr = &b; m = &Single< RichRef<bool> >(); }
+Ref::Ref(Date& d)    { ptr = &d; m = &Single< RichRef<Date> >(); }
+Ref::Ref(Time& t)    { ptr = &t; m = &Single< RichRef<Time> >(); }
+Ref::Ref(Value& v)   { ptr = &v; m = &Single< ValueRef >(); }
+
+// ----------------------------------
+
+bool ValueArray::Data::IsNull() const
+{
+	return this == &Single<ValueArray::NullData>();
+}
+
+void ValueArray::Data::Serialize(Stream& s)
+{
+	s % data;
+}
+
+unsigned ValueArray::Data::GetHashValue() const
+{
+	CombineHash w(data.GetCount());
+	for(int i = 0; i < data.GetCount(); i++)
+		w.Put(data[i].GetHashValue());
+	return w;
+}
+
+static bool sCmp(const Vector<Value>& a, const Vector<Value>& b)
+{
+	if(&a == &b) return true;
+	if(a.GetCount() != b.GetCount()) return false;
+	for(int i = 0; i < a.GetCount(); i++)
+		if(a[i] != b[i]) return false;
+	return true;
+}
+
+bool ValueArray::Data::IsEqual(const Value::Void *p)
+{
+	return sCmp(((Data *)p)->data, data);
+}
+
+bool ValueArray::operator==(const ValueArray& v) const
+{
+	return sCmp(data->data, v.data->data);
+}
+
+static String sAsString(const Vector<Value>& v)
+{
+	String s;
+	s << "[";
+	for(int i = 0; i < v.GetCount(); i++) {
+		if(i) s << ", ";
+		s << v[i];
+	}
+	s << "]";
+	return s;
+}
+
+String ValueArray::Data::AsString() const
+{
+	return sAsString(data);
+}
+
+Vector<Value>& ValueArray::Create()
+{
+	data = new Data;
+	return data->data;
+}
+
+Vector<Value>& ValueArray::Clone() {
+	if(data->GetRefCount() != 1) {
+		Data *d = new Data;
+		d->data <<= data->data;
+		data->Release();
+		data = d;
+	}
+	return data->data;
+}
+
+void ValueArray::Init0()
+{
+	data = &Single<NullData>();
+	data->Retain();
+}
+
+ValueArray::ValueArray(const ValueArray& v) {
+	data = v.data;
+	data->Retain();
+}
+
+ValueArray::ValueArray(pick_ Vector<Value>& v)
+{
+	Create() = v;
+}
+
+ValueArray::ValueArray(const Vector<Value>& v, int deep)
+{
+	Create() <<= v;
+}
+
+ValueArray::operator Value() const {
+	data->Retain();
+	return Value(data);
+}
+
+ValueArray::ValueArray(const Value& src)
+{
+	if(!UPP::IsNull(src)) {
+		if(IsType<ValueMap>(src)) {
+			ValueArray v = ValueMap(src);
+			data = v.data;
+			data->Retain();
+			return;
+		}
+		else {
+			ASSERT(dynamic_cast<const ValueArray::Data *>(src.GetVoidPtr()));
+			data = (ValueArray::Data *)src.GetVoidPtr();
+		}
+	}
+	else
+		data = &Single<NullData>();
+	data->Retain();
+}
+
+void ValueArray::Serialize(Stream& s) {
+	if(s.IsLoading()) {
+		data->Release();
+		Create();
+	}
+	data->Serialize(s);
+}
+
+ValueArray::~ValueArray() {
+	ASSERT(data->GetRefCount() > 0);
+	data->Release();
+}
+
+ValueArray& ValueArray::operator=(const ValueArray& v) {
+	v.data->Retain();
+	data->Release();
+	data = v.data;
+	return *this;
+}
+
+void ValueArray::SetCount(int n) {
+	Clone().SetCount(n);
+}
+
+void ValueArray::SetCount(int n, const Value& v)
+{
+	Clone().SetCount(n, v);
+}
+
+void ValueArray::Clear() {
+	Clone().Clear();
+}
+
+void ValueArray::Add(const Value& v) {
+	Clone().Add(v);
+}
+
+void ValueArray::Set(int i, const Value& v) {
+	ASSERT(i >= 0);
+	Clone().At(i) = v;
+}
+
+void ValueArray::Remove(int i, int count)
+{
+	Clone().Remove(i, count);
+}
+
+void ValueArray::Insert(int i, const ValueArray& va)
+{
+	if(va.data == data) {
+		ValueArray va2 = va;
+		Clone().Insert(i, va2.Get());
+	}
+	else
+		Clone().Insert(i, va.Get());
+}
+
+const Value& ValueArray::Get(int i) const {
+	ASSERT(i >= 0 && i < GetCount());
+	return data->data[i];
+}
+
+String ValueArray::ToString() const
+{
+	return sAsString(Get());
+}
+
+bool ValueMap::Data::IsNull() const {
+	return this == &Single<ValueMap::NullData>();
+}
+
+void ValueMap::Data::Serialize(Stream& s) {
+	s % key % value;
+}
+
+unsigned ValueMap::Data::GetHashValue() const {
+	CombineHash w(key.GetCount());
+	for(int i = 0; i < key.GetCount(); i++)
+		w.Put(key[i].GetHashValue());
+	w.Put(value.GetHashValue());
+	return w;
+}
+
+static bool sIsEqual(const Index<Value>& a, const Index<Value>& b) {
+	if(&a == &b) return true;
+	if(a.GetCount() != b.GetCount()) return false;
+	for(int i = 0; i < a.GetCount(); i++) {
+		if(a[i] != b[i]) return false;
+	}
+	return true;
+}
+
+bool ValueMap::Data::IsEqual(const Value::Void *p) {
+	return sIsEqual(((Data *)p)->key, key) && ((Data *)p)->value == value;
+}
+
+bool ValueMap::operator==(const ValueMap& v) const {
+	return sIsEqual(data->key, v.data->key) && data->value == v.data->value;
+}
+
+String ValueMap::Data::AsString() const
+{
+	String s;
+	s << "{ ";
+	for(int i = 0; i < key.GetCount(); i++) {
+		if(i) s << ", ";
+		s << key[i] << ": " << value[i];
+	}
+	s << " }";
+	return s;
+}
+
+ValueMap::Data& ValueMap::Create()
+{
+	data = new Data;
+	return *data;
+}
+
+ValueMap::Data& ValueMap::Clone() {
+	if(data->GetRefCount() != 1) {
+		Data *d = new Data;
+		d->key <<= data->key;
+		d->value = data->value;
+		data->Release();
+		data = d;
+	}
+	return *data;
+}
+
+void ValueMap::Init0()
+{
+	data = &Single<NullData>();
+	data->Retain();
+}
+
+ValueMap::ValueMap(const ValueMap& v)
+{
+	data = v.data;
+	data->Retain();
+}
+
+ValueMap::ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v)
+{
+	Data& d = Create();
+	d.key = k;
+	d.value = ValueArray(v);
+}
+
+ValueMap::ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep)
+{
+	Data& d = Create();
+	d.key <<= k;
+	Vector<Value> _v(v, 0);
+	d.value = ValueArray(_v);
+}
+
+ValueMap::operator Value() const {
+	data->Retain();
+	return Value(data);
+}
+
+ValueMap::ValueMap(const Value& src)
+{
+	if(!IsNull(src)) {
+		if(IsType<ValueArray>(src)) {
+			ValueArray va = src;
+			Init0();
+			for(int i = 0; i < va.GetCount(); i++)
+				Add(i, va[i]);
+			return;
+		}
+		else {
+			ASSERT(dynamic_cast<const ValueMap::Data *>(src.GetVoidPtr()));
+			data = (ValueMap::Data *)src.GetVoidPtr();
+		}
+	}
+	else
+		data = &Single<NullData>();
+	data->Retain();
+}
+
+void ValueMap::Serialize(Stream& s) {
+	if(s.IsLoading()) {
+		data->Release();
+		Create();
+	}
+	data->Serialize(s);
+}
+
+ValueMap::~ValueMap() {
+	ASSERT(data->GetRefCount() > 0);
+	data->Release();
+}
+
+ValueMap& ValueMap::operator=(const ValueMap& v) {
+	v.data->Retain();
+	data->Release();
+	data = v.data;
+	return *this;
+}
+
+void ValueMap::Clear() {
+	data->Release();
+	Init0();
+}
+
+void ValueMap::Add(const Value& key, const Value& value) {
+	Data& d = Clone();
+	d.key.Add(key);
+	d.value.Add(value);
+}
+
+void ValueMap::Set(const Value& key, const Value& value)
+{
+	Data& d = Clone();
+	int i = d.key.Find(key);
+	if(i >= 0)
+		d.value.Set(i, value);
+	else {
+		d.key.Add(key);
+		d.value.Add(value);
+	}
+}
+
+void ValueMap::SetAt(int i, const Value& v) {
+	Clone().value.Set(i, v);
+}
+
+void ValueMap::SetKey(int i, const Value& k) {
+	Clone().key.Set(i, k);
+}
+
+void ValueMap::Remove(int i)
+{
+	Data& d = Clone();
+	d.key.Remove(i);
+	d.value.Remove(i);
+}
+
+const Value& ValueMap::operator[](const Value& key) const
+{
+	int q = data->key.Find(key);
+	return q >= 0 ? data->value[q] : ErrorValue();
+}
+
+// ----------------------------------
+
+int StdValueCompare(const Value& a, const Value& b, int language)
+{
+	LTIMING("StdValueCompare");
+
+	bool na = IsNull(a), nb = IsNull(b);
+	if(na || nb)
+		return !na ? 1 : !nb ? -1 : 0;
+	dword ta = a.GetType(), tb = b.GetType();
+	if((ta == INT_V || ta == BOOL_V) && (tb == INT_V || tb == BOOL_V))
+		return cmp<int>(a, b);
+	if((ta == BOOL_V || ta == INT_V || ta == INT64_V || ta == DOUBLE_V)
+	&& (tb == BOOL_V || tb == INT_V || tb == INT64_V || tb == DOUBLE_V))
+		return cmp<double>(a, b);
+	if(ta == DATE_V && tb == DATE_V)
+		return cmp<Date>(a, b);
+	if((ta == DATE_V || ta == TIME_V) && (tb == DATE_V || tb == TIME_V))
+		return cmp<Time>(a, b);
+	if((ta == STRING_V || ta == WSTRING_V) && (tb == STRING_V || tb == WSTRING_V))
+		return GetLanguageInfo(language).Compare(WString(a), WString(b));
+	return cmp<int>(ta, tb);
+}
+
+int StdValueCompare(const Value& a, const Value& b)
+{
+	return StdValueCompare(a, b, GetCurrentLanguage());
+}
+
+int StdValueCompareDesc(const Value& a, const Value& b, int language)
+{
+	return -StdValueCompare(a, b, language);
+}
+
+int StdValueCompareDesc(const Value& a, const Value& b)
+{
+	return -StdValueCompare(a, b);
+}
+
+StdValueOrder::StdValueOrder(int l) : language(l) {}
+
+bool StdValueOrder::operator()(const Value& a, const Value& b) const
+{
+	return StdValueCompare(a, b, language) < 0;
+}
+
+bool FnValueOrder::operator()(const Value& a, const Value& b) const
+{
+	return (*fn)(a, b) < 0;
+}
+
+bool StdValuePairOrder::operator()(const Value& k1, const Value& v1, const Value& k2, const Value& v2) const
+{
+	int q = StdValueCompare(k1, k2, language);
+	if(q) return q < 0;
+	return StdValueCompare(v1, v2, language);
+}
+
+bool FnValuePairOrder::operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const
+{
+	return (*fn)(keya, valuea, keyb, valueb) < 0;
+}
+
+END_UPP_NAMESPACE
+
+#endif
+
diff --git a/uppsrc/Core/Value.cpp b/uppsrc/Core/Value.cpp
index 4ae9958aa..a9f2298f8 100644
--- a/uppsrc/Core/Value.cpp
+++ b/uppsrc/Core/Value.cpp
@@ -32,7 +32,7 @@ void Value::RefRetain()
 
 Value& Value::operator=(const Value& v) {
 	if(this == &v) return *this;
-	Free();
+	FreeRef();
 	data = v.data;
 	if(IsRef())
 		ptr()->Retain();
diff --git a/uppsrc/Core/Value.h b/uppsrc/Core/Value.h
index 16105087b..e6428bb47 100644
--- a/uppsrc/Core/Value.h
+++ b/uppsrc/Core/Value.h
@@ -137,7 +137,8 @@ protected:
 	void     InitRef(Void *p)        { data.SetSpecial(REF); ptr() = p; }
 	void     RefRelease();
 	void     RefRetain();
-	void     Free()                  { if(IsRef()) RefRelease(); }
+	void     FreeRef()               { if(IsRef()) RefRelease(); }
+	void     Free()                  { FreeRef(); data.Clear(); }
 	void     SetLarge(const Value& v);
 
 	template <class T>
diff --git a/uppsrc/Core/ValueUtil.cpp b/uppsrc/Core/ValueUtil.cpp
index 587ddae49..d010b2abf 100644
--- a/uppsrc/Core/ValueUtil.cpp
+++ b/uppsrc/Core/ValueUtil.cpp
@@ -1,599 +1,599 @@
-#include "Core.h"
-
-NAMESPACE_UPP
-
-#ifdef SVO_VALUE
-
-#define LTIMING(x) // RTIMING(x)
-
-struct Ref::ValueRef : public RefManager {
-	virtual int   GetType()                            { return VALUE_V; }
-	virtual Value GetValue(const void *ptr)            { return *(Value *) ptr; }
-	virtual bool  IsNull(const void *ptr)              { return UPP::IsNull(*(Value *) ptr); }
-	virtual void  SetValue(void *ptr, const Value& v)  { *(Value *) ptr = v; }
-	virtual void  SetNull(void *ptr)                   { *(Value *) ptr = Null; }
-};
-
-Ref::Ref(String& s)  { ptr = &s; m = &Single< StdRef<String> >(); }
-Ref::Ref(WString& s) { ptr = &s; m = &Single< StdRef<WString> >(); }
-Ref::Ref(int& i)     { ptr = &i; m = &Single< StdRef<int> >(); }
-Ref::Ref(int64& i)   { ptr = &i; m = &Single< StdRef<int64> >(); }
-Ref::Ref(double& d)  { ptr = &d; m = &Single< StdRef<double> >(); }
-Ref::Ref(bool& b)    { ptr = &b; m = &Single< StdRef<bool> >(); }
-Ref::Ref(Date& d)    { ptr = &d; m = &Single< StdRef<Date> >(); }
-Ref::Ref(Time& t)    { ptr = &t; m = &Single< StdRef<Time> >(); }
-Ref::Ref(Value& v)   { ptr = &v; m = &Single< ValueRef >(); }
-
-// ----------------------------------
-
-bool ValueArray::Data::IsNull() const
-{
-	return this == &Single<ValueArray::NullData>();
-}
-
-void ValueArray::Data::Serialize(Stream& s)
-{
-	s % data;
-}
-
-void ValueArray::Data::Jsonize(JsonIO& jio)
-{
-	Upp::Jsonize(jio, data);
-}
-
-void ValueArray::Data::Xmlize(XmlIO& io)
-{
-	Upp::Xmlize(io, data);
-}
-
-unsigned ValueArray::Data::GetHashValue() const
-{
-	CombineHash w(data.GetCount());
-	for(int i = 0; i < data.GetCount(); i++)
-		w.Put(data[i].GetHashValue());
-	return w;
-}
-
-static bool sCmp(const Vector<Value>& a, const Vector<Value>& b)
-{
-	if(&a == &b) return true;
-	if(a.GetCount() != b.GetCount()) return false;
-	for(int i = 0; i < a.GetCount(); i++)
-		if(a[i] != b[i]) return false;
-	return true;
-}
-
-bool ValueArray::Data::IsEqual(const Value::Void *p)
-{
-	return sCmp(((Data *)p)->data, data);
-}
-
-bool ValueArray::operator==(const ValueArray& v) const
-{
-	return sCmp(data->data, v.data->data);
-}
-
-static String sAsString(const Vector<Value>& v)
-{
-	String s;
-	s << "[";
-	for(int i = 0; i < v.GetCount(); i++) {
-		if(i) s << ", ";
-		s << v[i];
-	}
-	s << "]";
-	return s;
-}
-
-String ValueArray::Data::AsString() const
-{
-	return sAsString(data);
-}
-
-Vector<Value>& ValueArray::Create()
-{
-	data = new Data;
-	return data->data;
-}
-
-Vector<Value>& ValueArray::Clone() {
-	if(data->GetRefCount() != 1) {
-		Data *d = new Data;
-		d->data <<= data->data;
-		data->Release();
-		data = d;
-	}
-	return data->data;
-}
-
-void ValueArray::Init0()
-{
-	data = &Single<NullData>();
-	data->Retain();
-}
-
-ValueArray::ValueArray(const ValueArray& v) {
-	data = v.data;
-	data->Retain();
-}
-
-ValueArray::ValueArray(pick_ Vector<Value>& v)
-{
-	Create() = v;
-}
-
-ValueArray::ValueArray(const Vector<Value>& v, int deep)
-{
-	Create() <<= v;
-}
-
-ValueArray::operator Value() const {
-	data->Retain();
-	return Value(data);
-}
-
-ValueArray::ValueArray(const Value& src)
-{
-	if(!UPP::IsNull(src)) {
-		if(IsType<ValueMap>(src)) {
-			ValueArray v = ValueMap(src);
-			data = v.data;
-			data->Retain();
-			return;
-		}
-		else {
-			ASSERT(dynamic_cast<const ValueArray::Data *>(src.GetVoidPtr()));
-			data = (ValueArray::Data *)src.GetVoidPtr();
-		}
-	}
-	else
-		data = &Single<NullData>();
-	data->Retain();
-}
-
-void ValueArray::Serialize(Stream& s) {
-	if(s.IsLoading()) {
-		data->Release();
-		Create();
-	}
-	data->Serialize(s);
-}
-
-void ValueArray::Jsonize(JsonIO& jio)
-{
-	if(jio.IsLoading()) {
-		data->Release();
-		Create();
-	}
-	data->Jsonize(jio);
-}
-
-ValueArray::~ValueArray() {
-	ASSERT(data->GetRefCount() > 0);
-	data->Release();
-}
-
-ValueArray& ValueArray::operator=(const ValueArray& v) {
-	v.data->Retain();
-	data->Release();
-	data = v.data;
-	return *this;
-}
-
-void ValueArray::SetCount(int n) {
-	Clone().SetCount(n);
-}
-
-void ValueArray::SetCount(int n, const Value& v)
-{
-	Clone().SetCount(n, v);
-}
-
-void ValueArray::Clear() {
-	Clone().Clear();
-}
-
-void ValueArray::Add(const Value& v) {
-	Clone().Add(v);
-}
-
-void ValueArray::Set(int i, const Value& v) {
-	ASSERT(i >= 0);
-	Clone().At(i) = v;
-}
-
-void ValueArray::Remove(int i, int count)
-{
-	Clone().Remove(i, count);
-}
-
-void ValueArray::Insert(int i, const ValueArray& va)
-{
-	if(va.data == data) {
-		ValueArray va2 = va;
-		Clone().Insert(i, va2.Get());
-	}
-	else
-		Clone().Insert(i, va.Get());
-}
-
-const Value& ValueArray::Get(int i) const {
-	ASSERT(i >= 0 && i < GetCount());
-	return data->data[i];
-}
-
-Value ValueArray::GetAndClear(int i)
-{
-	ASSERT(i >= 0 && i < GetCount());
-	Vector<Value>& x = Clone();
-	Value v = x[i];
-	x[i] = Value();
-	return v;
-}
-
-template<>
-String AsString(const ValueArray& v) {
-	return sAsString(v.Get());
-}
-
-bool ValueMap::Data::IsNull() const {
-	return this == &Single<ValueMap::NullData>();
-}
-
-void ValueMap::Data::Serialize(Stream& s) {
-	s % key % value;
-}
-
-void ValueMap::Data::Xmlize(XmlIO& xio)
-{
-	Upp::Xmlize(xio, key);
-	Upp::Xmlize(xio, value);
-}
-
-void ValueMap::Data::Jsonize(JsonIO& jio)
-{
-	if(jio.IsStoring()) {
-		ValueArray va;
-		int n = min(value.GetCount(), key.GetCount());
-		for(int i = 0; i < n; i++) {
-			ValueMap m;
-			m.Add("key", StoreAsJsonValue(key[i]));
-			m.Add("value", StoreAsJsonValue(value[i]));
-			va.Add(m);
-		}
-		jio.Set(va);
-	}
-	else {
-		Value va = jio.Get();
-		key.Clear();
-		value.Clear();
-		for(int i = 0; i < va.GetCount(); i++) {
-			Value k, v;
-			LoadFromJsonValue(k, va[i]["key"]);
-			LoadFromJsonValue(v, va[i]["value"]);
-			key.Add(k);
-			value.Add(v);
-		}
-	}
-}
-
-unsigned ValueMap::Data::GetHashValue() const {
-	CombineHash w(key.GetCount());
-	for(int i = 0; i < key.GetCount(); i++)
-		w.Put(key[i].GetHashValue());
-	w.Put(value.GetHashValue());
-	return w;
-}
-
-static bool sIsEqual(const Index<Value>& a, const Index<Value>& b) {
-	if(&a == &b) return true;
-	if(a.GetCount() != b.GetCount()) return false;
-	for(int i = 0; i < a.GetCount(); i++) {
-		if(a[i] != b[i]) return false;
-	}
-	return true;
-}
-
-bool ValueMap::Data::IsEqual(const Value::Void *p) {
-	return sIsEqual(((Data *)p)->key, key) && ((Data *)p)->value == value;
-}
-
-bool ValueMap::operator==(const ValueMap& v) const {
-	return sIsEqual(data->key, v.data->key) && data->value == v.data->value;
-}
-
-String ValueMap::Data::AsString() const
-{
-	String s;
-	s << "{ ";
-	for(int i = 0; i < key.GetCount(); i++) {
-		if(i) s << ", ";
-		s << key[i] << ": " << value[i];
-	}
-	s << " }";
-	return s;
-}
-
-ValueMap::Data& ValueMap::Create()
-{
-	data = new Data;
-	return *data;
-}
-
-const Value& ValueMap::Data::Get(const Value& k) const
-{
-	int q = key.Find(k);
-	return q >= 0 ? value[q] : ErrorValue();
-}
-
-ValueMap::Data& ValueMap::Clone() {
-	if(data->GetRefCount() != 1) {
-		Data *d = new Data;
-		d->key <<= data->key;
-		d->value = data->value;
-		data->Release();
-		data = d;
-	}
-	return *data;
-}
-
-void ValueMap::Init0()
-{
-	data = &Single<NullData>();
-	data->Retain();
-}
-
-ValueMap::ValueMap(const ValueMap& v)
-{
-	data = v.data;
-	data->Retain();
-}
-
-ValueMap::ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v)
-{
-	Data& d = Create();
-	d.key = k;
-	d.value = ValueArray(v);
-}
-
-ValueMap::ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep)
-{
-	Data& d = Create();
-	d.key <<= k;
-	Vector<Value> _v(v, 0);
-	d.value = ValueArray(_v);
-}
-
-ValueMap::operator Value() const {
-	data->Retain();
-	return Value(data);
-}
-
-ValueMap::ValueMap(const Value& src)
-{
-	if(!IsNull(src)) {
-		if(IsType<ValueArray>(src)) {
-			ValueArray va = src;
-			Init0();
-			for(int i = 0; i < va.GetCount(); i++)
-				Add(i, va[i]);
-			return;
-		}
-		else {
-			ASSERT(dynamic_cast<const ValueMap::Data *>(src.GetVoidPtr()));
-			data = (ValueMap::Data *)src.GetVoidPtr();
-		}
-	}
-	else
-		data = &Single<NullData>();
-	data->Retain();
-}
-
-void ValueMap::Serialize(Stream& s) {
-	if(s.IsLoading()) {
-		data->Release();
-		Create();
-	}
-	data->Serialize(s);
-}
-
-void ValueMap::Jsonize(JsonIO& jio)
-{
-	if(jio.IsLoading()) {
-		data->Release();
-		Create();
-	}
-	data->Jsonize(jio);
-}
-
-
-ValueMap::~ValueMap() {
-	ASSERT(data->GetRefCount() > 0);
-	data->Release();
-}
-
-ValueMap& ValueMap::operator=(const ValueMap& v) {
-	v.data->Retain();
-	data->Release();
-	data = v.data;
-	return *this;
-}
-
-void ValueMap::Clear() {
-	data->Release();
-	Init0();
-}
-
-void ValueMap::Add(const Value& key, const Value& value) {
-	Data& d = Clone();
-	d.key.Add(key);
-	d.value.Add(value);
-}
-
-void ValueMap::Set(const Value& key, const Value& value)
-{
-	Data& d = Clone();
-	int i = d.key.Find(key);
-	if(i >= 0)
-		d.value.Set(i, value);
-	else {
-		d.key.Add(key);
-		d.value.Add(value);
-	}
-}
-
-void ValueMap::SetAt(int i, const Value& v) {
-	Clone().value.Set(i, v);
-}
-
-void ValueMap::SetKey(int i, const Value& k) {
-	Clone().key.Set(i, k);
-}
-
-void ValueMap::Remove(int i)
-{
-	Data& d = Clone();
-	d.key.Remove(i);
-	d.value.Remove(i);
-}
-
-const Value& ValueMap::operator[](const Value& key) const
-{
-	return data->Get(key);
-}
-
-Value ValueMap::GetAndClear(const Value& key)
-{
-	Data& d = Clone();
-	int q = d.key.Find(key);
-	return q < 0 ? ErrorValue() : d.value.GetAndClear(q);
-}
-
-// ----------------------------------
-
-int StdValueCompare(const Value& a, const Value& b, int language)
-{
-	LTIMING("StdValueCompare");
-
-	bool na = IsNull(a), nb = IsNull(b);
-	if(na || nb)
-		return !na ? 1 : !nb ? -1 : 0;
-	dword ta = a.GetType(), tb = b.GetType();
-	if((ta == INT_V || ta == BOOL_V) && (tb == INT_V || tb == BOOL_V))
-		return cmp<int>(a, b);
-	if((ta == BOOL_V || ta == INT_V || ta == INT64_V || ta == DOUBLE_V)
-	&& (tb == BOOL_V || tb == INT_V || tb == INT64_V || tb == DOUBLE_V))
-		return cmp<double>(a, b);
-	if(ta == DATE_V && tb == DATE_V)
-		return cmp<Date>(a, b);
-	if((ta == DATE_V || ta == TIME_V) && (tb == DATE_V || tb == TIME_V))
-		return cmp<Time>(a, b);
-	if((ta == STRING_V || ta == WSTRING_V) && (tb == STRING_V || tb == WSTRING_V))
-		return GetLanguageInfo(language).Compare(WString(a), WString(b));
-	return cmp<int>(ta, tb);
-}
-
-int StdValueCompare(const Value& a, const Value& b)
-{
-	return StdValueCompare(a, b, GetCurrentLanguage());
-}
-
-int StdValueCompareDesc(const Value& a, const Value& b, int language)
-{
-	return -StdValueCompare(a, b, language);
-}
-
-int StdValueCompareDesc(const Value& a, const Value& b)
-{
-	return -StdValueCompare(a, b);
-}
-
-StdValueOrder::StdValueOrder(int l) : language(l) {}
-
-bool StdValueOrder::operator()(const Value& a, const Value& b) const
-{
-	return StdValueCompare(a, b, language) < 0;
-}
-
-bool FnValueOrder::operator()(const Value& a, const Value& b) const
-{
-	return (*fn)(a, b) < 0;
-}
-
-bool StdValuePairOrder::operator()(const Value& k1, const Value& v1, const Value& k2, const Value& v2) const
-{
-	int q = StdValueCompare(k1, k2, language);
-	if(q) return q < 0;
-	return StdValueCompare(v1, v2, language);
-}
-
-bool FnValuePairOrder::operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const
-{
-	return (*fn)(keya, valuea, keyb, valueb) < 0;
-}
-
-#endif
-
-void Complex::Xmlize(XmlIO& xio)
-{
-	double r, i;
-	r = real(); i = imag();
-	xio.Attr("real", r).Attr("imag", i);
-	*this = C(r, i);
-}
-
-void Complex::Jsonize(JsonIO& jio)
-{
-	double r, i;
-	r = real(); i = imag();
-	jio("real", r)("imag", i);
-	*this = C(r, i);
-}
-
-void Complex::Serialize(Stream& s)
-{
-	double r, i;
-	r = real(); i = imag();
-	s % r % i;
-	*this = C(r, i);
-}
-
-#ifdef SVO_VALUE
-template <class T>
-static void sReg(const char *name)
-{
-	if(FitsSvoValue<T>())
-		Value::SvoRegister<T>(name);
-	else
-		Value::Register<T>(name);
-}
-
-INITBLOCK
-{
-	sReg<Point>("Point");
-	sReg<Point64>("Point64");
-	sReg<Pointf>("Pointf");
-	sReg<Size>("Size");
-	sReg<Size64>("Size64");
-	sReg<Sizef>("Sizef");
-	Value::Register<Rect>("Rect");
-	Value::Register<Rect64>("Rect64");
-	Value::Register<Rectf>("Rectf");
-}
-#else
-INITBLOCK {
-	Point p;
-	RichValue<Point>::Register();
-	RichValue<Point64>::Register();
-	RichValue<Pointf>::Register();
-	RichValue<Size>::Register();
-	RichValue<Size64>::Register();
-	RichValue<Sizef>::Register();
-	RichValue<Rect>::Register();
-	RichValue<Rect64>::Register();
-	RichValue<Rectf>::Register();
-}
-#endif
-
-END_UPP_NAMESPACE
-
+#include "Core.h"
+
+NAMESPACE_UPP
+
+#ifdef SVO_VALUE
+
+#define LTIMING(x) // RTIMING(x)
+
+struct Ref::ValueRef : public RefManager {
+	virtual int   GetType()                            { return VALUE_V; }
+	virtual Value GetValue(const void *ptr)            { return *(Value *) ptr; }
+	virtual bool  IsNull(const void *ptr)              { return UPP::IsNull(*(Value *) ptr); }
+	virtual void  SetValue(void *ptr, const Value& v)  { *(Value *) ptr = v; }
+	virtual void  SetNull(void *ptr)                   { *(Value *) ptr = Null; }
+};
+
+Ref::Ref(String& s)  { ptr = &s; m = &Single< StdRef<String> >(); }
+Ref::Ref(WString& s) { ptr = &s; m = &Single< StdRef<WString> >(); }
+Ref::Ref(int& i)     { ptr = &i; m = &Single< StdRef<int> >(); }
+Ref::Ref(int64& i)   { ptr = &i; m = &Single< StdRef<int64> >(); }
+Ref::Ref(double& d)  { ptr = &d; m = &Single< StdRef<double> >(); }
+Ref::Ref(bool& b)    { ptr = &b; m = &Single< StdRef<bool> >(); }
+Ref::Ref(Date& d)    { ptr = &d; m = &Single< StdRef<Date> >(); }
+Ref::Ref(Time& t)    { ptr = &t; m = &Single< StdRef<Time> >(); }
+Ref::Ref(Value& v)   { ptr = &v; m = &Single< ValueRef >(); }
+
+// ----------------------------------
+
+bool ValueArray::Data::IsNull() const
+{
+	return data.IsEmpty();
+}
+
+void ValueArray::Data::Serialize(Stream& s)
+{
+	s % data;
+}
+
+void ValueArray::Data::Jsonize(JsonIO& jio)
+{
+	Upp::Jsonize(jio, data);
+}
+
+void ValueArray::Data::Xmlize(XmlIO& io)
+{
+	Upp::Xmlize(io, data);
+}
+
+unsigned ValueArray::Data::GetHashValue() const
+{
+	CombineHash w(data.GetCount());
+	for(int i = 0; i < data.GetCount(); i++)
+		w.Put(data[i].GetHashValue());
+	return w;
+}
+
+static bool sCmp(const Vector<Value>& a, const Vector<Value>& b)
+{
+	if(&a == &b) return true;
+	if(a.GetCount() != b.GetCount()) return false;
+	for(int i = 0; i < a.GetCount(); i++)
+		if(a[i] != b[i]) return false;
+	return true;
+}
+
+bool ValueArray::Data::IsEqual(const Value::Void *p)
+{
+	return sCmp(((Data *)p)->data, data);
+}
+
+bool ValueArray::operator==(const ValueArray& v) const
+{
+	return sCmp(data->data, v.data->data);
+}
+
+static String sAsString(const Vector<Value>& v)
+{
+	String s;
+	s << "[";
+	for(int i = 0; i < v.GetCount(); i++) {
+		if(i) s << ", ";
+		s << v[i];
+	}
+	s << "]";
+	return s;
+}
+
+String ValueArray::Data::AsString() const
+{
+	return sAsString(data);
+}
+
+Vector<Value>& ValueArray::Create()
+{
+	data = new Data;
+	return data->data;
+}
+
+Vector<Value>& ValueArray::Clone() {
+	if(data->GetRefCount() != 1) {
+		Data *d = new Data;
+		d->data <<= data->data;
+		data->Release();
+		data = d;
+	}
+	return data->data;
+}
+
+void ValueArray::Init0()
+{
+	data = &Single<NullData>();
+	data->Retain();
+}
+
+ValueArray::ValueArray(const ValueArray& v) {
+	data = v.data;
+	data->Retain();
+}
+
+ValueArray::ValueArray(pick_ Vector<Value>& v)
+{
+	Create() = v;
+}
+
+ValueArray::ValueArray(const Vector<Value>& v, int deep)
+{
+	Create() <<= v;
+}
+
+ValueArray::operator Value() const {
+	data->Retain();
+	return Value(data);
+}
+
+ValueArray::ValueArray(const Value& src)
+{
+	if(!UPP::IsNull(src)) {
+		if(IsType<ValueMap>(src)) {
+			ValueArray v = ValueMap(src);
+			data = v.data;
+			data->Retain();
+			return;
+		}
+		else {
+			ASSERT(dynamic_cast<const ValueArray::Data *>(src.GetVoidPtr()));
+			data = (ValueArray::Data *)src.GetVoidPtr();
+		}
+	}
+	else
+		data = &Single<NullData>();
+	data->Retain();
+}
+
+void ValueArray::Serialize(Stream& s) {
+	if(s.IsLoading()) {
+		data->Release();
+		Create();
+	}
+	data->Serialize(s);
+}
+
+void ValueArray::Jsonize(JsonIO& jio)
+{
+	if(jio.IsLoading()) {
+		data->Release();
+		Create();
+	}
+	data->Jsonize(jio);
+}
+
+ValueArray::~ValueArray() {
+	ASSERT(data->GetRefCount() > 0);
+	data->Release();
+}
+
+ValueArray& ValueArray::operator=(const ValueArray& v) {
+	v.data->Retain();
+	data->Release();
+	data = v.data;
+	return *this;
+}
+
+void ValueArray::SetCount(int n) {
+	Clone().SetCount(n);
+}
+
+void ValueArray::SetCount(int n, const Value& v)
+{
+	Clone().SetCount(n, v);
+}
+
+void ValueArray::Clear() {
+	Clone().Clear();
+}
+
+void ValueArray::Add(const Value& v) {
+	Clone().Add(v);
+}
+
+void ValueArray::Set(int i, const Value& v) {
+	ASSERT(i >= 0);
+	Clone().At(i) = v;
+}
+
+void ValueArray::Remove(int i, int count)
+{
+	Clone().Remove(i, count);
+}
+
+void ValueArray::Insert(int i, const ValueArray& va)
+{
+	if(va.data == data) {
+		ValueArray va2 = va;
+		Clone().Insert(i, va2.Get());
+	}
+	else
+		Clone().Insert(i, va.Get());
+}
+
+const Value& ValueArray::Get(int i) const {
+	ASSERT(i >= 0 && i < GetCount());
+	return data->data[i];
+}
+
+Value ValueArray::GetAndClear(int i)
+{
+	ASSERT(i >= 0 && i < GetCount());
+	Vector<Value>& x = Clone();
+	Value v = x[i];
+	x[i] = Value();
+	return v;
+}
+
+template<>
+String AsString(const ValueArray& v) {
+	return sAsString(v.Get());
+}
+
+bool ValueMap::Data::IsNull() const {
+	return this == &Single<ValueMap::NullData>();
+}
+
+void ValueMap::Data::Serialize(Stream& s) {
+	s % key % value;
+}
+
+void ValueMap::Data::Xmlize(XmlIO& xio)
+{
+	Upp::Xmlize(xio, key);
+	Upp::Xmlize(xio, value);
+}
+
+void ValueMap::Data::Jsonize(JsonIO& jio)
+{
+	if(jio.IsStoring()) {
+		ValueArray va;
+		int n = min(value.GetCount(), key.GetCount());
+		for(int i = 0; i < n; i++) {
+			ValueMap m;
+			m.Add("key", StoreAsJsonValue(key[i]));
+			m.Add("value", StoreAsJsonValue(value[i]));
+			va.Add(m);
+		}
+		jio.Set(va);
+	}
+	else {
+		Value va = jio.Get();
+		key.Clear();
+		value.Clear();
+		for(int i = 0; i < va.GetCount(); i++) {
+			Value k, v;
+			LoadFromJsonValue(k, va[i]["key"]);
+			LoadFromJsonValue(v, va[i]["value"]);
+			key.Add(k);
+			value.Add(v);
+		}
+	}
+}
+
+unsigned ValueMap::Data::GetHashValue() const {
+	CombineHash w(key.GetCount());
+	for(int i = 0; i < key.GetCount(); i++)
+		w.Put(key[i].GetHashValue());
+	w.Put(value.GetHashValue());
+	return w;
+}
+
+static bool sIsEqual(const Index<Value>& a, const Index<Value>& b) {
+	if(&a == &b) return true;
+	if(a.GetCount() != b.GetCount()) return false;
+	for(int i = 0; i < a.GetCount(); i++) {
+		if(a[i] != b[i]) return false;
+	}
+	return true;
+}
+
+bool ValueMap::Data::IsEqual(const Value::Void *p) {
+	return sIsEqual(((Data *)p)->key, key) && ((Data *)p)->value == value;
+}
+
+bool ValueMap::operator==(const ValueMap& v) const {
+	return sIsEqual(data->key, v.data->key) && data->value == v.data->value;
+}
+
+String ValueMap::Data::AsString() const
+{
+	String s;
+	s << "{ ";
+	for(int i = 0; i < key.GetCount(); i++) {
+		if(i) s << ", ";
+		s << key[i] << ": " << value[i];
+	}
+	s << " }";
+	return s;
+}
+
+ValueMap::Data& ValueMap::Create()
+{
+	data = new Data;
+	return *data;
+}
+
+const Value& ValueMap::Data::Get(const Value& k) const
+{
+	int q = key.Find(k);
+	return q >= 0 ? value[q] : ErrorValue();
+}
+
+ValueMap::Data& ValueMap::Clone() {
+	if(data->GetRefCount() != 1) {
+		Data *d = new Data;
+		d->key <<= data->key;
+		d->value = data->value;
+		data->Release();
+		data = d;
+	}
+	return *data;
+}
+
+void ValueMap::Init0()
+{
+	data = &Single<NullData>();
+	data->Retain();
+}
+
+ValueMap::ValueMap(const ValueMap& v)
+{
+	data = v.data;
+	data->Retain();
+}
+
+ValueMap::ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v)
+{
+	Data& d = Create();
+	d.key = k;
+	d.value = ValueArray(v);
+}
+
+ValueMap::ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep)
+{
+	Data& d = Create();
+	d.key <<= k;
+	Vector<Value> _v(v, 0);
+	d.value = ValueArray(_v);
+}
+
+ValueMap::operator Value() const {
+	data->Retain();
+	return Value(data);
+}
+
+ValueMap::ValueMap(const Value& src)
+{
+	if(!IsNull(src)) {
+		if(IsType<ValueArray>(src)) {
+			ValueArray va = src;
+			Init0();
+			for(int i = 0; i < va.GetCount(); i++)
+				Add(i, va[i]);
+			return;
+		}
+		else {
+			ASSERT(dynamic_cast<const ValueMap::Data *>(src.GetVoidPtr()));
+			data = (ValueMap::Data *)src.GetVoidPtr();
+		}
+	}
+	else
+		data = &Single<NullData>();
+	data->Retain();
+}
+
+void ValueMap::Serialize(Stream& s) {
+	if(s.IsLoading()) {
+		data->Release();
+		Create();
+	}
+	data->Serialize(s);
+}
+
+void ValueMap::Jsonize(JsonIO& jio)
+{
+	if(jio.IsLoading()) {
+		data->Release();
+		Create();
+	}
+	data->Jsonize(jio);
+}
+
+
+ValueMap::~ValueMap() {
+	ASSERT(data->GetRefCount() > 0);
+	data->Release();
+}
+
+ValueMap& ValueMap::operator=(const ValueMap& v) {
+	v.data->Retain();
+	data->Release();
+	data = v.data;
+	return *this;
+}
+
+void ValueMap::Clear() {
+	data->Release();
+	Init0();
+}
+
+void ValueMap::Add(const Value& key, const Value& value) {
+	Data& d = Clone();
+	d.key.Add(key);
+	d.value.Add(value);
+}
+
+void ValueMap::Set(const Value& key, const Value& value)
+{
+	Data& d = Clone();
+	int i = d.key.Find(key);
+	if(i >= 0)
+		d.value.Set(i, value);
+	else {
+		d.key.Add(key);
+		d.value.Add(value);
+	}
+}
+
+void ValueMap::SetAt(int i, const Value& v) {
+	Clone().value.Set(i, v);
+}
+
+void ValueMap::SetKey(int i, const Value& k) {
+	Clone().key.Set(i, k);
+}
+
+void ValueMap::Remove(int i)
+{
+	Data& d = Clone();
+	d.key.Remove(i);
+	d.value.Remove(i);
+}
+
+const Value& ValueMap::operator[](const Value& key) const
+{
+	return data->Get(key);
+}
+
+Value ValueMap::GetAndClear(const Value& key)
+{
+	Data& d = Clone();
+	int q = d.key.Find(key);
+	return q < 0 ? ErrorValue() : d.value.GetAndClear(q);
+}
+
+// ----------------------------------
+
+int StdValueCompare(const Value& a, const Value& b, int language)
+{
+	LTIMING("StdValueCompare");
+
+	bool na = IsNull(a), nb = IsNull(b);
+	if(na || nb)
+		return !na ? 1 : !nb ? -1 : 0;
+	dword ta = a.GetType(), tb = b.GetType();
+	if((ta == INT_V || ta == BOOL_V) && (tb == INT_V || tb == BOOL_V))
+		return cmp<int>(a, b);
+	if((ta == BOOL_V || ta == INT_V || ta == INT64_V || ta == DOUBLE_V)
+	&& (tb == BOOL_V || tb == INT_V || tb == INT64_V || tb == DOUBLE_V))
+		return cmp<double>(a, b);
+	if(ta == DATE_V && tb == DATE_V)
+		return cmp<Date>(a, b);
+	if((ta == DATE_V || ta == TIME_V) && (tb == DATE_V || tb == TIME_V))
+		return cmp<Time>(a, b);
+	if((ta == STRING_V || ta == WSTRING_V) && (tb == STRING_V || tb == WSTRING_V))
+		return GetLanguageInfo(language).Compare(WString(a), WString(b));
+	return cmp<int>(ta, tb);
+}
+
+int StdValueCompare(const Value& a, const Value& b)
+{
+	return StdValueCompare(a, b, GetCurrentLanguage());
+}
+
+int StdValueCompareDesc(const Value& a, const Value& b, int language)
+{
+	return -StdValueCompare(a, b, language);
+}
+
+int StdValueCompareDesc(const Value& a, const Value& b)
+{
+	return -StdValueCompare(a, b);
+}
+
+StdValueOrder::StdValueOrder(int l) : language(l) {}
+
+bool StdValueOrder::operator()(const Value& a, const Value& b) const
+{
+	return StdValueCompare(a, b, language) < 0;
+}
+
+bool FnValueOrder::operator()(const Value& a, const Value& b) const
+{
+	return (*fn)(a, b) < 0;
+}
+
+bool StdValuePairOrder::operator()(const Value& k1, const Value& v1, const Value& k2, const Value& v2) const
+{
+	int q = StdValueCompare(k1, k2, language);
+	if(q) return q < 0;
+	return StdValueCompare(v1, v2, language);
+}
+
+bool FnValuePairOrder::operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const
+{
+	return (*fn)(keya, valuea, keyb, valueb) < 0;
+}
+
+#endif
+
+void Complex::Xmlize(XmlIO& xio)
+{
+	double r, i;
+	r = real(); i = imag();
+	xio.Attr("real", r).Attr("imag", i);
+	*this = C(r, i);
+}
+
+void Complex::Jsonize(JsonIO& jio)
+{
+	double r, i;
+	r = real(); i = imag();
+	jio("real", r)("imag", i);
+	*this = C(r, i);
+}
+
+void Complex::Serialize(Stream& s)
+{
+	double r, i;
+	r = real(); i = imag();
+	s % r % i;
+	*this = C(r, i);
+}
+
+#ifdef SVO_VALUE
+template <class T>
+static void sReg(const char *name)
+{
+	if(FitsSvoValue<T>())
+		Value::SvoRegister<T>(name);
+	else
+		Value::Register<T>(name);
+}
+
+INITBLOCK
+{
+	sReg<Point>("Point");
+	sReg<Point64>("Point64");
+	sReg<Pointf>("Pointf");
+	sReg<Size>("Size");
+	sReg<Size64>("Size64");
+	sReg<Sizef>("Sizef");
+	Value::Register<Rect>("Rect");
+	Value::Register<Rect64>("Rect64");
+	Value::Register<Rectf>("Rectf");
+}
+#else
+INITBLOCK {
+	Point p;
+	RichValue<Point>::Register();
+	RichValue<Point64>::Register();
+	RichValue<Pointf>::Register();
+	RichValue<Size>::Register();
+	RichValue<Size64>::Register();
+	RichValue<Sizef>::Register();
+	RichValue<Rect>::Register();
+	RichValue<Rect64>::Register();
+	RichValue<Rectf>::Register();
+}
+#endif
+
+END_UPP_NAMESPACE
+
diff --git a/uppsrc/Core/ValueUtil.h b/uppsrc/Core/ValueUtil.h
index bb547bca8..666650cb7 100644
--- a/uppsrc/Core/ValueUtil.h
+++ b/uppsrc/Core/ValueUtil.h
@@ -1,359 +1,357 @@
-#ifdef SVO_VALUE
-
-Value Scan(dword stdtype, const String& text, const Value& def = Null);
-
-inline const String&  Nvl(const String& a, const String& b)    { return IsNull(a) ? b : a; }
-inline int            Nvl(int a, int b)                        { return IsNull(a) ? b : a; }
-inline int64          Nvl(int64 a, int64 b)                    { return IsNull(a) ? b : a; }
-inline double         Nvl(double a, double b)                  { return IsNull(a) ? b : a; }
-inline Date           Nvl(Date a, Date b)                      { return IsNull(a) ? b : a; }
-inline Time           Nvl(Time a, Time b)                      { return IsNull(a) ? b : a; }
-
-inline int            Nvl(int a)                               { return Nvl(a, 0); }
-inline int64          Nvl(int64 a)                             { return Nvl(a, (int64)0); }
-inline double         Nvl(double a)                            { return Nvl(a, 0.0); }
-
-int StdValueCompare(const Value& a, const Value& b, int language);
-int StdValueCompare(const Value& a, const Value& b);
-
-int StdValueCompareDesc(const Value& a, const Value& b, int language);
-int StdValueCompareDesc(const Value& a, const Value& b);
-
-struct ValueOrder {
-	virtual bool operator()(const Value& a, const Value& b) const = 0;
-	virtual ~ValueOrder() {}
-};
-
-struct StdValueOrder : ValueOrder {
-	int language;
-
-	virtual bool operator()(const Value& a, const Value& b) const;
-
-	StdValueOrder(int l = -1);
-};
-
-struct FnValueOrder : ValueOrder {
-	int (*fn)(const Value& a, const Value& b);
-
-	virtual bool operator()(const Value& a, const Value& b) const;
-
-	FnValueOrder(int (*fn)(const Value& a, const Value& b)) : fn(fn) {}
-};
-
-struct ValuePairOrder {
-	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const = 0;
-	virtual ~ValuePairOrder() {}
-};
-
-struct StdValuePairOrder : ValuePairOrder {
-	int language;
-
-	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
-
-	StdValuePairOrder(int l = -1);
-};
-
-struct FnValuePairOrder : ValuePairOrder {
-	int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2);
-
-	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
-
-	FnValuePairOrder(int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2)) : fn(fn) {}
-};
-
-class Id : Moveable<Id> {
-	String id;
-
-public:
-	const String&  ToString() const              { return id; }
-	dword          GetHashValue() const          { return UPP::GetHashValue(id); }
-	bool           IsNull() const                { return UPP::IsNull(id); }
-
-	operator const String&() const               { return ToString(); }
-	const String&  operator~() const             { return ToString(); }
-	bool           operator==(const Id& b) const { return id == b.id; }
-	bool           operator!=(const Id& b) const { return id != b.id; }
-
-	operator bool() const                        { return id.GetCount(); }
-
-	Id()                                         {}
-	Id(const String& s)                          { id = s; }
-	Id(const char *s)                            { id = s; }
-};
-
-struct RefManager {
-	virtual int   GetType() = 0;
-	virtual Value GetValue(const void *)            { return Null; }
-	virtual bool  IsNull(const void *)              { return false; }
-	virtual void  SetValue(void *, const Value& v)  { NEVER(); }
-	virtual void  SetNull(void *)                   { NEVER(); }
-	virtual ~RefManager() {}
-};
-
-template <class T>
-struct StdRef : public RefManager {
-	virtual void  SetValue(void *p, const Value& v) { *(T *) p = (T)v; }
-	virtual Value GetValue(const void *p)           { return *(const T *) p; }
-	virtual int   GetType()                         { return GetValueTypeNo<T>(); }
-	virtual bool  IsNull(const void *p)             { return UPP::IsNull(*(T *) p); }
-	virtual void  SetNull(void *p)                  { UPP::SetNull(*(T *)p); }
-	virtual ~StdRef() {}
-};
-
-class Ref : Moveable<Ref> {
-protected:
-	RefManager *m;
-	void       *ptr;
-	struct      ValueRef;
-
-public:
-	dword    GetType() const           { return m ? m->GetType() : VOID_V; }
-	bool     IsNull() const            { return m ? m->IsNull(ptr) : true; }
-
-	void    *GetVoidPtr() const        { return ptr; }
-
-	template <class T>
-	bool     Is() const                { return GetType() == GetValueTypeNo<T>(); } // VALUE_V!!!
-	template <class T>
-	T&       Get() const               { ASSERT(GetValueTypeNo<T>() == GetType()); return *(T *)GetVoidPtr(); }
-
-	void     SetNull()                 { if(m) m->SetNull(ptr); }
-	Value    GetValue() const          { return m ? m->GetValue(ptr) : Value(); }
-	void     SetValue(const Value& v)  { ASSERT(m); m->SetValue(ptr, v); }
-
-	operator Value() const             { return GetValue(); }
-	Value    operator~() const         { return GetValue(); }
-	Ref&     operator=(const Value& v) { SetValue(v); return *this; }
-
-	Ref(String& s);
-	Ref(WString& s);
-	Ref(int& i);
-	Ref(int64& i);
-	Ref(double& d);
-	Ref(bool& b);
-	Ref(Date& d);
-	Ref(Time& t);
-	Ref(Value& v);
-	Ref(void *_ptr, RefManager *_m)    { ptr = _ptr, m = _m; }
-	Ref(const ValueTypeRef& r);
-	Ref()                              { ptr = m = NULL; }
-};
-
-template <class T>
-T& GetRef(Ref r, T *x = NULL) {
-	ASSERT(GetValueTypeNo<T>() == r.GetType());
-	return *(T *) r.GetVoidPtr();
-}
-
-inline String&  RefString(Ref f)  { return GetRef<String>(f); }
-inline WString& RefWString(Ref f) { return GetRef<WString>(f); }
-inline int&     RefInt(Ref f)     { return GetRef<int>(f); }
-inline int64&   RefInt64(Ref f)   { return GetRef<int64>(f); }
-inline double&  RefDouble(Ref f)  { return GetRef<double>(f); }
-inline bool&    RefBool(Ref f)    { return GetRef<bool>(f); }
-inline Date&    RefDate(Ref f)    { return GetRef<Date>(f); }
-inline Time&    RefTime(Ref f)    { return GetRef<Time>(f); }
-inline Value&   RefValue(Ref f)   { ASSERT(f.GetType() == VALUE_V);
-                                    return *(Value *)f.GetVoidPtr(); }
-
-template <class T>
-Ref AsRef(T& x) {
-	return Ref(&x, &Single< StdRef<T> >());
-}
-
-struct ValueTypeRef {
-	RefManager *m;
-	void       *ptr;
-};
-
-inline
-Ref::Ref(const ValueTypeRef& r)
-{
-	ptr = r.ptr;
-	m = r.m;
-}
-
-template <class T, dword type, class B>
-ValueType<T, type, B>::operator ValueTypeRef()
-{
-	ValueTypeRef h;
-	h.ptr = this;
-	h.m = &Single< StdRef<T> >();
-	return h;
-}
-
-#define E__Value(I)   Value p##I
-#define E__Ref(I)     Ref p##I
-
-// ---------------------- Value Array
-
-class ValueArray : AssignValueTypeNo<ValueArray, VALUEARRAY_V, Moveable<ValueArray> > {
-	struct Data : Value::Void {
-		virtual dword      GetType() const             { return VALUEARRAY_V; }
-		virtual bool       IsNull() const;
-		virtual void       Serialize(Stream& s);
-		virtual void       Xmlize(XmlIO& xio);
-		virtual void       Jsonize(JsonIO& jio);
-		virtual unsigned   GetHashValue() const;
-		virtual bool       IsEqual(const Value::Void *p);
-		virtual String     AsString() const;
-
-		int GetRefCount() const     { return AtomicRead(refcount); }
-
-		Vector<Value> data;
-	};
-	struct NullData : Data {};
-	Data *data;
-
-	Vector<Value>& Create();
-	Vector<Value>& Clone();
-	void  Init0();
-	
-	friend Value::Void *ValueArrayDataCreate();
-	friend class Value;
-
-public:
-	ValueArray()                              { Init0(); }
-	ValueArray(const ValueArray& v);
-	explicit ValueArray(pick_ Vector<Value>& values);
-	explicit ValueArray(const Vector<Value>& values, int deep);
-	~ValueArray();
-
-	ValueArray& operator=(const ValueArray& v);
-
-	operator Value() const;
-	ValueArray(const Value& src);
-
-	ValueArray(const Nuller&)                 { Init0(); }
-	bool IsNull() const                       { return data->IsNull(); }
-
-	void Clear();
-	void SetCount(int n);
-	void SetCount(int n, const Value& v);
-	int  GetCount() const                     { return data->data.GetCount(); }
-	bool IsEmpty() const                      { return data->data.IsEmpty(); }
-
-	void Add(const Value& v);
-	ValueArray& operator<<(const Value& v)    { Add(v); return *this; }
-	void Set(int i, const Value& v);
-	const Value& Get(int i) const;
-	Value GetAndClear(int i);
-	const Vector<Value>& Get() const          { return data->data; }
-
-	void Remove(int i, int count = 1);
-	void Insert(int i, const ValueArray& va);
-	void Append(const ValueArray& va)         { Insert(GetCount(), va); }
-
-	const Value& operator[](int i) const      { return Get(i); }
-
-	unsigned GetHashValue() const             { return data->GetHashValue(); }
-	void  Serialize(Stream& s);
-	void  Jsonize(JsonIO& jio);
-
-	bool operator==(const ValueArray& v) const;
-	bool operator!=(const ValueArray& v) const  { return !operator==(v); }
-};
-
-template<> inline unsigned GetHashValue(const ValueArray& v) { return v.GetHashValue(); }
-template<> inline bool     IsNull(const ValueArray& v)       { return v.IsNull(); }
-
-template<>
-String AsString(const ValueArray& v);
-
-class ValueMap : AssignValueTypeNo<ValueMap, VALUEMAP_V, Moveable<ValueMap> >{
-	struct Data : Value::Void {
-		virtual dword      GetType() const             { return VALUEMAP_V; }
-		virtual bool       IsNull() const;
-		virtual void       Serialize(Stream& s);
-		virtual void       Xmlize(XmlIO& xio);
-		virtual void       Jsonize(JsonIO& jio);
-		virtual unsigned   GetHashValue() const;
-		virtual bool       IsEqual(const Value::Void *p);
-		virtual String     AsString() const;
-
-		const Value& Get(const Value& key) const;
-
-		Index<Value> key;
-		ValueArray   value;
-	};
-
-	struct NullData : Data {};
-	Data *data;
-
-	Data& Create();
-	Data& Clone();
-	void  Init0();
-
-	friend Value::Void *ValueMapDataCreate();
-	friend class Value;
-
-public:
-	ValueMap()                               { Init0(); }
-	ValueMap(const ValueMap& v);
-	ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v);
-	ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep);
-	~ValueMap();
-
-	ValueMap& operator=(const ValueMap& v);
-
-	operator Value() const;
-	ValueMap(const Value& src);
-
-	ValueMap(const Nuller&)                  { Init0(); }
-	bool IsNullInstance() const              { return data->IsNull(); }
-
-	void Clear();
-	int  GetCount() const                     { return data->value.GetCount(); }
-	bool IsEmpty() const                      { return data->value.IsEmpty(); }
-	const Value& GetKey(int i) const          { return data->key[i]; }
-	const Value& GetValue(int i) const        { return data->value[i]; }
-
-	void Add(const Value& key, const Value& value);
-	void Add(const String& s, const Value& value) { Add(Value(s), value); }
-	void Add(const char *s, const Value& value)   { Add(Value(s), value); }
-	void Add(Id id, const Value& value)           { Add(Value(id.ToString()), value); }
-
-	void Set(const Value& key, const Value& value);
-	void Set(const String& s, const Value& value) { Set(Value(s), value); }
-	void Set(const char *s, const Value& value)   { Set(Value(s), value); }
-	void Set(Id id, const Value& value)           { Set(Value(id.ToString()), value); }
-
-	void SetAt(int i, const Value& v);
-	void SetKey(int i, const Value& k);
-	void SetKey(int i, const String& s)           { SetKey(i, Value(s)); }
-	void SetKey(int i, const char* s)             { SetKey(i, Value(s)); }
-	void SetKey(int i, Id id)                     { SetKey(i, Value(id.ToString())); }
-	void Remove(int i);
-
-	const Index<Value>& GetKeys() const           { return data->key; }
-	ValueArray GetValues() const                  { return data->value; }
-
-	operator ValueArray() const                   { return GetValues(); }
-
-	const Value& operator[](const Value& k) const;
-	const Value& operator[](const String& s) const{ return operator[](Value(s)); }
-	const Value& operator[](const char *s) const  { return operator[](Value(s)); }
-	const Value& operator[](const Id& k) const    { return operator[](Value(k.ToString())); }
-	
-	Value GetAndClear(const Value& key);
-
-	unsigned GetHashValue() const                 { return data->GetHashValue(); }
-	void     Serialize(Stream& s);
-	void     Jsonize(JsonIO& jio);
-	String   ToString() const                     { return data->AsString(); }
-
-	bool operator==(const ValueMap& v) const;
-	bool operator!=(const ValueMap& v) const      { return !operator==(v); }
-};
-
-class ValueGen {
-public:
-	virtual Value  Get() = 0;
-	Value operator++()                           { return Get(); }
-	virtual ~ValueGen() {}
-};
-
-
-#include "Value.hpp"
-
+#ifdef SVO_VALUE
+
+Value Scan(dword stdtype, const String& text, const Value& def = Null);
+
+inline const String&  Nvl(const String& a, const String& b)    { return IsNull(a) ? b : a; }
+inline int            Nvl(int a, int b)                        { return IsNull(a) ? b : a; }
+inline int64          Nvl(int64 a, int64 b)                    { return IsNull(a) ? b : a; }
+inline double         Nvl(double a, double b)                  { return IsNull(a) ? b : a; }
+inline Date           Nvl(Date a, Date b)                      { return IsNull(a) ? b : a; }
+inline Time           Nvl(Time a, Time b)                      { return IsNull(a) ? b : a; }
+
+inline int            Nvl(int a)                               { return Nvl(a, 0); }
+inline int64          Nvl(int64 a)                             { return Nvl(a, (int64)0); }
+inline double         Nvl(double a)                            { return Nvl(a, 0.0); }
+
+int StdValueCompare(const Value& a, const Value& b, int language);
+int StdValueCompare(const Value& a, const Value& b);
+
+int StdValueCompareDesc(const Value& a, const Value& b, int language);
+int StdValueCompareDesc(const Value& a, const Value& b);
+
+struct ValueOrder {
+	virtual bool operator()(const Value& a, const Value& b) const = 0;
+	virtual ~ValueOrder() {}
+};
+
+struct StdValueOrder : ValueOrder {
+	int language;
+
+	virtual bool operator()(const Value& a, const Value& b) const;
+
+	StdValueOrder(int l = -1);
+};
+
+struct FnValueOrder : ValueOrder {
+	int (*fn)(const Value& a, const Value& b);
+
+	virtual bool operator()(const Value& a, const Value& b) const;
+
+	FnValueOrder(int (*fn)(const Value& a, const Value& b)) : fn(fn) {}
+};
+
+struct ValuePairOrder {
+	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const = 0;
+	virtual ~ValuePairOrder() {}
+};
+
+struct StdValuePairOrder : ValuePairOrder {
+	int language;
+
+	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
+
+	StdValuePairOrder(int l = -1);
+};
+
+struct FnValuePairOrder : ValuePairOrder {
+	int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2);
+
+	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
+
+	FnValuePairOrder(int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2)) : fn(fn) {}
+};
+
+class Id : Moveable<Id> {
+	String id;
+
+public:
+	const String&  ToString() const              { return id; }
+	dword          GetHashValue() const          { return UPP::GetHashValue(id); }
+	bool           IsNull() const                { return UPP::IsNull(id); }
+
+	operator const String&() const               { return ToString(); }
+	const String&  operator~() const             { return ToString(); }
+	bool           operator==(const Id& b) const { return id == b.id; }
+	bool           operator!=(const Id& b) const { return id != b.id; }
+
+	operator bool() const                        { return id.GetCount(); }
+
+	Id()                                         {}
+	Id(const String& s)                          { id = s; }
+	Id(const char *s)                            { id = s; }
+};
+
+struct RefManager {
+	virtual int   GetType() = 0;
+	virtual Value GetValue(const void *)            { return Null; }
+	virtual bool  IsNull(const void *)              { return false; }
+	virtual void  SetValue(void *, const Value& v)  { NEVER(); }
+	virtual void  SetNull(void *)                   { NEVER(); }
+	virtual ~RefManager() {}
+};
+
+template <class T>
+struct StdRef : public RefManager {
+	virtual void  SetValue(void *p, const Value& v) { *(T *) p = (T)v; }
+	virtual Value GetValue(const void *p)           { return *(const T *) p; }
+	virtual int   GetType()                         { return GetValueTypeNo<T>(); }
+	virtual bool  IsNull(const void *p)             { return UPP::IsNull(*(T *) p); }
+	virtual void  SetNull(void *p)                  { UPP::SetNull(*(T *)p); }
+	virtual ~StdRef() {}
+};
+
+class Ref : Moveable<Ref> {
+protected:
+	RefManager *m;
+	void       *ptr;
+	struct      ValueRef;
+
+public:
+	dword    GetType() const           { return m ? m->GetType() : VOID_V; }
+	bool     IsNull() const            { return m ? m->IsNull(ptr) : true; }
+
+	void    *GetVoidPtr() const        { return ptr; }
+
+	template <class T>
+	bool     Is() const                { return GetType() == GetValueTypeNo<T>(); } // VALUE_V!!!
+	template <class T>
+	T&       Get() const               { ASSERT(GetValueTypeNo<T>() == GetType()); return *(T *)GetVoidPtr(); }
+
+	void     SetNull()                 { if(m) m->SetNull(ptr); }
+	Value    GetValue() const          { return m ? m->GetValue(ptr) : Value(); }
+	void     SetValue(const Value& v)  { ASSERT(m); m->SetValue(ptr, v); }
+
+	operator Value() const             { return GetValue(); }
+	Value    operator~() const         { return GetValue(); }
+	Ref&     operator=(const Value& v) { SetValue(v); return *this; }
+
+	Ref(String& s);
+	Ref(WString& s);
+	Ref(int& i);
+	Ref(int64& i);
+	Ref(double& d);
+	Ref(bool& b);
+	Ref(Date& d);
+	Ref(Time& t);
+	Ref(Value& v);
+	Ref(void *_ptr, RefManager *_m)    { ptr = _ptr, m = _m; }
+	Ref(const ValueTypeRef& r);
+	Ref()                              { ptr = m = NULL; }
+};
+
+template <class T>
+T& GetRef(Ref r, T *x = NULL) {
+	ASSERT(GetValueTypeNo<T>() == r.GetType());
+	return *(T *) r.GetVoidPtr();
+}
+
+inline String&  RefString(Ref f)  { return GetRef<String>(f); }
+inline WString& RefWString(Ref f) { return GetRef<WString>(f); }
+inline int&     RefInt(Ref f)     { return GetRef<int>(f); }
+inline int64&   RefInt64(Ref f)   { return GetRef<int64>(f); }
+inline double&  RefDouble(Ref f)  { return GetRef<double>(f); }
+inline bool&    RefBool(Ref f)    { return GetRef<bool>(f); }
+inline Date&    RefDate(Ref f)    { return GetRef<Date>(f); }
+inline Time&    RefTime(Ref f)    { return GetRef<Time>(f); }
+inline Value&   RefValue(Ref f)   { ASSERT(f.GetType() == VALUE_V);
+                                    return *(Value *)f.GetVoidPtr(); }
+
+template <class T>
+Ref AsRef(T& x) {
+	return Ref(&x, &Single< StdRef<T> >());
+}
+
+struct ValueTypeRef {
+	RefManager *m;
+	void       *ptr;
+};
+
+inline
+Ref::Ref(const ValueTypeRef& r)
+{
+	ptr = r.ptr;
+	m = r.m;
+}
+
+template <class T, dword type, class B>
+ValueType<T, type, B>::operator ValueTypeRef()
+{
+	ValueTypeRef h;
+	h.ptr = this;
+	h.m = &Single< StdRef<T> >();
+	return h;
+}
+
+#define E__Value(I)   Value p##I
+#define E__Ref(I)     Ref p##I
+
+// ---------------------- Value Array
+
+class ValueArray : AssignValueTypeNo<ValueArray, VALUEARRAY_V, Moveable<ValueArray> > {
+	struct Data : Value::Void {
+		virtual dword      GetType() const             { return VALUEARRAY_V; }
+		virtual bool       IsNull() const;
+		virtual void       Serialize(Stream& s);
+		virtual void       Xmlize(XmlIO& xio);
+		virtual void       Jsonize(JsonIO& jio);
+		virtual unsigned   GetHashValue() const;
+		virtual bool       IsEqual(const Value::Void *p);
+		virtual String     AsString() const;
+
+		int GetRefCount() const     { return AtomicRead(refcount); }
+
+		Vector<Value> data;
+	};
+	struct NullData : Data {};
+	Data *data;
+
+	Vector<Value>& Create();
+	Vector<Value>& Clone();
+	void  Init0();
+	
+	friend Value::Void *ValueArrayDataCreate();
+	friend class Value;
+
+public:
+	ValueArray()                              { Init0(); }
+	ValueArray(const ValueArray& v);
+	explicit ValueArray(pick_ Vector<Value>& values);
+	explicit ValueArray(const Vector<Value>& values, int deep);
+	~ValueArray();
+
+	ValueArray& operator=(const ValueArray& v);
+
+	operator Value() const;
+	ValueArray(const Value& src);
+
+	ValueArray(const Nuller&)                 { Init0(); }
+	bool IsNullInstance() const               { return IsEmpty(); }
+
+	void Clear();
+	void SetCount(int n);
+	void SetCount(int n, const Value& v);
+	int  GetCount() const                     { return data->data.GetCount(); }
+	bool IsEmpty() const                      { return data->data.IsEmpty(); }
+
+	void Add(const Value& v);
+	ValueArray& operator<<(const Value& v)    { Add(v); return *this; }
+	void Set(int i, const Value& v);
+	const Value& Get(int i) const;
+	Value GetAndClear(int i);
+	const Vector<Value>& Get() const          { return data->data; }
+
+	void Remove(int i, int count = 1);
+	void Insert(int i, const ValueArray& va);
+	void Append(const ValueArray& va)         { Insert(GetCount(), va); }
+
+	const Value& operator[](int i) const      { return Get(i); }
+
+	unsigned GetHashValue() const             { return data->GetHashValue(); }
+	void     Serialize(Stream& s);
+	void     Jsonize(JsonIO& jio);
+	String   ToString() const;
+
+	bool operator==(const ValueArray& v) const;
+	bool operator!=(const ValueArray& v) const  { return !operator==(v); }
+};
+
+template<>
+String AsString(const ValueArray& v);
+
+class ValueMap : AssignValueTypeNo<ValueMap, VALUEMAP_V, Moveable<ValueMap> >{
+	struct Data : Value::Void {
+		virtual dword      GetType() const             { return VALUEMAP_V; }
+		virtual bool       IsNull() const;
+		virtual void       Serialize(Stream& s);
+		virtual void       Xmlize(XmlIO& xio);
+		virtual void       Jsonize(JsonIO& jio);
+		virtual unsigned   GetHashValue() const;
+		virtual bool       IsEqual(const Value::Void *p);
+		virtual String     AsString() const;
+
+		const Value& Get(const Value& key) const;
+
+		Index<Value> key;
+		ValueArray   value;
+	};
+
+	struct NullData : Data {};
+	Data *data;
+
+	Data& Create();
+	Data& Clone();
+	void  Init0();
+
+	friend Value::Void *ValueMapDataCreate();
+	friend class Value;
+
+public:
+	ValueMap()                               { Init0(); }
+	ValueMap(const ValueMap& v);
+	ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v);
+	ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep);
+	~ValueMap();
+
+	ValueMap& operator=(const ValueMap& v);
+
+	operator Value() const;
+	ValueMap(const Value& src);
+
+	ValueMap(const Nuller&)                  { Init0(); }
+	bool IsNullInstance() const              { return IsEmpty(); }
+
+	void Clear();
+	int  GetCount() const                     { return data->value.GetCount(); }
+	bool IsEmpty() const                      { return data->value.IsEmpty(); }
+	const Value& GetKey(int i) const          { return data->key[i]; }
+	const Value& GetValue(int i) const        { return data->value[i]; }
+
+	void Add(const Value& key, const Value& value);
+	void Add(const String& s, const Value& value) { Add(Value(s), value); }
+	void Add(const char *s, const Value& value)   { Add(Value(s), value); }
+	void Add(Id id, const Value& value)           { Add(Value(id.ToString()), value); }
+
+	void Set(const Value& key, const Value& value);
+	void Set(const String& s, const Value& value) { Set(Value(s), value); }
+	void Set(const char *s, const Value& value)   { Set(Value(s), value); }
+	void Set(Id id, const Value& value)           { Set(Value(id.ToString()), value); }
+
+	void SetAt(int i, const Value& v);
+	void SetKey(int i, const Value& k);
+	void SetKey(int i, const String& s)           { SetKey(i, Value(s)); }
+	void SetKey(int i, const char* s)             { SetKey(i, Value(s)); }
+	void SetKey(int i, Id id)                     { SetKey(i, Value(id.ToString())); }
+	void Remove(int i);
+
+	const Index<Value>& GetKeys() const           { return data->key; }
+	ValueArray GetValues() const                  { return data->value; }
+
+	operator ValueArray() const                   { return GetValues(); }
+
+	const Value& operator[](const Value& k) const;
+	const Value& operator[](const String& s) const{ return operator[](Value(s)); }
+	const Value& operator[](const char *s) const  { return operator[](Value(s)); }
+	const Value& operator[](const Id& k) const    { return operator[](Value(k.ToString())); }
+	
+	Value GetAndClear(const Value& key);
+
+	unsigned GetHashValue() const                 { return data->GetHashValue(); }
+	void     Serialize(Stream& s);
+	void     Jsonize(JsonIO& jio);
+	String   ToString() const                     { return data->AsString(); }
+
+	bool operator==(const ValueMap& v) const;
+	bool operator!=(const ValueMap& v) const      { return !operator==(v); }
+};
+
+class ValueGen {
+public:
+	virtual Value  Get() = 0;
+	Value operator++()                           { return Get(); }
+	virtual ~ValueGen() {}
+};
+
+
+#include "Value.hpp"
+
 #endif
\ No newline at end of file
diff --git a/uppsrc/Core/Xmlize.cpp b/uppsrc/Core/Xmlize.cpp
index 5187eaca5..4cbac8343 100644
--- a/uppsrc/Core/Xmlize.cpp
+++ b/uppsrc/Core/Xmlize.cpp
@@ -11,6 +11,7 @@ void Xmlize(XmlIO& xml, String& var)
 				var = xml->Node(i).GetText();
 				return;
 			}
+		var.Clear();
 	}
 	else {
 		for(int i = 0; i < xml->GetCount(); i++)