diff --git a/uppsrc/Core/Core.h b/uppsrc/Core/Core.h
index 36c8e8685..901e8ce33 100644
--- a/uppsrc/Core/Core.h
+++ b/uppsrc/Core/Core.h
@@ -259,6 +259,9 @@ inline void operator  delete[](void *ptr, const std::nothrow_t&) throw() { UPP::
 
 NAMESPACE_UPP
 
+class XmlIO;
+class JsonIO;
+
 #include "Mt.h"
 #include "Global.h"
 #include "Topt.h"
@@ -278,8 +281,6 @@ NAMESPACE_UPP
 #include "Tuple.h"
 #include "Other.h"
 #include "Algo.h"
-#include "Vcont.hpp"
-#include "Index.hpp"
 
 #include "Value.h"
 #include "ValueUtil.h"
@@ -319,6 +320,9 @@ NAMESPACE_UPP
 
 #include "Win32Util.h"
 
+#include "Vcont.hpp"
+#include "Index.hpp"
+
 #if (defined(HEAPDBG) || defined(TESTLEAKS)) && defined(PLATFORM_POSIX)
 extern int sMemDiagInitCount;
 #endif
diff --git a/uppsrc/Core/Index.h b/uppsrc/Core/Index.h
index 555881f9d..52b5515ce 100644
--- a/uppsrc/Core/Index.h
+++ b/uppsrc/Core/Index.h
@@ -162,6 +162,8 @@ public:
 
 #ifdef UPP
 	void     Serialize(Stream& s);
+	void     Xmlize(XmlIO& xio, const char *itemtag = "key");
+	void     Jsonize(JsonIO& jio);
 #endif
 
 	V        PickKeys() pick_                 { return key; }
diff --git a/uppsrc/Core/Index.hpp b/uppsrc/Core/Index.hpp
index 3c0dab723..455c9ede4 100644
--- a/uppsrc/Core/Index.hpp
+++ b/uppsrc/Core/Index.hpp
@@ -234,6 +234,18 @@ void AIndex<T, V, HashFn>::Serialize(Stream& s) {
 	key.Serialize(s);
 	hash.Serialize(s);
 }
+
+template <class T, class V, class HashFn>
+void AIndex<T, V, HashFn>::Xmlize(XmlIO& xio, const char *itemtag)
+{
+	XmlizeIndex<T, AIndex<T, V, HashFn> >(xio, itemtag, *this);
+}
+
+template <class T, class V, class HashFn>
+void AIndex<T, V, HashFn>::Jsonize(JsonIO& jio)
+{
+	JsonizeIndex<AIndex<T, V, HashFn>, T>(jio, *this);
+}
 #endif
 
 template <class T, class V, class HashFn>
@@ -520,6 +532,18 @@ void AMap<K, T, V, HashFn>::Serialize(Stream& s) {
 	int version = 0;
 	s / version % key % value;
 }
+
+template <class K, class T, class V, class HashFn>
+void AMap<K, T, V, HashFn>::Xmlize(XmlIO& xio)
+{
+	XmlizeMap<K, T, AMap<K, T, V, HashFn> >(xio, "key", "value", *this);
+}
+
+template <class K, class T, class V, class HashFn>
+void AMap<K, T, V, HashFn>::Jsonize(JsonIO& jio)
+{
+	JsonizeMap<AMap<K, T, V, HashFn>, K, T>(jio, *this, "key", "value");
+}
 #endif
 
 template <class K, class T, class V, class HashFn>
diff --git a/uppsrc/Core/JSON.h b/uppsrc/Core/JSON.h
index acb0e9814..b1944498f 100644
--- a/uppsrc/Core/JSON.h
+++ b/uppsrc/Core/JSON.h
@@ -1,361 +1,325 @@
-Value  ParseJSON(CParser& p);
-Value  ParseJSON(const char *s);
-
-inline String AsJSON(int i)             { return IsNull(i) ? "null" : AsString(i); }
-inline String AsJSON(double n)          { return IsNull(n) ? "null" : AsString(n); }
-inline String AsJSON(bool b)            { return b ? "true" : "false"; }
-inline String AsJSON(const String& s)   { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
-inline String AsJSON(const WString& s)  { return AsCString(s.ToString(), INT_MAX, NULL, ASCSTRING_JSON); }
-inline String AsJSON(const char *s)     { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
-
-String AsJSON(const Value& v, const String& indent, bool pretty);
-String AsJSON(const Value& v, bool pretty = false);
-
-class JsonArray;
-
-class Json {
-	String text;
-
-public:
-	Json& CatRaw(const char *key, const String& val);
-
-	String ToString() const                                     { return "{" + text + "}"; }
-	String operator~() const                                    { return ToString(); }
-	operator String() const                                     { return ToString(); }
-
-	operator bool() const                                       { return text.GetCount(); }
-	
-	Json& operator()(const char *key, const Value& value)       { return CatRaw(key, AsJSON(value)); }
-	Json& operator()(const char *key, int i)                    { return CatRaw(key, AsJSON(i)); }
-	Json& operator()(const char *key, double n)                 { return CatRaw(key, AsJSON(n)); }
-	Json& operator()(const char *key, bool b)                   { return CatRaw(key, AsJSON(b)); }
-	Json& operator()(const char *key, const String& s)          { return CatRaw(key, AsJSON(s)); }
-	Json& operator()(const char *key, const WString& s)         { return CatRaw(key, AsJSON(s)); }
-	Json& operator()(const char *key, const char *s)            { return CatRaw(key, AsJSON(s)); }
-	Json& operator()(const char *key, const Json& object)       { return CatRaw(key, ~object); }
-	Json& operator()(const char *key, const JsonArray& array);
-		
-	Json() {}
-	Json(const char *key, const Value& value)                   { CatRaw(key, AsJSON(value)); }
-	Json(const char *key, int i)                                { CatRaw(key, AsJSON(i)); }
-	Json(const char *key, double n)                             { CatRaw(key, AsJSON(n)); }
-	Json(const char *key, bool b)                               { CatRaw(key, AsJSON(b)); }
-	Json(const char *key, const String& s)                      { CatRaw(key, AsJSON(s)); }
-	Json(const char *key, const WString& s)                     { CatRaw(key, AsJSON(s)); }
-	Json(const char *key, const char *s)                        { CatRaw(key, AsJSON(s)); }
-	Json(const char *key, const Json& object)                   { CatRaw(key, ~object); }
-	Json(const char *key, const JsonArray& array)               { operator()(key, array); }
-};
-
-class JsonArray {
-	String text;
-
-public:
-	JsonArray& CatRaw(const String& val);
-
-	String ToString() const                                     { return "[" + text + "]"; }
-	String operator~() const                                    { return ToString(); }
-	operator String() const                                     { return ToString(); }
-	
-	operator bool() const                                       { return text.GetCount(); }
-	
-	JsonArray& operator<<(const Value& value)                   { return CatRaw(AsJSON(value)); }
-	JsonArray& operator<<(int i)                                { return CatRaw(AsJSON(i)); }
-	JsonArray& operator<<(double n)                             { return CatRaw(AsJSON(n)); }
-	JsonArray& operator<<(bool b)                               { return CatRaw(AsJSON(b)); }
-	JsonArray& operator<<(const String& s)                      { return CatRaw(AsJSON(s)); }
-	JsonArray& operator<<(const WString& s)                     { return CatRaw(AsJSON(s)); }
-	JsonArray& operator<<(const char *s)                        { return CatRaw(AsJSON(s)); }
-	JsonArray& operator<<(const Json& object)                   { return CatRaw(~object); }
-	JsonArray& operator<<(const JsonArray& array)               { return CatRaw(~array); }
-		
-	JsonArray() {}
-};
-
-inline Json& Json::operator()(const char *key, const JsonArray& array)
-{
-	return CatRaw(key, array);
-}
-
-class JsonIO {
-	const Value   *src;
-	One<ValueMap>  map;
-	Value          tgt;
-
-public:
-	bool IsLoading() const                       { return src; }
-	bool IsStoring() const                       { return !src; }
-	
-	const Value& Get() const                     { ASSERT(IsLoading()); return *src; }
-	void         Set(const Value& v)             { ASSERT(IsStoring() && !map); tgt = v; }
-
-	void         Put(Value& v)                   { ASSERT(IsStoring()); if(map) v = *map; else v = tgt; }
-	Value        GetResult() const               { ASSERT(IsStoring()); return map ? Value(*map) : tgt; }
-
-	template <class T>
-	JsonIO& operator()(const char *key, T& value);
-	
-	JsonIO(const Value& src) : src(&src)         {}
-	JsonIO()                                     { src = NULL; }
-};
-
-struct JsonizeError : Exc {
-	JsonizeError(const String& s) : Exc(s) {}
-};
-
-template <class T>
-void Jsonize(JsonIO& io, T& var)
-{
-	var.Jsonize(io);
-}
-
-template <class T>
-JsonIO& JsonIO::operator()(const char *key, T& value)
-{
-	if(IsLoading()) {
-		const Value& v = (*src)[key];
-		if(!v.IsVoid()) {
-			JsonIO jio(v);
-			Jsonize(jio, value);
-		}
-	}
-	else {
-		ASSERT(tgt.IsVoid());
-		if(!map)
-			map.Create();
-		JsonIO jio;
-		Jsonize(jio, value);
-		if(jio.map)
-			map->Add(key, *jio.map);
-		else
-			map->Add(key, jio.tgt);
-	}
-	return *this;
-}
-
-template <class T>
-Value StoreAsJsonValue(const T& var)
-{
-	JsonIO io;
-	Jsonize(io, const_cast<T&>(var));
-	return io.GetResult();
-}
-
-template <class T>
-void LoadFromJsonValue(T& var, const Value& x)
-{
-	JsonIO io(x);
-	Jsonize(io, var);
-}
-
-template <class T>
-String StoreAsJson(const T& var, bool pretty = false)
-{
-	return AsJSON(StoreAsJsonValue(var), pretty);
-}
-
-template <class T>
-bool LoadFromJson(T& var, const char *json)
-{
-	try {
-		Value jv = ParseJSON(json);
-		if(jv.IsError())
-			return false;
-		LoadFromJsonValue(var, jv);
-	}
-	catch(JsonizeError) {
-		return false;
-	}
-	return true;
-}
-
-String sJsonFile(const char *file);
-
-template <class T>
-bool StoreAsJsonFile(const T& var, const char *file = NULL, bool pretty = false)
-{
-	return SaveFile(sJsonFile(file), StoreAsJson(var, pretty));;
-}
-
-template <class T>
-bool LoadFromJsonFile(T& var, const char *file = NULL)
-{
-	return LoadFromJson(var, LoadFile(sJsonFile(file)));
-}
-
-template<> void Jsonize(JsonIO& io, int& var);
-template<> void Jsonize(JsonIO& io, int16& var);
-template<> void Jsonize(JsonIO& io, int64& var);
-template<> void Jsonize(JsonIO& io, double& var);
-template<> void Jsonize(JsonIO& io, bool& var);
-template<> void Jsonize(JsonIO& io, String& var);
-template<> void Jsonize(JsonIO& io, WString& var);
-template<> void Jsonize(JsonIO& io, Date& var);
-template<> void Jsonize(JsonIO& io, Time& var);
-
-template <class T, class V>
-void JsonizeArray(JsonIO& io, T& array)
-{
-	if(io.IsLoading()) {
-		const Value& va = io.Get();
-		array.SetCount(va.GetCount());
-		for(int i = 0; i < va.GetCount(); i++) {
-			JsonIO jio(va[i]);
-			Jsonize(jio, array[i]);
-		}
-	}
-	else {
-		Vector<Value> va;
-		va.SetCount(array.GetCount());
-		for(int i = 0; i < array.GetCount(); i++) {
-			JsonIO jio;
-			Jsonize(jio, array[i]);
-			jio.Put(va[i]);
-		}
-		io.Set(ValueArray(va));
-	}
-}
-
-template <class T>
-void Jsonize(JsonIO& io, Vector<T>& var)
-{
-	JsonizeArray<Vector<T>, T>(io, var);
-}
-
-template <class T>
-void Jsonize(JsonIO& io, Array<T>& var)
-{
-	JsonizeArray<Array<T>, T>(io, var);
-}
-
-template <class T, class K, class V>
-void JsonizeMap(JsonIO& io, T& map, const char *keyid, const char *valueid)
-{
-	if(io.IsLoading()) {
-		map.Clear();
-		const Value& va = io.Get();
-		map.Reserve(va.GetCount());
-		for(int i = 0; i < va.GetCount(); i++) {
-			K key;
-			V value;
-			LoadFromJsonValue(key, va[i][keyid]);
-			LoadFromJsonValue(value, va[i][valueid]);	
-			map.Add(key, value);
-		}
-	}
-	else {
-		Vector<Value> va;
-		va.SetCount(map.GetCount());
-		for(int i = 0; i < map.GetCount(); i++)
-			if(!map.IsUnlinked(i)) {
-				ValueMap item;
-				item.Add(keyid, StoreAsJsonValue(map.GetKey(i)));
-				item.Add(valueid, StoreAsJsonValue(map[i]));
-				va[i] = item;
-			}
-		io.Set(ValueArray(va));
-	}
-}
-
-template <class K, class V, class H>
-void Jsonize(JsonIO& io, VectorMap<K, V, H>& map)
-{
-	JsonizeMap<VectorMap<K, V, H>, K, V>(io, map, "key", "value");
-}
-
-template <class K, class V, class H>
-void Jsonize(JsonIO& io, ArrayMap<K, V, H>& map)
-{
-	JsonizeMap<ArrayMap<K, V, H>, K, V>(io, map, "key", "value");
-}
-
-template <class T, class K, class V>
-void JsonizeStringMap(JsonIO& io, T& map)
-{
-	if(io.IsLoading()) {
-		map.Clear();
-		const ValueMap& va = io.Get();
-		map.Reserve(va.GetCount());
-		for(int i = 0; i < va.GetCount(); i++) {
-			V value;
-			String key = va.GetKey(i);
-			LoadFromJsonValue(key, va.GetKey(i));
-			LoadFromJsonValue(value, va.GetValue(i));	
-			map.Add(key, value);
-		}
-	}
-	else {
-		Index<Value>  index;
-		Vector<Value> values;
-		index.Reserve(map.GetCount());
-		values.Reserve(map.GetCount());
-		for (int i=0; i<map.GetCount(); ++i)
-		{
-			index.Add(StoreAsJsonValue(map.GetKey(i)));
-			values.Add(StoreAsJsonValue(map[i]));
-		}
-		ValueMap vm(index, values);
-		io.Set(vm);
-	}
-}
-
-template <class K, class V, class H>
-void StringMap(JsonIO& io, VectorMap<K, V, H>& map)
-{
-	JsonizeStringMap<VectorMap<K, V, H>, K, V>(io, map);
-}
-
-template <class K, class V, class H>
-void StringMap(JsonIO& io, ArrayMap<K, V, H>& map)
-{
-	JsonizeStringMap<ArrayMap<K, V, H>, K, V>(io, map);
-}
-
-template <class T, class V>
-void JsonizeIndex(JsonIO& io, T& index)
-{
-	if(io.IsLoading()) {
-		const Value& va = io.Get();
-		index.Reserve(va.GetCount());
-		for(int i = 0; i < va.GetCount(); i++) {
-			V v;
-			LoadFromJsonValue(v, va[i]);
-			index.Add(v);
-		}
-	}
-	else {
-		Vector<Value> va;
-		for(int i = 0; i < index.GetCount(); i++)
-			if(!index.IsUnlinked(i))
-				va.Add(StoreAsJsonValue(index[i]));
-		io.Set(ValueArray(va));
-	}
-}
-
-template <class T>
-void Jsonize(JsonIO& io, Index<T>& var)
-{
-	JsonizeIndex<Index<T>, T>(io, var);
-}
-
-template <class T>
-void Jsonize(JsonIO& io, ArrayIndex<T>& var)
-{
-	JsonizeIndex<ArrayIndex<T>, T>(io, var);
-}
-
-template <class T>
-void JsonizeBySerialize(JsonIO& jio, T& x)
-{
-	String h;
-	if(jio.IsStoring())
-	   h = HexString(StoreAsString(x));
-	jio("data", h);
-	if(jio.IsLoading())
-		try {
-			LoadFromString(x, ScanHexString(h));
-		}
-		catch(LoadingError) {
-			throw JsonizeError("jsonize by serialize error");
-		}
-}
+Value  ParseJSON(CParser& p);
+Value  ParseJSON(const char *s);
+
+inline String AsJSON(int i)             { return IsNull(i) ? "null" : AsString(i); }
+inline String AsJSON(double n)          { return IsNull(n) ? "null" : AsString(n); }
+inline String AsJSON(bool b)            { return b ? "true" : "false"; }
+inline String AsJSON(const String& s)   { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
+inline String AsJSON(const WString& s)  { return AsCString(s.ToString(), INT_MAX, NULL, ASCSTRING_JSON); }
+inline String AsJSON(const char *s)     { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
+
+String AsJSON(const Value& v, const String& indent, bool pretty);
+String AsJSON(const Value& v, bool pretty = false);
+
+class JsonArray;
+
+class Json {
+	String text;
+
+public:
+	Json& CatRaw(const char *key, const String& val);
+
+	String ToString() const                                     { return "{" + text + "}"; }
+	String operator~() const                                    { return ToString(); }
+	operator String() const                                     { return ToString(); }
+
+	operator bool() const                                       { return text.GetCount(); }
+	
+	Json& operator()(const char *key, const Value& value)       { return CatRaw(key, AsJSON(value)); }
+	Json& operator()(const char *key, int i)                    { return CatRaw(key, AsJSON(i)); }
+	Json& operator()(const char *key, double n)                 { return CatRaw(key, AsJSON(n)); }
+	Json& operator()(const char *key, bool b)                   { return CatRaw(key, AsJSON(b)); }
+	Json& operator()(const char *key, const String& s)          { return CatRaw(key, AsJSON(s)); }
+	Json& operator()(const char *key, const WString& s)         { return CatRaw(key, AsJSON(s)); }
+	Json& operator()(const char *key, const char *s)            { return CatRaw(key, AsJSON(s)); }
+	Json& operator()(const char *key, const Json& object)       { return CatRaw(key, ~object); }
+	Json& operator()(const char *key, const JsonArray& array);
+		
+	Json() {}
+	Json(const char *key, const Value& value)                   { CatRaw(key, AsJSON(value)); }
+	Json(const char *key, int i)                                { CatRaw(key, AsJSON(i)); }
+	Json(const char *key, double n)                             { CatRaw(key, AsJSON(n)); }
+	Json(const char *key, bool b)                               { CatRaw(key, AsJSON(b)); }
+	Json(const char *key, const String& s)                      { CatRaw(key, AsJSON(s)); }
+	Json(const char *key, const WString& s)                     { CatRaw(key, AsJSON(s)); }
+	Json(const char *key, const char *s)                        { CatRaw(key, AsJSON(s)); }
+	Json(const char *key, const Json& object)                   { CatRaw(key, ~object); }
+	Json(const char *key, const JsonArray& array)               { operator()(key, array); }
+};
+
+class JsonArray {
+	String text;
+
+public:
+	JsonArray& CatRaw(const String& val);
+
+	String ToString() const                                     { return "[" + text + "]"; }
+	String operator~() const                                    { return ToString(); }
+	operator String() const                                     { return ToString(); }
+	
+	operator bool() const                                       { return text.GetCount(); }
+	
+	JsonArray& operator<<(const Value& value)                   { return CatRaw(AsJSON(value)); }
+	JsonArray& operator<<(int i)                                { return CatRaw(AsJSON(i)); }
+	JsonArray& operator<<(double n)                             { return CatRaw(AsJSON(n)); }
+	JsonArray& operator<<(bool b)                               { return CatRaw(AsJSON(b)); }
+	JsonArray& operator<<(const String& s)                      { return CatRaw(AsJSON(s)); }
+	JsonArray& operator<<(const WString& s)                     { return CatRaw(AsJSON(s)); }
+	JsonArray& operator<<(const char *s)                        { return CatRaw(AsJSON(s)); }
+	JsonArray& operator<<(const Json& object)                   { return CatRaw(~object); }
+	JsonArray& operator<<(const JsonArray& array)               { return CatRaw(~array); }
+		
+	JsonArray() {}
+};
+
+inline Json& Json::operator()(const char *key, const JsonArray& array)
+{
+	return CatRaw(key, array);
+}
+
+class JsonIO {
+	const Value   *src;
+	One<ValueMap>  map;
+	Value          tgt;
+
+public:
+	bool IsLoading() const                       { return src; }
+	bool IsStoring() const                       { return !src; }
+	
+	const Value& Get() const                     { ASSERT(IsLoading()); return *src; }
+	void         Set(const Value& v)             { ASSERT(IsStoring() && !map); tgt = v; }
+
+	void         Put(Value& v)                   { ASSERT(IsStoring()); if(map) v = *map; else v = tgt; }
+	Value        GetResult() const               { ASSERT(IsStoring()); return map ? Value(*map) : tgt; }
+
+	template <class T>
+	JsonIO& operator()(const char *key, T& value);
+	
+	JsonIO(const Value& src) : src(&src)         {}
+	JsonIO()                                     { src = NULL; }
+};
+
+struct JsonizeError : Exc {
+	JsonizeError(const String& s) : Exc(s) {}
+};
+
+template <class T>
+void Jsonize(JsonIO& io, T& var)
+{
+	var.Jsonize(io);
+}
+
+template <class T>
+JsonIO& JsonIO::operator()(const char *key, T& value)
+{
+	if(IsLoading()) {
+		const Value& v = (*src)[key];
+		if(!v.IsVoid()) {
+			JsonIO jio(v);
+			Jsonize(jio, value);
+		}
+	}
+	else {
+		ASSERT(tgt.IsVoid());
+		if(!map)
+			map.Create();
+		JsonIO jio;
+		Jsonize(jio, value);
+		if(jio.map)
+			map->Add(key, *jio.map);
+		else
+			map->Add(key, jio.tgt);
+	}
+	return *this;
+}
+
+template <class T>
+Value StoreAsJsonValue(const T& var)
+{
+	JsonIO io;
+	Jsonize(io, const_cast<T&>(var));
+	return io.GetResult();
+}
+
+template <class T>
+void LoadFromJsonValue(T& var, const Value& x)
+{
+	JsonIO io(x);
+	Jsonize(io, var);
+}
+
+template <class T>
+String StoreAsJson(const T& var, bool pretty = false)
+{
+	return AsJSON(StoreAsJsonValue(var), pretty);
+}
+
+template <class T>
+bool LoadFromJson(T& var, const char *json)
+{
+	try {
+		Value jv = ParseJSON(json);
+		if(jv.IsError())
+			return false;
+		LoadFromJsonValue(var, jv);
+	}
+	catch(JsonizeError) {
+		return false;
+	}
+	return true;
+}
+
+String sJsonFile(const char *file);
+
+template <class T>
+bool StoreAsJsonFile(const T& var, const char *file = NULL, bool pretty = false)
+{
+	return SaveFile(sJsonFile(file), StoreAsJson(var, pretty));;
+}
+
+template <class T>
+bool LoadFromJsonFile(T& var, const char *file = NULL)
+{
+	return LoadFromJson(var, LoadFile(sJsonFile(file)));
+}
+
+template<> void Jsonize(JsonIO& io, int& var);
+template<> void Jsonize(JsonIO& io, int16& var);
+template<> void Jsonize(JsonIO& io, int64& var);
+template<> void Jsonize(JsonIO& io, double& var);
+template<> void Jsonize(JsonIO& io, bool& var);
+template<> void Jsonize(JsonIO& io, String& var);
+template<> void Jsonize(JsonIO& io, WString& var);
+template<> void Jsonize(JsonIO& io, Date& var);
+template<> void Jsonize(JsonIO& io, Time& var);
+
+template <class T, class V>
+void JsonizeArray(JsonIO& io, T& array)
+{
+	if(io.IsLoading()) {
+		const Value& va = io.Get();
+		array.SetCount(va.GetCount());
+		for(int i = 0; i < va.GetCount(); i++) {
+			JsonIO jio(va[i]);
+			Jsonize(jio, array[i]);
+		}
+	}
+	else {
+		Vector<Value> va;
+		va.SetCount(array.GetCount());
+		for(int i = 0; i < array.GetCount(); i++) {
+			JsonIO jio;
+			Jsonize(jio, array[i]);
+			jio.Put(va[i]);
+		}
+		io.Set(ValueArray(va));
+	}
+}
+
+template <class T, class K, class V>
+void JsonizeMap(JsonIO& io, T& map, const char *keyid, const char *valueid)
+{
+	if(io.IsLoading()) {
+		map.Clear();
+		const Value& va = io.Get();
+		map.Reserve(va.GetCount());
+		for(int i = 0; i < va.GetCount(); i++) {
+			K key;
+			V value;
+			LoadFromJsonValue(key, va[i][keyid]);
+			LoadFromJsonValue(value, va[i][valueid]);	
+			map.Add(key, value);
+		}
+	}
+	else {
+		Vector<Value> va;
+		va.SetCount(map.GetCount());
+		for(int i = 0; i < map.GetCount(); i++)
+			if(!map.IsUnlinked(i)) {
+				ValueMap item;
+				item.Add(keyid, StoreAsJsonValue(map.GetKey(i)));
+				item.Add(valueid, StoreAsJsonValue(map[i]));
+				va[i] = item;
+			}
+		io.Set(ValueArray(va));
+	}
+}
+
+template <class T, class K, class V>
+void JsonizeStringMap(JsonIO& io, T& map)
+{
+	if(io.IsLoading()) {
+		map.Clear();
+		const ValueMap& va = io.Get();
+		map.Reserve(va.GetCount());
+		for(int i = 0; i < va.GetCount(); i++) {
+			V value;
+			String key = va.GetKey(i);
+			LoadFromJsonValue(key, va.GetKey(i));
+			LoadFromJsonValue(value, va.GetValue(i));	
+			map.Add(key, value);
+		}
+	}
+	else {
+		Index<Value>  index;
+		Vector<Value> values;
+		index.Reserve(map.GetCount());
+		values.Reserve(map.GetCount());
+		for (int i=0; i<map.GetCount(); ++i)
+		{
+			index.Add(StoreAsJsonValue(map.GetKey(i)));
+			values.Add(StoreAsJsonValue(map[i]));
+		}
+		ValueMap vm(index, values);
+		io.Set(vm);
+	}
+}
+
+template <class K, class V, class H>
+void StringMap(JsonIO& io, VectorMap<K, V, H>& map)
+{
+	JsonizeStringMap<VectorMap<K, V, H>, K, V>(io, map);
+}
+
+template <class K, class V, class H>
+void StringMap(JsonIO& io, ArrayMap<K, V, H>& map)
+{
+	JsonizeStringMap<ArrayMap<K, V, H>, K, V>(io, map);
+}
+
+template <class T, class V>
+void JsonizeIndex(JsonIO& io, T& index)
+{
+	if(io.IsLoading()) {
+		const Value& va = io.Get();
+		index.Reserve(va.GetCount());
+		for(int i = 0; i < va.GetCount(); i++) {
+			V v;
+			LoadFromJsonValue(v, va[i]);
+			index.Add(v);
+		}
+	}
+	else {
+		Vector<Value> va;
+		for(int i = 0; i < index.GetCount(); i++)
+			if(!index.IsUnlinked(i))
+				va.Add(StoreAsJsonValue(index[i]));
+		io.Set(ValueArray(va));
+	}
+}
+
+template <class T>
+void JsonizeBySerialize(JsonIO& jio, T& x)
+{
+	String h;
+	if(jio.IsStoring())
+	   h = HexString(StoreAsString(x));
+	jio("data", h);
+	if(jio.IsLoading())
+		try {
+			LoadFromString(x, ScanHexString(h));
+		}
+		catch(LoadingError) {
+			throw JsonizeError("jsonize by serialize error");
+		}
+}
diff --git a/uppsrc/Core/Map.h b/uppsrc/Core/Map.h
index 5c6b82d91..dff7f80c9 100644
--- a/uppsrc/Core/Map.h
+++ b/uppsrc/Core/Map.h
@@ -89,6 +89,8 @@ public:
 
 #ifdef UPP
 	void     Serialize(Stream& s);
+	void     Xmlize(XmlIO& xio);
+	void     Jsonize(JsonIO& jio);
 #endif
 
 	void     Swap(AMap& x)                         { UPP::Swap(value, x.value);
diff --git a/uppsrc/Core/Vcont.h b/uppsrc/Core/Vcont.h
index 8e53bcd2e..c7ee3b658 100644
--- a/uppsrc/Core/Vcont.h
+++ b/uppsrc/Core/Vcont.h
@@ -95,6 +95,8 @@ public:
 
 #ifdef UPP
 	void     Serialize(Stream& s)    { StreamContainer(s, *this); }
+	void     Xmlize(XmlIO& xio, const char *itemtag = "item");
+	void     Jsonize(JsonIO& jio);
 #endif
 
 	Vector()                         { vector = NULL; items = alloc = 0; }
@@ -228,6 +230,8 @@ public:
 
 #ifdef UPP
 	void     Serialize(Stream& s)       { StreamContainer(s, *this); }
+	void     Xmlize(XmlIO& xio, const char *itemtag = "item");
+	void     Jsonize(JsonIO& jio);
 #endif
 
 	Array()                             {}
diff --git a/uppsrc/Core/Vcont.hpp b/uppsrc/Core/Vcont.hpp
index a79f74065..cca395612 100644
--- a/uppsrc/Core/Vcont.hpp
+++ b/uppsrc/Core/Vcont.hpp
@@ -324,6 +324,20 @@ void Vector<T>::Set(int i, const T& x, int count) {
 	}
 }
 
+#ifdef UPP
+template <class T>
+void Vector<T>::Xmlize(XmlIO& xio, const char *itemtag)
+{
+	XmlizeContainer(xio, itemtag, *this);
+}
+
+template <class T>
+void Vector<T>::Jsonize(JsonIO& jio)
+{
+	JsonizeArray<Vector<T>, T>(jio, *this);
+}
+#endif
+
 // ------------------
 
 template <class T>
@@ -475,6 +489,20 @@ void Array<T>::Insert(int i, const Array& x, int offset, int count) {
 		vector[q + i] = DeepCopyNew(x[q + offset]);
 }
 
+#ifdef UPP
+template <class T>
+void Array<T>::Xmlize(XmlIO& xio, const char *itemtag)
+{
+	XmlizeContainer(xio, itemtag, *this);
+}
+
+template <class T>
+void Array<T>::Jsonize(JsonIO& jio)
+{
+	JsonizeArray<Array<T>, T>(jio, *this);
+}
+#endif
+
 // ------------------
 
 template <class T, int NBLK>
diff --git a/uppsrc/Core/Xmlize.cpp b/uppsrc/Core/Xmlize.cpp
index 5f1ae38c7..fdde3347a 100644
--- a/uppsrc/Core/Xmlize.cpp
+++ b/uppsrc/Core/Xmlize.cpp
@@ -172,9 +172,7 @@ void XmlizeLang(XmlIO& xml, const char *tag, int& lang, const char *id)
 
 String StoreAsXML(Callback1<XmlIO> xmlize, const char *name)
 {
-	String n = Filter(name, CharFilterAlpha);
-	if(IsNull(n))
-		n = "app";
+	String n = Filter(name ? name : "app", CharFilterAlpha);
 	XmlNode node;
 	xmlize(XmlIO(node(n), false, Value()));
 	return AsXML(node);
diff --git a/uppsrc/Core/Xmlize.h b/uppsrc/Core/Xmlize.h
index 6c6defc99..ca97afad9 100644
--- a/uppsrc/Core/Xmlize.h
+++ b/uppsrc/Core/Xmlize.h
@@ -74,7 +74,7 @@ void Xmlize(XmlIO& xml, T& var)
 template <class T>
 void Xmlize(XmlIO& xml, const char* itemtag, T& var)
 {
-	var.Xmlize(xml);
+	var.Xmlize(xml, itemtag);
 }
 
 template <class T> XmlIO XmlIO::operator()(const char *tag, T& var) {
@@ -146,30 +146,6 @@ void XmlizeContainer(XmlIO& xml, const char *tag, T& data)
 	}
 }
 
-template<class T>
-void Xmlize(XmlIO& xml, Vector<T>& data)
-{
-	XmlizeContainer(xml, "item", data);
-}
-
-template<class T>
-void Xmlize(XmlIO& xml, const char* itemtag, Vector<T>& data)
-{
-	XmlizeContainer(xml, itemtag, data);
-}
-
-template<class T>
-void Xmlize(XmlIO& xml, Array<T>& data)
-{
-	XmlizeContainer(xml, "item", data);
-}
-
-template<class T>
-void Xmlize(XmlIO& xml, const char* itemtag, Array<T>& data)
-{
-	XmlizeContainer(xml, itemtag, data);
-}
-
 template<class T>
 void XmlizeStore(XmlIO& xml, const T& data)
 {
@@ -202,18 +178,6 @@ void XmlizeMap(XmlIO& xml, const char *keytag, const char *valuetag, T& data)
 	}
 }
 
-template<class K, class V, class H>
-void Xmlize(XmlIO& xml, VectorMap<K, V, H>& data)
-{
-	XmlizeMap<K, V>(xml, "key", "value", data);
-}
-
-template<class K, class V, class H>
-void Xmlize(XmlIO& xml, ArrayMap<K, V, H>& data)
-{
-	XmlizeMap<K, V>(xml, "key", "value", data);
-}
-
 template<class K, class T>
 void XmlizeIndex(XmlIO& xml, const char *keytag, T& data)
 {
@@ -240,18 +204,6 @@ void XmlizeIndex(XmlIO& xml, const char *keytag, T& data)
 	}
 }
 
-template<class K, class H>
-void Xmlize(XmlIO& xml, Index<K, H>& data)
-{
-	XmlizeIndex<K>(xml, "key", data);
-}
-
-template<class K, class H>
-void Xmlize(XmlIO& xml, ArrayIndex<K, H>& data)
-{
-	XmlizeIndex<K>(xml, "key", data);
-}
-
 template <class T>
 struct ParamHelper__ {
 	T&   data;
diff --git a/uppsrc/Core/src.tpp/Jsonize$en-us.tpp b/uppsrc/Core/src.tpp/Jsonize$en-us.tpp
index 3cd30bd53..1e215f429 100644
--- a/uppsrc/Core/src.tpp/Jsonize$en-us.tpp
+++ b/uppsrc/Core/src.tpp/Jsonize$en-us.tpp
@@ -139,26 +139,6 @@ sonIO][@(0.0.255) `&]_[*@3 io], [@(0.0.255) bool`&]_[*@3 var])&]
 sonIO][@(0.0.255) `&]_[*@3 io], [_^Date^ Date][@(0.0.255) `&]_[*@3 var])&]
 [s5;:Jsonize`(JsonIO`&`,Time`&`): [@(0.0.255) template]_<>_[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ J
 sonIO][@(0.0.255) `&]_[*@3 io], [_^Time^ Time][@(0.0.255) `&]_[*@3 var])&]
-[s5;:Jsonize`(JsonIO`&`,Vector`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>
-_[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], 
-[_^Vector^ Vector]<[*@4 T]>`&_[*@3 var])&]
-[s5;:Jsonize`(JsonIO`&`,Array`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_
-[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], 
-[_^Array^ Array]<[*@4 T]>`&_[*@3 var])&]
-[s5;:Jsonize`(JsonIO`&`,Index`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_
-[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], 
-[_^Index^ Index]<[*@4 T]>`&_[*@3 var])&]
-[s5;:Jsonize`(JsonIO`&`,ArrayIndex`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T
-]>_[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], 
-[_^ArrayIndex^ ArrayIndex]<[*@4 T]>`&_[*@3 var])&]
-[s5;:Jsonize`(JsonIO`&`,VectorMap`<K`,V`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) clas
-s]_[*@4 K], [@(0.0.255) class]_[*@4 V], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Jsoniz
-e]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], [_^VectorMap^ VectorMap]<[*@4 K], 
-[*@4 V], [*@4 H]>`&_[*@3 var])&]
-[s5;:Jsonize`(JsonIO`&`,ArrayMap`<K`,V`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class
-]_[*@4 K], [@(0.0.255) class]_[*@4 V], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Jsonize
-]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], [_^ArrayMap^ ArrayMap]<[*@4 K], 
-[*@4 V], [*@4 H]>`&_[*@3 var])&]
 [s2; Provides Jsonize template specialization to support [*@3 var] 
 data type.&]
 [s3; &]
diff --git a/uppsrc/Core/src.tpp/XmlIO$en-us.tpp b/uppsrc/Core/src.tpp/XmlIO$en-us.tpp
index 31a968a93..c0503221b 100644
--- a/uppsrc/Core/src.tpp/XmlIO$en-us.tpp
+++ b/uppsrc/Core/src.tpp/XmlIO$en-us.tpp
@@ -270,30 +270,6 @@ mlIO][@(0.0.255) `&]_[*@3 xml], [_^int16^ int16][@(0.0.255) `&]_[*@3 var])&]
 mlIO][@(0.0.255) `&]_[*@3 xml], [_^int64^ int64][@(0.0.255) `&]_[*@3 var])&]
 [s5;:Xmlize`(XmlIO`&`,byte`&`): [@(0.0.255) template]_<>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ X
 mlIO][@(0.0.255) `&]_[*@3 xml], [_^byte^ byte][@(0.0.255) `&]_[*@3 var])&]
-[s5;:Xmlize`(XmlIO`&`,Vector`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_[@(0.0.255) v
-oid]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml], [_^Vector^ Vector]<[*@4 T]>`&_[*@3 d
-ata])&]
-[s5;:Xmlize`(XmlIO`&`,const char`*`,Vector`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) c
-lass]_[*@4 T]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml], 
-[@(0.0.255) const]_[@(0.0.255) char`*]_[*@3 itemtag], [_^Vector^ Vector]<[*@4 T]>`&_[*@3 data
-])&]
-[s5;:Xmlize`(XmlIO`&`,Array`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_[@(0.0.255) v
-oid]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml], [_^Array^ Array]<[*@4 T]>`&_[*@3 dat
-a])&]
-[s5;:Xmlize`(XmlIO`&`,const char`*`,Array`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) cl
-ass]_[*@4 T]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml], 
-[@(0.0.255) const]_[@(0.0.255) char`*]_[*@3 itemtag], [_^Array^ Array]<[*@4 T]>`&_[*@3 data])
-&]
-[s5;:Xmlize`(XmlIO`&`,ArrayMap`<K`,V`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_
-[*@4 K], [@(0.0.255) class]_[*@4 V], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ X
-mlIO][@(0.0.255) `&]_[*@3 xml], [_^ArrayMap^ ArrayMap]<[*@4 K], [*@4 V], 
-[*@4 H]>`&_[*@3 data])&]
-[s5;:Xmlize`(XmlIO`&`,Index`<K`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 K],
- [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 x
-ml], [_^Index^ Index]<[*@4 K], [*@4 H]>`&_[*@3 data])&]
-[s5;:Xmlize`(XmlIO`&`,ArrayIndex`<K`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 K
-], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 x
-ml], [_^ArrayIndex^ ArrayIndex]<[*@4 K], [*@4 H]>`&_[*@3 data])&]
 [s2; Provides template specialization to support Xmlization of [*@3 var] 
 data types.&]
 [s3;%% &]