Project import
diff --git a/jsoncpp/AUTHORS b/jsoncpp/AUTHORS
new file mode 100644
index 0000000..c0fbbee
--- /dev/null
+++ b/jsoncpp/AUTHORS
@@ -0,0 +1 @@
+Baptiste Lepilleur <blep@users.sourceforge.net>
diff --git a/jsoncpp/Android.mk b/jsoncpp/Android.mk
new file mode 100644
index 0000000..310f09d
--- /dev/null
+++ b/jsoncpp/Android.mk
@@ -0,0 +1,57 @@
+BASE_PATH := $(call my-dir)
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	src/lib_json/json_reader.cpp \
+	chromium-overrides/src/lib_json/json_value.cpp \
+	src/lib_json/json_writer.cpp
+
+LOCAL_C_INCLUDES:= \
+	$(LOCAL_PATH)/chromium-overrides/include \
+	$(LOCAL_PATH)/include \
+	$(LOCAL_PATH)/src/lib_json
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := \
+	$(LOCAL_PATH)/chromium-overrides/include \
+	$(LOCAL_PATH)/include
+
+LOCAL_CFLAGS := \
+	-DJSON_USE_EXCEPTION=0
+
+LOCAL_MODULE_TAGS := \
+	tests
+
+LOCAL_MODULE := \
+	libjsoncpp
+
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+        chromium-overrides/src/lib_json/json_value.cpp \
+        src/lib_json/json_writer.cpp
+
+LOCAL_C_INCLUDES:= \
+        $(LOCAL_PATH)/chromium-overrides/include \
+        $(LOCAL_PATH)/include \
+        $(LOCAL_PATH)/src/lib_json
+
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := \
+        $(LOCAL_PATH)/chromium-overrides/include \
+        $(LOCAL_PATH)/include
+
+LOCAL_CFLAGS := \
+        -DJSON_USE_EXCEPTION=0
+LOCAL_CFLAGS += -std=c++11
+
+LOCAL_MODULE_TAGS := \
+        tests
+
+LOCAL_MODULE := \
+        libjsoncppwriter
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/jsoncpp/LICENSE b/jsoncpp/LICENSE
new file mode 100644
index 0000000..ca2bfe1
--- /dev/null
+++ b/jsoncpp/LICENSE
@@ -0,0 +1,55 @@
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
diff --git a/jsoncpp/MODULE_LICENSE_MIT b/jsoncpp/MODULE_LICENSE_MIT
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/jsoncpp/MODULE_LICENSE_MIT
diff --git a/jsoncpp/NEWS.txt b/jsoncpp/NEWS.txt
new file mode 100644
index 0000000..8316ff6
--- /dev/null
+++ b/jsoncpp/NEWS.txt
@@ -0,0 +1,143 @@
+New in SVN
+----------
+
+ *  Updated the type system's behavior, in order to better support backwards
+    compatibility with code that was written before 64-bit integer support was
+    introduced. Here's how it works now:
+
+     *  isInt, isInt64, isUInt, and isUInt64 return true if and only if the
+        value can be exactly represented as that type. In particular, a value
+        constructed with a double like 17.0 will now return true for all of
+        these methods.
+
+     *  isDouble and isFloat now return true for all numeric values, since all
+        numeric values can be converted to a double or float without
+        truncation. Note however that the conversion may not be exact -- for
+        example, doubles cannot exactly represent all integers above 2^53 + 1.
+
+     *  isBool, isNull, isString, isArray, and isObject now return true if and
+        only if the value is of that type.
+
+     *  isConvertibleTo(fooValue) indicates that it is safe to call asFoo.
+        (For each type foo, isFoo always implies isConvertibleTo(fooValue).)
+        asFoo returns an approximate or exact representation as appropriate.
+        For example, a double value may be truncated when asInt is called.
+
+     *  For backwards compatibility with old code, isConvertibleTo(intValue)
+        may return false even if type() == intValue. This is because the value
+        may have been constructed with a 64-bit integer larger than maxInt,
+        and calling asInt() would cause an exception. If you're writing new
+        code, use isInt64 to find out whether the value is exactly
+        representable using an Int64, or asDouble() combined with minInt64 and
+        maxInt64 to figure out whether it is approximately representable.
+
+
+  New in JsonCpp 0.6.0:
+  ---------------------
+
+* Compilation
+
+  - LD_LIBRARY_PATH and LIBRARY_PATH environment variables are now 
+    propagated to the build environment as this is required for some 
+    compiler installation.
+
+  - Added support for Microsoft Visual Studio 2008 (bug #2930462): 
+    The platform "msvc90" has been added.
+
+    Notes: you need to setup the environment by running vcvars32.bat 
+    (e.g. MSVC 2008 command prompt in start menu) before running scons.
+    
+  - Added support for amalgamated source and header generation (a la sqlite).
+    Refer to README.txt section "Generating amalgamated source and header"
+    for detail.
+    
+* Value
+
+  - Removed experimental ValueAllocator, it caused static 
+    initialization/destruction order issues (bug #2934500). 
+    The DefaultValueAllocator has been inlined in code.
+    
+  - Added support for 64 bits integer:
+  
+    Types Json::Int64 and Json::UInt64 have been added. They are aliased
+	to 64 bits integers on system that support them (based on __int64 on 
+	Microsoft Visual Studio platform, and long long on other platforms).
+	
+	Types Json::LargestInt and Json::LargestUInt have been added. They are
+	aliased to the largest integer type supported: 
+	either Json::Int/Json::UInt or Json::Int64/Json::UInt64 respectively.
+	
+	Json::Value::asInt() and Json::Value::asUInt() still returns plain
+	"int" based types, but asserts if an attempt is made to retrieve
+	a 64 bits value that can not represented as the return type.
+	
+	Json::Value::asInt64() and Json::Value::asUInt64() have been added
+	to obtain the 64 bits integer value.
+	
+	Json::Value::asLargestInt() and Json::Value::asLargestUInt() returns
+	the integer as a LargestInt/LargestUInt respectively. Those functions
+	functions are typically used when implementing writer.
+	
+	The reader attempts to read number as 64 bits integer, and fall back
+	to reading a double if the number is not in the range of 64 bits 
+	integer.
+    
+    Warning: Json::Value::asInt() and Json::Value::asUInt() now returns
+    long long. This changes break code that was passing the return value
+    to *printf() function.
+  
+    Support for 64 bits integer can be disabled by defining the macro 
+	JSON_NO_INT64 (uncomment it in json/config.h for example), though
+	it should have no impact on existing usage.
+    
+  - The type Json::ArrayIndex is used for indexes of a JSON value array. It
+    is an unsigned int (typically 32 bits).
+	
+  - Array index can be passed as int to operator[], allowing use of literal:
+    Json::Value array;
+	array.append( 1234 );
+	int value = array[0].asInt();  // did not compile previously
+
+  - Added float Json::Value::asFloat() to obtain a floating point value as a
+    float (avoid lost of precision warning caused by used of asDouble() 
+    to initialize a float).
+
+* Reader
+
+  - Renamed Reader::getFormatedErrorMessages() to getFormattedErrorMessages.
+    Bug #3023708 (Formatted has 2 't'). The old member function is deprecated
+    but still present for backward compatibility.
+    
+* Tests
+
+  - Added test to ensure that the escape sequence "\/" is corrected handled 
+    by the parser.
+
+* Bug fixes
+
+  - Bug #3139677: JSON [1 2 3] was incorrectly parsed as [1, 3]. Error is now 
+    correctly detected.
+    
+  - Bug #3139678: stack buffer overflow when parsing a double with a
+    length of 32 characters.
+	
+  - Fixed Value::operator <= implementation (had the semantic of operator >=).
+    Found when adding unit tests for comparison operators.
+    
+  - Value::compare() is now const and has an actual implementation with
+    unit tests.
+
+  - Bug #2407932: strpbrk() can fail for NULL pointer.
+
+  - Bug #3306345: Fixed minor typo in Path::resolve().
+
+  - Bug #3314841/#3306896: errors in amalgamate.py
+
+  - Fixed some Coverity warnings and line-endings.
+    
+* License
+  
+  - See file LICENSE for details. Basically JsonCpp is now licensed under 
+    MIT license, or public domain if desired and recognized in your jurisdiction.
+    Thanks to Stephan G. Beal [http://wanderinghorse.net/home/stephan/]) who
+	helped figuring out the solution to the public domain issue.
diff --git a/jsoncpp/NOTICE b/jsoncpp/NOTICE
new file mode 100644
index 0000000..ca2bfe1
--- /dev/null
+++ b/jsoncpp/NOTICE
@@ -0,0 +1,55 @@
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
diff --git a/jsoncpp/README.txt b/jsoncpp/README.txt
new file mode 100644
index 0000000..88c1178
--- /dev/null
+++ b/jsoncpp/README.txt
@@ -0,0 +1,173 @@
+* Introduction:
+  =============
+
+JSON (JavaScript Object Notation) is a lightweight data-interchange format. 
+It can represent integer, real number, string, an ordered sequence of 
+value, and a collection of name/value pairs.
+
+JsonCpp (http://jsoncpp.sourceforge.net/) is a simple API to manipulate 
+JSON value, handle serialization and unserialization to string.
+
+It can also preserve existing comment in unserialization/serialization steps,
+making it a convenient format to store user input files.
+
+Unserialization parsing is user friendly and provides precise error reports.
+
+
+* Building/Testing:
+  =================
+
+JsonCpp uses Scons (http://www.scons.org) as a build system. Scons requires
+python to be installed (http://www.python.org).
+
+You download scons-local distribution from the following url:
+http://sourceforge.net/projects/scons/files/scons-local/1.2.0/
+
+Unzip it in the directory where you found this README file. scons.py Should be 
+at the same level as README.
+
+python scons.py platform=PLTFRM [TARGET]
+where PLTFRM may be one of:
+	suncc Sun C++ (Solaris)
+	vacpp Visual Age C++ (AIX)
+	mingw 
+	msvc6 Microsoft Visual Studio 6 service pack 5-6
+	msvc70 Microsoft Visual Studio 2002
+	msvc71 Microsoft Visual Studio 2003
+	msvc80 Microsoft Visual Studio 2005
+	msvc90 Microsoft Visual Studio 2008
+	linux-gcc Gnu C++ (linux, also reported to work for Mac OS X)
+
+Notes: if you are building with Microsoft Visual Studio 2008, you need to 
+setup the environment by running vcvars32.bat (e.g. MSVC 2008 command prompt)
+before running scons.
+	
+Adding platform is fairly simple. You need to change the Sconstruct file 
+to do so.
+	
+and TARGET may be:
+	check: build library and run unit tests.
+
+    
+* Running the test manually:
+  ==========================
+
+Notes that test can be run by scons using the 'check' target (see above).
+
+You need to run test manually only if you are troubleshooting an issue.
+
+In the instruction below, replace "path to jsontest.exe" with the path
+of the 'jsontest' executable that was compiled on your platform.
+  
+cd test
+# This will run the Reader/Writer tests
+python runjsontests.py "path to jsontest.exe"
+
+# This will run the Reader/Writer tests, using JSONChecker test suite
+# (http://www.json.org/JSON_checker/).
+# Notes: not all tests pass: JsonCpp is too lenient (for example,
+# it allows an integer to start with '0'). The goal is to improve
+# strict mode parsing to get all tests to pass.
+python runjsontests.py --with-json-checker "path to jsontest.exe"
+
+# This will run the unit tests (mostly Value)
+python rununittests.py "path to test_lib_json.exe"
+
+You can run the tests using valgrind:
+python rununittests.py --valgrind "path to test_lib_json.exe"
+
+
+* Building the documentation:
+  ===========================
+
+Run the python script doxybuild.py from the top directory:
+
+python doxybuild.py --open --with-dot
+
+See doxybuild.py --help for options. 
+
+Notes that the documentation is also available for download as a tarball. 
+The documentation of the latest release is available online at:
+http://jsoncpp.sourceforge.net/
+
+* Generating amalgamated source and header
+  ========================================
+
+JsonCpp is provided with a script to generate a single header and a single
+source file to ease inclusion in an existing project.
+
+The amalgamated source can be generated at any time by running the following
+command from the top-directory (requires python 2.6):
+
+python amalgamate.py
+
+It is possible to specify header name. See -h options for detail. By default,
+the following files are generated:
+- dist/jsoncpp.cpp: source file that need to be added to your project
+- dist/json/json.h: header file corresponding to use in your project. It is
+equivalent to including json/json.h in non-amalgamated source. This header
+only depends on standard headers. 
+- dist/json/json-forwards.h: header the provides forward declaration
+of all JsonCpp types. This typically what should be included in headers to
+speed-up compilation.
+
+The amalgamated sources are generated by concatenating JsonCpp source in the
+correct order and defining macro JSON_IS_AMALGAMATION to prevent inclusion
+of other headers.
+
+* Using json-cpp in your project:
+  ===============================
+
+include/ should be added to your compiler include path. jsoncpp headers 
+should be included as follow:
+
+#include <json/json.h>
+  
+
+* Adding a reader/writer test:
+  ============================
+
+To add a test, you need to create two files in test/data:
+- a TESTNAME.json file, that contains the input document in JSON format.
+- a TESTNAME.expected file, that contains a flatened representation of 
+  the input document.
+  
+TESTNAME.expected file format:
+- each line represents a JSON element of the element tree represented 
+  by the input document.
+- each line has two parts: the path to access the element separated from
+  the element value by '='. Array and object values are always empty 
+  (e.g. represented by either [] or {}).
+- element path: '.' represented the root element, and is used to separate 
+  object members. [N] is used to specify the value of an array element
+  at index N.
+See test_complex_01.json and test_complex_01.expected to better understand
+element path.
+
+
+* Understanding reader/writer test output:
+  ========================================
+
+When a test is run, output files are generated aside the input test files. 
+Below is a short description of the content of each file:
+
+- test_complex_01.json: input JSON document
+- test_complex_01.expected: flattened JSON element tree used to check if 
+    parsing was corrected.
+
+- test_complex_01.actual: flattened JSON element tree produced by 
+    jsontest.exe from reading test_complex_01.json
+- test_complex_01.rewrite: JSON document written by jsontest.exe using the
+    Json::Value parsed from test_complex_01.json and serialized using
+    Json::StyledWritter.
+- test_complex_01.actual-rewrite: flattened JSON element tree produced by 
+    jsontest.exe from reading test_complex_01.rewrite.
+test_complex_01.process-output: jsontest.exe output, typically useful to
+    understand parsing error.
+
+* License
+  =======
+  
+See file LICENSE for details. Basically JsonCpp is licensed under 
+MIT license, or public domain if desired and recognized in your jurisdiction.
+
diff --git a/jsoncpp/SConstruct b/jsoncpp/SConstruct
new file mode 100644
index 0000000..23225cb
--- /dev/null
+++ b/jsoncpp/SConstruct
@@ -0,0 +1,248 @@
+"""
+Notes: 
+- shared library support is buggy: it assumes that a static and dynamic library can be build from the same object files. This is not true on many platforms. For this reason it is only enabled on linux-gcc at the current time.
+
+To add a platform:
+- add its name in options allowed_values below
+- add tool initialization for this platform. Search for "if platform == 'suncc'" as an example.
+"""
+
+import os
+import os.path
+import sys
+
+JSONCPP_VERSION = open(File('#version').abspath,'rt').read().strip()
+DIST_DIR = '#dist'
+
+options = Variables()
+options.Add( EnumVariable('platform',
+                        'Platform (compiler/stl) used to build the project',
+                        'msvc71',
+                        allowed_values='suncc vacpp mingw msvc6 msvc7 msvc71 msvc80 msvc90 linux-gcc'.split(),
+                        ignorecase=2) )
+
+try:
+    platform = ARGUMENTS['platform']
+    if platform == 'linux-gcc':
+        CXX = 'g++' # not quite right, but env is not yet available.
+        import commands
+        version = commands.getoutput('%s -dumpversion' %CXX)
+        platform = 'linux-gcc-%s' %version
+        print "Using platform '%s'" %platform
+        LD_LIBRARY_PATH = os.environ.get('LD_LIBRARY_PATH', '')
+        LD_LIBRARY_PATH = "%s:libs/%s" %(LD_LIBRARY_PATH, platform)
+        os.environ['LD_LIBRARY_PATH'] = LD_LIBRARY_PATH
+        print "LD_LIBRARY_PATH =", LD_LIBRARY_PATH
+except KeyError:
+    print 'You must specify a "platform"'
+    sys.exit(2)
+
+print "Building using PLATFORM =", platform
+
+rootbuild_dir = Dir('#buildscons')
+build_dir = os.path.join( '#buildscons', platform )
+bin_dir = os.path.join( '#bin', platform )
+lib_dir = os.path.join( '#libs', platform )
+sconsign_dir_path = Dir(build_dir).abspath
+sconsign_path = os.path.join( sconsign_dir_path, '.sconsign.dbm' )
+
+# Ensure build directory exist (SConsignFile fail otherwise!)
+if not os.path.exists( sconsign_dir_path ):
+    os.makedirs( sconsign_dir_path )
+
+# Store all dependencies signature in a database
+SConsignFile( sconsign_path )
+
+def make_environ_vars():
+	"""Returns a dictionnary with environment variable to use when compiling."""
+	# PATH is required to find the compiler
+	# TEMP is required for at least mingw
+    # LD_LIBRARY_PATH & co is required on some system for the compiler
+	vars = {}
+	for name in ('PATH', 'TEMP', 'TMP', 'LD_LIBRARY_PATH', 'LIBRARY_PATH'):
+		if name in os.environ:
+			vars[name] = os.environ[name]
+	return vars
+	
+
+env = Environment( ENV = make_environ_vars(),
+                   toolpath = ['scons-tools'],
+                   tools=[] ) #, tools=['default'] )
+
+if platform == 'suncc':
+    env.Tool( 'sunc++' )
+    env.Tool( 'sunlink' )
+    env.Tool( 'sunar' )
+    env.Append( CCFLAGS = ['-mt'] )
+elif platform == 'vacpp':
+    env.Tool( 'default' )
+    env.Tool( 'aixcc' )
+    env['CXX'] = 'xlC_r'   #scons does not pick-up the correct one !
+    # using xlC_r ensure multi-threading is enabled:
+    # http://publib.boulder.ibm.com/infocenter/pseries/index.jsp?topic=/com.ibm.vacpp7a.doc/compiler/ref/cuselect.htm
+    env.Append( CCFLAGS = '-qrtti=all',
+                LINKFLAGS='-bh:5' )  # -bh:5 remove duplicate symbol warning
+elif platform == 'msvc6':
+    env['MSVS_VERSION']='6.0'
+    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
+        env.Tool( tool )
+    env['CXXFLAGS']='-GR -GX /nologo /MT'
+elif platform == 'msvc70':
+    env['MSVS_VERSION']='7.0'
+    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
+        env.Tool( tool )
+    env['CXXFLAGS']='-GR -GX /nologo /MT'
+elif platform == 'msvc71':
+    env['MSVS_VERSION']='7.1'
+    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
+        env.Tool( tool )
+    env['CXXFLAGS']='-GR -GX /nologo /MT'
+elif platform == 'msvc80':
+    env['MSVS_VERSION']='8.0'
+    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
+        env.Tool( tool )
+    env['CXXFLAGS']='-GR -EHsc /nologo /MT'
+elif platform == 'msvc90':
+    env['MSVS_VERSION']='9.0'
+    # Scons 1.2 fails to detect the correct location of the platform SDK.
+    # So we propagate those from the environment. This requires that the
+    # user run vcvars32.bat before compiling.
+    if 'INCLUDE' in os.environ:
+        env['ENV']['INCLUDE'] = os.environ['INCLUDE']
+    if 'LIB' in os.environ:
+        env['ENV']['LIB'] = os.environ['LIB']
+    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
+        env.Tool( tool )
+    env['CXXFLAGS']='-GR -EHsc /nologo /MT'
+elif platform == 'mingw':
+    env.Tool( 'mingw' )
+    env.Append( CPPDEFINES=[ "WIN32", "NDEBUG", "_MT" ] )
+elif platform.startswith('linux-gcc'):
+    env.Tool( 'default' )
+    env.Append( LIBS = ['pthread'], CCFLAGS = "-Wall" )
+    env['SHARED_LIB_ENABLED'] = True
+else:
+    print "UNSUPPORTED PLATFORM."
+    env.Exit(1)
+
+env.Tool('targz')
+env.Tool('srcdist')
+env.Tool('globtool')
+
+env.Append( CPPPATH = ['#include'],
+            LIBPATH = lib_dir )
+short_platform = platform
+if short_platform.startswith('msvc'):
+    short_platform = short_platform[2:]
+# Notes: on Windows you need to rebuild the source for each variant
+# Build script does not support that yet so we only build static libraries.
+# This also fails on AIX because both dynamic and static library ends with
+# extension .a.
+env['SHARED_LIB_ENABLED'] = env.get('SHARED_LIB_ENABLED', False)
+env['LIB_PLATFORM'] = short_platform
+env['LIB_LINK_TYPE'] = 'lib'    # static
+env['LIB_CRUNTIME'] = 'mt'
+env['LIB_NAME_SUFFIX'] = '${LIB_PLATFORM}_${LIB_LINK_TYPE}${LIB_CRUNTIME}'  # must match autolink naming convention
+env['JSONCPP_VERSION'] = JSONCPP_VERSION
+env['BUILD_DIR'] = env.Dir(build_dir)
+env['ROOTBUILD_DIR'] = env.Dir(rootbuild_dir)
+env['DIST_DIR'] = DIST_DIR
+if 'TarGz' in env['BUILDERS']:
+	class SrcDistAdder:
+		def __init__( self, env ):
+			self.env = env
+		def __call__( self, *args, **kw ):
+			apply( self.env.SrcDist, (self.env['SRCDIST_TARGET'],) + args, kw )
+	env['SRCDIST_BUILDER'] = env.TarGz
+else: # If tarfile module is missing
+	class SrcDistAdder:
+		def __init__( self, env ):
+			pass
+		def __call__( self, *args, **kw ):
+			pass
+env['SRCDIST_ADD'] = SrcDistAdder( env )
+env['SRCDIST_TARGET'] = os.path.join( DIST_DIR, 'jsoncpp-src-%s.tar.gz' % env['JSONCPP_VERSION'] )
+                      
+env_testing = env.Clone( )
+env_testing.Append( LIBS = ['json_${LIB_NAME_SUFFIX}'] )
+
+def buildJSONExample( env, target_sources, target_name ):
+    env = env.Clone()
+    env.Append( CPPPATH = ['#'] )
+    exe = env.Program( target=target_name,
+                       source=target_sources )
+    env['SRCDIST_ADD']( source=[target_sources] )
+    global bin_dir
+    return env.Install( bin_dir, exe )
+
+def buildJSONTests( env, target_sources, target_name ):
+    jsontests_node = buildJSONExample( env, target_sources, target_name )
+    check_alias_target = env.Alias( 'check', jsontests_node, RunJSONTests( jsontests_node, jsontests_node ) )
+    env.AlwaysBuild( check_alias_target )
+
+def buildUnitTests( env, target_sources, target_name ):
+    jsontests_node = buildJSONExample( env, target_sources, target_name )
+    check_alias_target = env.Alias( 'check', jsontests_node, 
+                                    RunUnitTests( jsontests_node, jsontests_node ) )
+    env.AlwaysBuild( check_alias_target )
+
+def buildLibrary( env, target_sources, target_name ):
+    static_lib = env.StaticLibrary( target=target_name + '_${LIB_NAME_SUFFIX}',
+                                    source=target_sources )
+    global lib_dir
+    env.Install( lib_dir, static_lib )
+    if env['SHARED_LIB_ENABLED']:
+        shared_lib = env.SharedLibrary( target=target_name + '_${LIB_NAME_SUFFIX}',
+                                        source=target_sources )
+        env.Install( lib_dir, shared_lib )
+    env['SRCDIST_ADD']( source=[target_sources] )
+
+Export( 'env env_testing buildJSONExample buildLibrary buildJSONTests buildUnitTests' )
+
+def buildProjectInDirectory( target_directory ):
+    global build_dir
+    target_build_dir = os.path.join( build_dir, target_directory )
+    target = os.path.join( target_directory, 'sconscript' )
+    SConscript( target, build_dir=target_build_dir, duplicate=0 )
+    env['SRCDIST_ADD']( source=[target] )
+
+
+def runJSONTests_action( target, source = None, env = None ):
+    # Add test scripts to python path
+    jsontest_path = Dir( '#test' ).abspath
+    sys.path.insert( 0, jsontest_path )
+    data_path = os.path.join( jsontest_path, 'data' )
+    import runjsontests
+    return runjsontests.runAllTests( os.path.abspath(source[0].path), data_path )
+
+def runJSONTests_string( target, source = None, env = None ):
+    return 'RunJSONTests("%s")' % source[0]
+
+import SCons.Action
+ActionFactory = SCons.Action.ActionFactory
+RunJSONTests = ActionFactory(runJSONTests_action, runJSONTests_string )
+
+def runUnitTests_action( target, source = None, env = None ):
+    # Add test scripts to python path
+    jsontest_path = Dir( '#test' ).abspath
+    sys.path.insert( 0, jsontest_path )
+    import rununittests
+    return rununittests.runAllTests( os.path.abspath(source[0].path) )
+
+def runUnitTests_string( target, source = None, env = None ):
+    return 'RunUnitTests("%s")' % source[0]
+
+RunUnitTests = ActionFactory(runUnitTests_action, runUnitTests_string )
+
+env.Alias( 'check' )
+
+srcdist_cmd = env['SRCDIST_ADD']( source = """
+    AUTHORS README.txt SConstruct
+    """.split() )
+env.Alias( 'src-dist', srcdist_cmd )
+
+buildProjectInDirectory( 'src/jsontestrunner' )
+buildProjectInDirectory( 'src/lib_json' )
+buildProjectInDirectory( 'src/test_lib_json' )
+#print env.Dump()
+
diff --git a/jsoncpp/amalgamate.py b/jsoncpp/amalgamate.py
new file mode 100644
index 0000000..eab724f
--- /dev/null
+++ b/jsoncpp/amalgamate.py
@@ -0,0 +1,148 @@
+"""Amalgate json-cpp library sources into a single source and header file.
+
+Requires Python 2.6
+
+Example of invocation (must be invoked from json-cpp top directory):
+python amalgate.py
+"""
+import os
+import os.path
+import sys
+
+class AmalgamationFile:
+    def __init__( self, top_dir ):
+        self.top_dir = top_dir
+        self.blocks = []
+
+    def add_text( self, text ):
+        if not text.endswith( '\n' ):
+            text += '\n'
+        self.blocks.append( text )
+
+    def add_file( self, relative_input_path, wrap_in_comment=False ):
+        def add_marker( prefix ):
+            self.add_text( '' )
+            self.add_text( '// ' + '/'*70 )
+            self.add_text( '// %s of content of file: %s' % (prefix, relative_input_path.replace('\\','/')) )
+            self.add_text( '// ' + '/'*70 )
+            self.add_text( '' )
+        add_marker( 'Beginning' )
+        f = open( os.path.join( self.top_dir, relative_input_path ), 'rt' )
+        content = f.read()
+        if wrap_in_comment:
+            content = '/*\n' + content + '\n*/'
+        self.add_text( content )
+        f.close()
+        add_marker( 'End' )
+        self.add_text( '\n\n\n\n' )
+
+    def get_value( self ):
+        return ''.join( self.blocks ).replace('\r\n','\n')
+
+    def write_to( self, output_path ):
+        output_dir = os.path.dirname( output_path )
+        if output_dir and not os.path.isdir( output_dir ):
+            os.makedirs( output_dir )
+        f = open( output_path, 'wb' )
+        f.write( self.get_value() )
+        f.close()
+
+def amalgamate_source( source_top_dir=None,
+                       target_source_path=None,
+                       header_include_path=None ):
+    """Produces amalgated source.
+       Parameters:
+           source_top_dir: top-directory
+           target_source_path: output .cpp path
+           header_include_path: generated header path relative to target_source_path.
+    """
+    print 'Amalgating header...'
+    header = AmalgamationFile( source_top_dir )
+    header.add_text( '/// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).' )
+    header.add_text( '/// It is intented to be used with #include <%s>' % header_include_path )
+    header.add_file( 'LICENSE', wrap_in_comment=True )
+    header.add_text( '#ifndef JSON_AMALGATED_H_INCLUDED' )
+    header.add_text( '# define JSON_AMALGATED_H_INCLUDED' )
+    header.add_text( '/// If defined, indicates that the source file is amalgated' )
+    header.add_text( '/// to prevent private header inclusion.' )
+    header.add_text( '#define JSON_IS_AMALGAMATION' )
+    header.add_file( 'include/json/config.h' )
+    header.add_file( 'include/json/forwards.h' )
+    header.add_file( 'include/json/features.h' )
+    header.add_file( 'include/json/value.h' )
+    header.add_file( 'include/json/reader.h' )
+    header.add_file( 'include/json/writer.h' )
+    header.add_text( '#endif //ifndef JSON_AMALGATED_H_INCLUDED' )
+
+    target_header_path = os.path.join( os.path.dirname(target_source_path), header_include_path )
+    print 'Writing amalgated header to %r' % target_header_path
+    header.write_to( target_header_path )
+
+    base, ext = os.path.splitext( header_include_path )
+    forward_header_include_path = base + '-forwards' + ext
+    print 'Amalgating forward header...'
+    header = AmalgamationFile( source_top_dir )
+    header.add_text( '/// Json-cpp amalgated forward header (http://jsoncpp.sourceforge.net/).' )
+    header.add_text( '/// It is intented to be used with #include <%s>' % forward_header_include_path )
+    header.add_text( '/// This header provides forward declaration for all JsonCpp types.' )
+    header.add_file( 'LICENSE', wrap_in_comment=True )
+    header.add_text( '#ifndef JSON_FORWARD_AMALGATED_H_INCLUDED' )
+    header.add_text( '# define JSON_FORWARD_AMALGATED_H_INCLUDED' )
+    header.add_text( '/// If defined, indicates that the source file is amalgated' )
+    header.add_text( '/// to prevent private header inclusion.' )
+    header.add_text( '#define JSON_IS_AMALGAMATION' )
+    header.add_file( 'include/json/config.h' )
+    header.add_file( 'include/json/forwards.h' )
+    header.add_text( '#endif //ifndef JSON_FORWARD_AMALGATED_H_INCLUDED' )
+
+    target_forward_header_path = os.path.join( os.path.dirname(target_source_path),
+                                               forward_header_include_path )
+    print 'Writing amalgated forward header to %r' % target_forward_header_path
+    header.write_to( target_forward_header_path )
+
+    print 'Amalgating source...'
+    source = AmalgamationFile( source_top_dir )
+    source.add_text( '/// Json-cpp amalgated source (http://jsoncpp.sourceforge.net/).' )
+    source.add_text( '/// It is intented to be used with #include <%s>' % header_include_path )
+    source.add_file( 'LICENSE', wrap_in_comment=True )
+    source.add_text( '' )
+    source.add_text( '#include <%s>' % header_include_path )
+    source.add_text( '' )
+    lib_json = 'src/lib_json'
+    source.add_file( os.path.join(lib_json, 'json_tool.h') )
+    source.add_file( os.path.join(lib_json, 'json_reader.cpp') )
+    source.add_file( os.path.join(lib_json, 'json_batchallocator.h') )
+    source.add_file( os.path.join(lib_json, 'json_valueiterator.inl') )
+    source.add_file( os.path.join(lib_json, 'json_value.cpp') )
+    source.add_file( os.path.join(lib_json, 'json_writer.cpp') )
+
+    print 'Writing amalgated source to %r' % target_source_path
+    source.write_to( target_source_path )
+
+def main():
+    usage = """%prog [options]
+Generate a single amalgated source and header file from the sources.
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option('-s', '--source', dest="target_source_path", action='store', default='dist/jsoncpp.cpp',
+        help="""Output .cpp source path. [Default: %default]""")
+    parser.add_option('-i', '--include', dest="header_include_path", action='store', default='json/json.h',
+        help="""Header include path. Used to include the header from the amalgated source file. [Default: %default]""")
+    parser.add_option('-t', '--top-dir', dest="top_dir", action='store', default=os.getcwd(),
+        help="""Source top-directory. [Default: %default]""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+
+    msg = amalgamate_source( source_top_dir=options.top_dir,
+                             target_source_path=options.target_source_path,
+                             header_include_path=options.header_include_path )
+    if msg:
+        sys.stderr.write( msg + '\n' )
+        sys.exit( 1 )
+    else:
+        print 'Source succesfully amalagated'
+ 
+if __name__ == '__main__':
+    main()
diff --git a/jsoncpp/chromium-overrides/LICENSE b/jsoncpp/chromium-overrides/LICENSE
new file mode 100644
index 0000000..ca2bfe1
--- /dev/null
+++ b/jsoncpp/chromium-overrides/LICENSE
@@ -0,0 +1,55 @@
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
diff --git a/jsoncpp/chromium-overrides/include/json/value.h b/jsoncpp/chromium-overrides/include/json/value.h
new file mode 100644
index 0000000..a7d7c07
--- /dev/null
+++ b/jsoncpp/chromium-overrides/include/json/value.h
@@ -0,0 +1,1109 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_H_INCLUDED
+# define CPPTL_JSON_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "json/forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+# include <string>
+# include <vector>
+
+# ifndef JSON_USE_CPPTL_SMALLMAP
+#  include <map>
+# else
+#  include <cpptl/smallmap.h>
+# endif
+# ifdef JSON_USE_CPPTL
+#  include <cpptl/forwards.h>
+# endif
+
+/** \brief JSON (JavaScript Object Notation).
+ */
+namespace Json {
+
+   /** \brief Type of the value held by a Value object.
+    */
+   enum ValueType
+   {
+      nullValue = 0, ///< 'null' value
+      intValue,      ///< signed integer value
+      uintValue,     ///< unsigned integer value
+      realValue,     ///< double value
+      stringValue,   ///< UTF-8 string value
+      booleanValue,  ///< bool value
+      arrayValue,    ///< array value (ordered list)
+      objectValue    ///< object value (collection of name/value pairs).
+   };
+
+   enum CommentPlacement
+   {
+      commentBefore = 0,        ///< a comment placed on the line before a value
+      commentAfterOnSameLine,   ///< a comment just after a value on the same line
+      commentAfter,             ///< a comment on the line after a value (only make sense for root value)
+      numberOfCommentPlacement
+   };
+
+//# ifdef JSON_USE_CPPTL
+//   typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
+//   typedef CppTL::AnyEnumerator<const Value &> EnumValues;
+//# endif
+
+   /** \brief Lightweight wrapper to tag static string.
+    *
+    * Value constructor and objectValue member assignement takes advantage of the
+    * StaticString and avoid the cost of string duplication when storing the
+    * string or the member name.
+    *
+    * Example of usage:
+    * \code
+    * Json::Value aValue( StaticString("some text") );
+    * Json::Value object;
+    * static const StaticString code("code");
+    * object[code] = 1234;
+    * \endcode
+    */
+   class JSON_API StaticString
+   {
+   public:
+      explicit StaticString( const char *czstring )
+         : str_( czstring )
+      {
+      }
+
+      operator const char *() const
+      {
+         return str_;
+      }
+
+      const char *c_str() const
+      {
+         return str_;
+      }
+
+   private:
+      const char *str_;
+   };
+
+   /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
+    *
+    * This class is a discriminated union wrapper that can represents a:
+    * - signed integer [range: Value::minInt - Value::maxInt]
+    * - unsigned integer (range: 0 - Value::maxUInt)
+    * - double
+    * - UTF-8 string
+    * - boolean
+    * - 'null'
+    * - an ordered list of Value
+    * - collection of name/value pairs (javascript object)
+    *
+    * The type of the held value is represented by a #ValueType and 
+    * can be obtained using type().
+    *
+    * values of an #objectValue or #arrayValue can be accessed using operator[]() methods. 
+    * Non const methods will automatically create the a #nullValue element 
+    * if it does not exist. 
+    * The sequence of an #arrayValue will be automatically resize and initialized 
+    * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+    *
+    * The get() methods can be used to obtanis default value in the case the required element
+    * does not exist.
+    *
+    * It is possible to iterate over the list of a #objectValue values using 
+    * the getMemberNames() method.
+    */
+   class JSON_API Value 
+   {
+      friend class ValueIteratorBase;
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      friend class ValueInternalLink;
+      friend class ValueInternalMap;
+# endif
+   public:
+      typedef std::vector<std::string> Members;
+      typedef ValueIterator iterator;
+      typedef ValueConstIterator const_iterator;
+      typedef Json::UInt UInt;
+      typedef Json::Int Int;
+# if defined(JSON_HAS_INT64)
+      typedef Json::UInt64 UInt64;
+      typedef Json::Int64 Int64;
+#endif // defined(JSON_HAS_INT64)
+      typedef Json::LargestInt LargestInt;
+      typedef Json::LargestUInt LargestUInt;
+      typedef Json::ArrayIndex ArrayIndex;
+
+      static const Value& null;
+      /// Minimum signed integer value that can be stored in a Json::Value.
+      static const LargestInt minLargestInt;
+      /// Maximum signed integer value that can be stored in a Json::Value.
+      static const LargestInt maxLargestInt;
+      /// Maximum unsigned integer value that can be stored in a Json::Value.
+      static const LargestUInt maxLargestUInt;
+
+      /// Minimum signed int value that can be stored in a Json::Value.
+      static const Int minInt;
+      /// Maximum signed int value that can be stored in a Json::Value.
+      static const Int maxInt;
+      /// Maximum unsigned int value that can be stored in a Json::Value.
+      static const UInt maxUInt;
+
+# if defined(JSON_HAS_INT64)
+      /// Minimum signed 64 bits int value that can be stored in a Json::Value.
+      static const Int64 minInt64;
+      /// Maximum signed 64 bits int value that can be stored in a Json::Value.
+      static const Int64 maxInt64;
+      /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
+      static const UInt64 maxUInt64;
+#endif // defined(JSON_HAS_INT64)
+
+   private:
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+# ifndef JSON_VALUE_USE_INTERNAL_MAP
+      class CZString 
+      {
+      public:
+         enum DuplicationPolicy 
+         {
+            noDuplication = 0,
+            duplicate,
+            duplicateOnCopy
+         };
+         CZString( ArrayIndex index );
+         CZString( const char *cstr, DuplicationPolicy allocate );
+         CZString( const CZString &other );
+         ~CZString();
+         CZString &operator =( const CZString &other );
+         bool operator<( const CZString &other ) const;
+         bool operator==( const CZString &other ) const;
+         ArrayIndex index() const;
+         const char *c_str() const;
+         bool isStaticString() const;
+      private:
+         void swap( CZString &other );
+         const char *cstr_;
+         ArrayIndex index_;
+      };
+
+   public:
+#  ifndef JSON_USE_CPPTL_SMALLMAP
+      typedef std::map<CZString, Value> ObjectValues;
+#  else
+      typedef CppTL::SmallMap<CZString, Value> ObjectValues;
+#  endif // ifndef JSON_USE_CPPTL_SMALLMAP
+# endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
+#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+   public:
+      /** \brief Create a default Value of the given type.
+
+        This is a very useful constructor.
+        To create an empty array, pass arrayValue.
+        To create an empty object, pass objectValue.
+        Another Value can then be set to this one by assignment.
+    This is useful since clear() and resize() will not alter types.
+
+        Examples:
+    \code
+    Json::Value null_value; // null
+    Json::Value arr_value(Json::arrayValue); // []
+    Json::Value obj_value(Json::objectValue); // {}
+    \endcode
+      */
+      Value( ValueType type = nullValue );
+      Value( Int value );
+      Value( UInt value );
+#if defined(JSON_HAS_INT64)
+      Value( Int64 value );
+      Value( UInt64 value );
+#endif // if defined(JSON_HAS_INT64)
+      Value( double value );
+      Value( const char *value );
+      Value( const char *beginValue, const char *endValue );
+      /** \brief Constructs a value from a static string.
+
+       * Like other value string constructor but do not duplicate the string for
+       * internal storage. The given string must remain alive after the call to this
+       * constructor.
+       * Example of usage:
+       * \code
+       * Json::Value aValue( StaticString("some text") );
+       * \endcode
+       */
+      Value( const StaticString &value );
+      Value( const std::string &value );
+# ifdef JSON_USE_CPPTL
+      Value( const CppTL::ConstString &value );
+# endif
+      Value( bool value );
+      Value( const Value &other );
+      ~Value();
+
+      Value &operator=( const Value &other );
+      /// Swap values.
+      /// \note Currently, comments are intentionally not swapped, for
+      /// both logic and efficiency.
+      void swap( Value &other );
+
+      ValueType type() const;
+
+      bool operator <( const Value &other ) const;
+      bool operator <=( const Value &other ) const;
+      bool operator >=( const Value &other ) const;
+      bool operator >( const Value &other ) const;
+
+      bool operator ==( const Value &other ) const;
+      bool operator !=( const Value &other ) const;
+
+      int compare( const Value &other ) const;
+
+      const char *asCString() const;
+      std::string asString() const;
+# ifdef JSON_USE_CPPTL
+      CppTL::ConstString asConstString() const;
+# endif
+      Int asInt() const;
+      UInt asUInt() const;
+#if defined(JSON_HAS_INT64)
+      Int64 asInt64() const;
+      UInt64 asUInt64() const;
+#endif // if defined(JSON_HAS_INT64)
+      LargestInt asLargestInt() const;
+      LargestUInt asLargestUInt() const;
+      float asFloat() const;
+      double asDouble() const;
+      bool asBool() const;
+
+      bool isNull() const;
+      bool isBool() const;
+      bool isInt() const;
+      bool isInt64() const;
+      bool isUInt() const;
+      bool isUInt64() const;
+      bool isIntegral() const;
+      bool isDouble() const;
+      bool isNumeric() const;
+      bool isString() const;
+      bool isArray() const;
+      bool isObject() const;
+
+      bool isConvertibleTo( ValueType other ) const;
+
+      /// Number of values in array or object
+      ArrayIndex size() const;
+
+      /// \brief Return true if empty array, empty object, or null;
+      /// otherwise, false.
+      bool empty() const;
+
+      /// Return isNull()
+      bool operator!() const;
+
+      /// Remove all object members and array elements.
+      /// \pre type() is arrayValue, objectValue, or nullValue
+      /// \post type() is unchanged
+      void clear();
+
+      /// Resize the array to size elements. 
+      /// New elements are initialized to null.
+      /// May only be called on nullValue or arrayValue.
+      /// \pre type() is arrayValue or nullValue
+      /// \post type() is arrayValue
+      void resize( ArrayIndex size );
+
+      /// Access an array element (zero based index ).
+      /// If the array contains less than index element, then null value are inserted
+      /// in the array so that its size is index+1.
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      Value &operator[]( ArrayIndex index );
+
+      /// Access an array element (zero based index ).
+      /// If the array contains less than index element, then null value are inserted
+      /// in the array so that its size is index+1.
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      Value &operator[]( int index );
+
+      /// Access an array element (zero based index )
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      const Value &operator[]( ArrayIndex index ) const;
+
+      /// Access an array element (zero based index )
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      const Value &operator[]( int index ) const;
+
+      /// If the array contains at least index+1 elements, returns the element value, 
+      /// otherwise returns defaultValue.
+      Value get( ArrayIndex index, 
+                 const Value &defaultValue ) const;
+      /// Return true if index < size().
+      bool isValidIndex( ArrayIndex index ) const;
+      /// \brief Append value to array at the end.
+      ///
+      /// Equivalent to jsonvalue[jsonvalue.size()] = value;
+      Value &append( const Value &value );
+
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const char *key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const char *key ) const;
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const std::string &key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const std::string &key ) const;
+      /** \brief Access an object value by name, create a null member if it does not exist.
+
+       * If the object as no entry for that name, then the member name used to store
+       * the new entry is not duplicated.
+       * Example of use:
+       * \code
+       * Json::Value object;
+       * static const StaticString code("code");
+       * object[code] = 1234;
+       * \endcode
+       */
+      Value &operator[]( const StaticString &key );
+# ifdef JSON_USE_CPPTL
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const CppTL::ConstString &key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const CppTL::ConstString &key ) const;
+# endif
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const char *key, 
+                 const Value &defaultValue ) const;
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const std::string &key,
+                 const Value &defaultValue ) const;
+# ifdef JSON_USE_CPPTL
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const CppTL::ConstString &key,
+                 const Value &defaultValue ) const;
+# endif
+      /// \brief Remove and return the named member.  
+      ///
+      /// Do nothing if it did not exist.
+      /// \return the removed Value, or null.
+      /// \pre type() is objectValue or nullValue
+      /// \post type() is unchanged
+      Value removeMember( const char* key );
+      /// Same as removeMember(const char*)
+      Value removeMember( const std::string &key );
+
+      /// Return true if the object has a member named key.
+      bool isMember( const char *key ) const;
+      /// Return true if the object has a member named key.
+      bool isMember( const std::string &key ) const;
+# ifdef JSON_USE_CPPTL
+      /// Return true if the object has a member named key.
+      bool isMember( const CppTL::ConstString &key ) const;
+# endif
+
+      /// \brief Return a list of the member names.
+      ///
+      /// If null, return an empty list.
+      /// \pre type() is objectValue or nullValue
+      /// \post if type() was nullValue, it remains nullValue
+      Members getMemberNames() const;
+
+//# ifdef JSON_USE_CPPTL
+//      EnumMemberNames enumMemberNames() const;
+//      EnumValues enumValues() const;
+//# endif
+
+      /// Comments must be //... or /* ... */
+      void setComment( const char *comment,
+                       CommentPlacement placement );
+      /// Comments must be //... or /* ... */
+      void setComment( const std::string &comment,
+                       CommentPlacement placement );
+      bool hasComment( CommentPlacement placement ) const;
+      /// Include delimiters and embedded newlines.
+      std::string getComment( CommentPlacement placement ) const;
+
+      std::string toStyledString() const;
+
+      const_iterator begin() const;
+      const_iterator end() const;
+
+      iterator begin();
+      iterator end();
+
+   private:
+      Value &resolveReference( const char *key, 
+                               bool isStatic );
+
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      inline bool isItemAvailable() const
+      {
+         return itemIsUsed_ == 0;
+      }
+
+      inline void setItemUsed( bool isUsed = true )
+      {
+         itemIsUsed_ = isUsed ? 1 : 0;
+      }
+
+      inline bool isMemberNameStatic() const
+      {
+         return memberNameIsStatic_ == 0;
+      }
+
+      inline void setMemberNameIsStatic( bool isStatic )
+      {
+         memberNameIsStatic_ = isStatic ? 1 : 0;
+      }
+# endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+   private:
+      struct CommentInfo
+      {
+         CommentInfo();
+         ~CommentInfo();
+
+         void setComment( const char *text );
+
+         char *comment_;
+      };
+
+      //struct MemberNamesTransform
+      //{
+      //   typedef const char *result_type;
+      //   const char *operator()( const CZString &name ) const
+      //   {
+      //      return name.c_str();
+      //   }
+      //};
+
+      union ValueHolder
+      {
+         LargestInt int_;
+         LargestUInt uint_;
+         double real_;
+         bool bool_;
+         char *string_;
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+         ValueInternalArray *array_;
+         ValueInternalMap *map_;
+#else
+         ObjectValues *map_;
+# endif
+      } value_;
+      ValueType type_ : 8;
+      int allocated_ : 1;     // Notes: if declared as bool, bitfield is useless.
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      unsigned int itemIsUsed_ : 1;      // used by the ValueInternalMap container.
+      int memberNameIsStatic_ : 1;       // used by the ValueInternalMap container.
+# endif
+      CommentInfo *comments_;
+   };
+
+
+   /** \brief Experimental and untested: represents an element of the "path" to access a node.
+    */
+   class PathArgument
+   {
+   public:
+      friend class Path;
+
+      PathArgument();
+      PathArgument( ArrayIndex index );
+      PathArgument( const char *key );
+      PathArgument( const std::string &key );
+
+   private:
+      enum Kind
+      {
+         kindNone = 0,
+         kindIndex,
+         kindKey
+      };
+      std::string key_;
+      ArrayIndex index_;
+      Kind kind_;
+   };
+
+   /** \brief Experimental and untested: represents a "path" to access a node.
+    *
+    * Syntax:
+    * - "." => root node
+    * - ".[n]" => elements at index 'n' of root node (an array value)
+    * - ".name" => member named 'name' of root node (an object value)
+    * - ".name1.name2.name3"
+    * - ".[0][1][2].name1[3]"
+    * - ".%" => member name is provided as parameter
+    * - ".[%]" => index is provied as parameter
+    */
+   class Path
+   {
+   public:
+      Path( const std::string &path,
+            const PathArgument &a1 = PathArgument(),
+            const PathArgument &a2 = PathArgument(),
+            const PathArgument &a3 = PathArgument(),
+            const PathArgument &a4 = PathArgument(),
+            const PathArgument &a5 = PathArgument() );
+
+      const Value &resolve( const Value &root ) const;
+      Value resolve( const Value &root, 
+                     const Value &defaultValue ) const;
+      /// Creates the "path" to access the specified node and returns a reference on the node.
+      Value &make( Value &root ) const;
+
+   private:
+      typedef std::vector<const PathArgument *> InArgs;
+      typedef std::vector<PathArgument> Args;
+
+      void makePath( const std::string &path,
+                     const InArgs &in );
+      void addPathInArg( const std::string &path, 
+                         const InArgs &in, 
+                         InArgs::const_iterator &itInArg, 
+                         PathArgument::Kind kind );
+      void invalidPath( const std::string &path, 
+                        int location );
+
+      Args args_;
+   };
+
+
+
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   /** \brief Allocator to customize Value internal map.
+    * Below is an example of a simple implementation (default implementation actually
+    * use memory pool for speed).
+    * \code
+      class DefaultValueMapAllocator : public ValueMapAllocator
+      {
+      public: // overridden from ValueMapAllocator
+         virtual ValueInternalMap *newMap()
+         {
+            return new ValueInternalMap();
+         }
+
+         virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
+         {
+            return new ValueInternalMap( other );
+         }
+
+         virtual void destructMap( ValueInternalMap *map )
+         {
+            delete map;
+         }
+
+         virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+         {
+            return new ValueInternalLink[size];
+         }
+
+         virtual void releaseMapBuckets( ValueInternalLink *links )
+         {
+            delete [] links;
+         }
+
+         virtual ValueInternalLink *allocateMapLink()
+         {
+            return new ValueInternalLink();
+         }
+
+         virtual void releaseMapLink( ValueInternalLink *link )
+         {
+            delete link;
+         }
+      };
+    * \endcode
+    */ 
+   class JSON_API ValueMapAllocator
+   {
+   public:
+      virtual ~ValueMapAllocator();
+      virtual ValueInternalMap *newMap() = 0;
+      virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) = 0;
+      virtual void destructMap( ValueInternalMap *map ) = 0;
+      virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) = 0;
+      virtual void releaseMapBuckets( ValueInternalLink *links ) = 0;
+      virtual ValueInternalLink *allocateMapLink() = 0;
+      virtual void releaseMapLink( ValueInternalLink *link ) = 0;
+   };
+
+   /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
+    * \internal previous_ & next_ allows for bidirectional traversal.
+    */
+   class JSON_API ValueInternalLink
+   {
+   public:
+      enum { itemPerLink = 6 };  // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
+      enum InternalFlags { 
+         flagAvailable = 0,
+         flagUsed = 1
+      };
+
+      ValueInternalLink();
+
+      ~ValueInternalLink();
+
+      Value items_[itemPerLink];
+      char *keys_[itemPerLink];
+      ValueInternalLink *previous_;
+      ValueInternalLink *next_;
+   };
+
+
+   /** \brief A linked page based hash-table implementation used internally by Value.
+    * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
+    * list in each bucket to handle collision. There is an addional twist in that
+    * each node of the collision linked list is a page containing a fixed amount of
+    * value. This provides a better compromise between memory usage and speed.
+    * 
+    * Each bucket is made up of a chained list of ValueInternalLink. The last
+    * link of a given bucket can be found in the 'previous_' field of the following bucket.
+    * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
+    * Only the last link of a bucket may contains 'available' item. The last link always
+    * contains at least one element unless is it the bucket one very first link.
+    */
+   class JSON_API ValueInternalMap
+   {
+      friend class ValueIteratorBase;
+      friend class Value;
+   public:
+      typedef unsigned int HashKey;
+      typedef unsigned int BucketIndex;
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+      struct IteratorState
+      {
+         IteratorState() 
+            : map_(0)
+            , link_(0)
+            , itemIndex_(0)
+            , bucketIndex_(0) 
+         {
+         }
+         ValueInternalMap *map_;
+         ValueInternalLink *link_;
+         BucketIndex itemIndex_;
+         BucketIndex bucketIndex_;
+      };
+# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+      ValueInternalMap();
+      ValueInternalMap( const ValueInternalMap &other );
+      ValueInternalMap &operator =( const ValueInternalMap &other );
+      ~ValueInternalMap();
+
+      void swap( ValueInternalMap &other );
+
+      BucketIndex size() const;
+
+      void clear();
+
+      bool reserveDelta( BucketIndex growth );
+
+      bool reserve( BucketIndex newItemCount );
+
+      const Value *find( const char *key ) const;
+
+      Value *find( const char *key );
+
+      Value &resolveReference( const char *key, 
+                               bool isStatic );
+
+      void remove( const char *key );
+
+      void doActualRemove( ValueInternalLink *link, 
+                           BucketIndex index,
+                           BucketIndex bucketIndex );
+
+      ValueInternalLink *&getLastLinkInBucket( BucketIndex bucketIndex );
+
+      Value &setNewItem( const char *key, 
+                         bool isStatic, 
+                         ValueInternalLink *link, 
+                         BucketIndex index );
+
+      Value &unsafeAdd( const char *key, 
+                        bool isStatic, 
+                        HashKey hashedKey );
+
+      HashKey hash( const char *key ) const;
+
+      int compare( const ValueInternalMap &other ) const;
+
+   private:
+      void makeBeginIterator( IteratorState &it ) const;
+      void makeEndIterator( IteratorState &it ) const;
+      static bool equals( const IteratorState &x, const IteratorState &other );
+      static void increment( IteratorState &iterator );
+      static void incrementBucket( IteratorState &iterator );
+      static void decrement( IteratorState &iterator );
+      static const char *key( const IteratorState &iterator );
+      static const char *key( const IteratorState &iterator, bool &isStatic );
+      static Value &value( const IteratorState &iterator );
+      static int distance( const IteratorState &x, const IteratorState &y );
+
+   private:
+      ValueInternalLink *buckets_;
+      ValueInternalLink *tailLink_;
+      BucketIndex bucketsSize_;
+      BucketIndex itemCount_;
+   };
+
+   /** \brief A simplified deque implementation used internally by Value.
+   * \internal
+   * It is based on a list of fixed "page", each page contains a fixed number of items.
+   * Instead of using a linked-list, a array of pointer is used for fast item look-up.
+   * Look-up for an element is as follow:
+   * - compute page index: pageIndex = itemIndex / itemsPerPage
+   * - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
+   *
+   * Insertion is amortized constant time (only the array containing the index of pointers
+   * need to be reallocated when items are appended).
+   */
+   class JSON_API ValueInternalArray
+   {
+      friend class Value;
+      friend class ValueIteratorBase;
+   public:
+      enum { itemsPerPage = 8 };    // should be a power of 2 for fast divide and modulo.
+      typedef Value::ArrayIndex ArrayIndex;
+      typedef unsigned int PageIndex;
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+      struct IteratorState // Must be a POD
+      {
+         IteratorState() 
+            : array_(0)
+            , currentPageIndex_(0)
+            , currentItemIndex_(0) 
+         {
+         }
+         ValueInternalArray *array_;
+         Value **currentPageIndex_;
+         unsigned int currentItemIndex_;
+      };
+# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+      ValueInternalArray();
+      ValueInternalArray( const ValueInternalArray &other );
+      ValueInternalArray &operator =( const ValueInternalArray &other );
+      ~ValueInternalArray();
+      void swap( ValueInternalArray &other );
+
+      void clear();
+      void resize( ArrayIndex newSize );
+
+      Value &resolveReference( ArrayIndex index );
+
+      Value *find( ArrayIndex index ) const;
+
+      ArrayIndex size() const;
+
+      int compare( const ValueInternalArray &other ) const;
+
+   private:
+      static bool equals( const IteratorState &x, const IteratorState &other );
+      static void increment( IteratorState &iterator );
+      static void decrement( IteratorState &iterator );
+      static Value &dereference( const IteratorState &iterator );
+      static Value &unsafeDereference( const IteratorState &iterator );
+      static int distance( const IteratorState &x, const IteratorState &y );
+      static ArrayIndex indexOf( const IteratorState &iterator );
+      void makeBeginIterator( IteratorState &it ) const;
+      void makeEndIterator( IteratorState &it ) const;
+      void makeIterator( IteratorState &it, ArrayIndex index ) const;
+
+      void makeIndexValid( ArrayIndex index );
+
+      Value **pages_;
+      ArrayIndex size_;
+      PageIndex pageCount_;
+   };
+
+   /** \brief Experimental: do not use. Allocator to customize Value internal array.
+    * Below is an example of a simple implementation (actual implementation use
+    * memory pool).
+      \code
+class DefaultValueArrayAllocator : public ValueArrayAllocator
+{
+public: // overridden from ValueArrayAllocator
+   virtual ~DefaultValueArrayAllocator()
+   {
+   }
+
+   virtual ValueInternalArray *newArray()
+   {
+      return new ValueInternalArray();
+   }
+
+   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
+   {
+      return new ValueInternalArray( other );
+   }
+
+   virtual void destruct( ValueInternalArray *array )
+   {
+      delete array;
+   }
+
+   virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                          ValueInternalArray::PageIndex &indexCount,
+                                          ValueInternalArray::PageIndex minNewIndexCount )
+   {
+      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
+      if ( minNewIndexCount > newIndexCount )
+         newIndexCount = minNewIndexCount;
+      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
+      if ( !newIndexes )
+         throw std::bad_alloc();
+      indexCount = newIndexCount;
+      indexes = static_cast<Value **>( newIndexes );
+   }
+   virtual void releaseArrayPageIndex( Value **indexes, 
+                                       ValueInternalArray::PageIndex indexCount )
+   {
+      if ( indexes )
+         free( indexes );
+   }
+
+   virtual Value *allocateArrayPage()
+   {
+      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
+   }
+
+   virtual void releaseArrayPage( Value *value )
+   {
+      if ( value )
+         free( value );
+   }
+};
+      \endcode
+    */ 
+   class JSON_API ValueArrayAllocator
+   {
+   public:
+      virtual ~ValueArrayAllocator();
+      virtual ValueInternalArray *newArray() = 0;
+      virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) = 0;
+      virtual void destructArray( ValueInternalArray *array ) = 0;
+      /** \brief Reallocate array page index.
+       * Reallocates an array of pointer on each page.
+       * \param indexes [input] pointer on the current index. May be \c NULL.
+       *                [output] pointer on the new index of at least 
+       *                         \a minNewIndexCount pages. 
+       * \param indexCount [input] current number of pages in the index.
+       *                   [output] number of page the reallocated index can handle.
+       *                            \b MUST be >= \a minNewIndexCount.
+       * \param minNewIndexCount Minimum number of page the new index must be able to
+       *                         handle.
+       */
+      virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                             ValueInternalArray::PageIndex &indexCount,
+                                             ValueInternalArray::PageIndex minNewIndexCount ) = 0;
+      virtual void releaseArrayPageIndex( Value **indexes, 
+                                          ValueInternalArray::PageIndex indexCount ) = 0;
+      virtual Value *allocateArrayPage() = 0;
+      virtual void releaseArrayPage( Value *value ) = 0;
+   };
+#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+
+   /** \brief base class for Value iterators.
+    *
+    */
+   class ValueIteratorBase
+   {
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef ValueIteratorBase SelfType;
+
+      ValueIteratorBase();
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueIteratorBase( const Value::ObjectValues::iterator &current );
+#else
+      ValueIteratorBase( const ValueInternalArray::IteratorState &state );
+      ValueIteratorBase( const ValueInternalMap::IteratorState &state );
+#endif
+
+      bool operator ==( const SelfType &other ) const
+      {
+         return isEqual( other );
+      }
+
+      bool operator !=( const SelfType &other ) const
+      {
+         return !isEqual( other );
+      }
+
+      difference_type operator -( const SelfType &other ) const
+      {
+         return computeDistance( other );
+      }
+
+      /// Return either the index or the member name of the referenced value as a Value.
+      Value key() const;
+
+      /// Return the index of the referenced Value. -1 if it is not an arrayValue.
+      UInt index() const;
+
+      /// Return the member name of the referenced Value. "" if it is not an objectValue.
+      const char *memberName() const;
+
+   protected:
+      Value &deref() const;
+
+      void increment();
+
+      void decrement();
+
+      difference_type computeDistance( const SelfType &other ) const;
+
+      bool isEqual( const SelfType &other ) const;
+
+      void copy( const SelfType &other );
+
+   private:
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      Value::ObjectValues::iterator current_;
+      // Indicates that iterator is for a null value.
+      bool isNull_;
+#else
+      union
+      {
+         ValueInternalArray::IteratorState array_;
+         ValueInternalMap::IteratorState map_;
+      } iterator_;
+      bool isArray_;
+#endif
+   };
+
+   /** \brief const iterator for object and array value.
+    *
+    */
+   class ValueConstIterator : public ValueIteratorBase
+   {
+      friend class Value;
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef const Value &reference;
+      typedef const Value *pointer;
+      typedef ValueConstIterator SelfType;
+
+      ValueConstIterator();
+   private:
+      /*! \internal Use by Value to create an iterator.
+       */
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueConstIterator( const Value::ObjectValues::iterator &current );
+#else
+      ValueConstIterator( const ValueInternalArray::IteratorState &state );
+      ValueConstIterator( const ValueInternalMap::IteratorState &state );
+#endif
+   public:
+      SelfType &operator =( const ValueIteratorBase &other );
+
+      SelfType operator++( int )
+      {
+         SelfType temp( *this );
+         ++*this;
+         return temp;
+      }
+
+      SelfType operator--( int )
+      {
+         SelfType temp( *this );
+         --*this;
+         return temp;
+      }
+
+      SelfType &operator--()
+      {
+         decrement();
+         return *this;
+      }
+
+      SelfType &operator++()
+      {
+         increment();
+         return *this;
+      }
+
+      reference operator *() const
+      {
+         return deref();
+      }
+   };
+
+
+   /** \brief Iterator for object and array value.
+    */
+   class ValueIterator : public ValueIteratorBase
+   {
+      friend class Value;
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef Value &reference;
+      typedef Value *pointer;
+      typedef ValueIterator SelfType;
+
+      ValueIterator();
+      ValueIterator( const ValueConstIterator &other );
+      ValueIterator( const ValueIterator &other );
+   private:
+      /*! \internal Use by Value to create an iterator.
+       */
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueIterator( const Value::ObjectValues::iterator &current );
+#else
+      ValueIterator( const ValueInternalArray::IteratorState &state );
+      ValueIterator( const ValueInternalMap::IteratorState &state );
+#endif
+   public:
+
+      SelfType &operator =( const SelfType &other );
+
+      SelfType operator++( int )
+      {
+         SelfType temp( *this );
+         ++*this;
+         return temp;
+      }
+
+      SelfType operator--( int )
+      {
+         SelfType temp( *this );
+         --*this;
+         return temp;
+      }
+
+      SelfType &operator--()
+      {
+         decrement();
+         return *this;
+      }
+
+      SelfType &operator++()
+      {
+         increment();
+         return *this;
+      }
+
+      reference operator *() const
+      {
+         return deref();
+      }
+   };
+
+
+} // namespace Json
+
+
+#endif // CPPTL_JSON_H_INCLUDED
diff --git a/jsoncpp/chromium-overrides/src/lib_json/json_value.cpp b/jsoncpp/chromium-overrides/src/lib_json/json_value.cpp
new file mode 100644
index 0000000..850724f
--- /dev/null
+++ b/jsoncpp/chromium-overrides/src/lib_json/json_value.cpp
@@ -0,0 +1,1924 @@
+// Copyright 2011 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/assertions.h>
+# include <json/value.h>
+# include <json/writer.h>
+# ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#  include "json_batchallocator.h"
+# endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <math.h>
+#include <sstream>
+#include <utility>
+#include <stdexcept>
+#include <cstring>
+#include <cassert>
+#ifdef JSON_USE_CPPTL
+# include <cpptl/conststring.h>
+#endif
+#include <cstddef>    // size_t
+
+#define JSON_ASSERT_UNREACHABLE assert( false )
+
+namespace Json {
+
+// This is a walkaround to avoid the static initialization of Value::null.
+// const Value Value::null;
+static const unsigned char kNull[sizeof(Value)] = { 0 };
+const Value& Value::null = reinterpret_cast<const Value&>(kNull);
+
+const Int Value::minInt = Int( ~(UInt(-1)/2) );
+const Int Value::maxInt = Int( UInt(-1)/2 );
+const UInt Value::maxUInt = UInt(-1);
+# if defined(JSON_HAS_INT64)
+const Int64 Value::minInt64 = Int64( ~(UInt64(-1)/2) );
+const Int64 Value::maxInt64 = Int64( UInt64(-1)/2 );
+const UInt64 Value::maxUInt64 = UInt64(-1);
+// The constant is hard-coded because some compiler have trouble
+// converting Value::maxUInt64 to a double correctly (AIX/xlC).
+// Assumes that UInt64 is a 64 bits integer.
+static const double maxUInt64AsDouble = 18446744073709551615.0;
+#endif // defined(JSON_HAS_INT64)
+const LargestInt Value::minLargestInt = LargestInt( ~(LargestUInt(-1)/2) );
+const LargestInt Value::maxLargestInt = LargestInt( LargestUInt(-1)/2 );
+const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
+
+
+/// Unknown size marker
+static const unsigned int unknown = (unsigned)-1;
+
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+   return d >= min && d <= max;
+}
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double integerToDouble( Json::UInt64 value )
+{
+    return static_cast<double>( Int64(value/2) ) * 2.0 + Int64(value & 1);
+}
+
+template<typename T>
+static inline double integerToDouble( T value )
+{
+    return static_cast<double>( value );
+}
+
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+   return d >= integerToDouble(min) && d <= integerToDouble(max);
+}
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+
+
+/** Duplicates the specified string value.
+ * @param value Pointer to the string to duplicate. Must be zero-terminated if
+ *              length is "unknown".
+ * @param length Length of the value. if equals to unknown, then it will be
+ *               computed using strlen(value).
+ * @return Pointer on the duplicate instance of string.
+ */
+static inline char *
+duplicateStringValue( const char *value, 
+                      unsigned int length = unknown )
+{
+   if ( length == unknown )
+      length = (unsigned int)strlen(value);
+
+   // Avoid an integer overflow in the call to malloc below by limiting length
+   // to a sane value.
+   if (length >= (unsigned)Value::maxInt)
+      length = Value::maxInt - 1;
+
+   char *newString = static_cast<char *>( malloc( length + 1 ) );
+   JSON_ASSERT_MESSAGE( newString != 0, "Failed to allocate string value buffer" );
+   memcpy( newString, value, length );
+   newString[length] = 0;
+   return newString;
+}
+
+
+/** Free the string duplicated by duplicateStringValue().
+ */
+static inline void 
+releaseStringValue( char *value )
+{
+   if ( value )
+      free( value );
+}
+
+} // namespace Json
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// ValueInternals...
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+#if !defined(JSON_IS_AMALGAMATION)
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+#  include "json_internalarray.inl"
+#  include "json_internalmap.inl"
+# endif // JSON_VALUE_USE_INTERNAL_MAP
+
+# include "json_valueiterator.inl"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::CommentInfo
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+
+Value::CommentInfo::CommentInfo()
+   : comment_( 0 )
+{
+}
+
+Value::CommentInfo::~CommentInfo()
+{
+   if ( comment_ )
+      releaseStringValue( comment_ );
+}
+
+
+void 
+Value::CommentInfo::setComment( const char *text )
+{
+   if ( comment_ )
+      releaseStringValue( comment_ );
+   JSON_ASSERT( text != 0 );
+   JSON_ASSERT_MESSAGE( text[0]=='\0' || text[0]=='/', "Comments must start with /");
+   // It seems that /**/ style comments are acceptable as well.
+   comment_ = duplicateStringValue( text );
+}
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::CZString
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+# ifndef JSON_VALUE_USE_INTERNAL_MAP
+
+// Notes: index_ indicates if the string was allocated when
+// a string is stored.
+
+Value::CZString::CZString( ArrayIndex index )
+   : cstr_( 0 )
+   , index_( index )
+{
+}
+
+Value::CZString::CZString( const char *cstr, DuplicationPolicy allocate )
+   : cstr_( allocate == duplicate ? duplicateStringValue(cstr) 
+                                  : cstr )
+   , index_( allocate )
+{
+}
+
+Value::CZString::CZString( const CZString &other )
+: cstr_( other.index_ != noDuplication &&  other.cstr_ != 0
+                ?  duplicateStringValue( other.cstr_ )
+                : other.cstr_ )
+   , index_( other.cstr_ ? (other.index_ == noDuplication ? noDuplication : duplicate)
+                         : other.index_ )
+{
+}
+
+Value::CZString::~CZString()
+{
+   if ( cstr_  &&  index_ == duplicate )
+      releaseStringValue( const_cast<char *>( cstr_ ) );
+}
+
+void 
+Value::CZString::swap( CZString &other )
+{
+   std::swap( cstr_, other.cstr_ );
+   std::swap( index_, other.index_ );
+}
+
+Value::CZString &
+Value::CZString::operator =( const CZString &other )
+{
+   CZString temp( other );
+   swap( temp );
+   return *this;
+}
+
+bool 
+Value::CZString::operator<( const CZString &other ) const 
+{
+   if ( cstr_ )
+      return strcmp( cstr_, other.cstr_ ) < 0;
+   return index_ < other.index_;
+}
+
+bool 
+Value::CZString::operator==( const CZString &other ) const 
+{
+   if ( cstr_ )
+      return strcmp( cstr_, other.cstr_ ) == 0;
+   return index_ == other.index_;
+}
+
+
+ArrayIndex 
+Value::CZString::index() const
+{
+   return index_;
+}
+
+
+const char *
+Value::CZString::c_str() const
+{
+   return cstr_;
+}
+
+bool 
+Value::CZString::isStaticString() const
+{
+   return index_ == noDuplication;
+}
+
+#endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::Value
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+/*! \internal Default constructor initialization must be equivalent to:
+ * memset( this, 0, sizeof(Value) )
+ * This optimization is used in ValueInternalMap fast allocator.
+ */
+Value::Value( ValueType type )
+   : type_( type )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   switch ( type )
+   {
+   case nullValue:
+      break;
+   case intValue:
+   case uintValue:
+      value_.int_ = 0;
+      break;
+   case realValue:
+      value_.real_ = 0.0;
+      break;
+   case stringValue:
+      value_.string_ = 0;
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_ = new ObjectValues();
+      break;
+#else
+   case arrayValue:
+      value_.array_ = arrayAllocator()->newArray();
+      break;
+   case objectValue:
+      value_.map_ = mapAllocator()->newMap();
+      break;
+#endif
+   case booleanValue:
+      value_.bool_ = false;
+      break;
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+}
+
+
+Value::Value( UInt value )
+   : type_( uintValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.uint_ = value;
+}
+
+Value::Value( Int value )
+   : type_( intValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.int_ = value;
+}
+
+
+# if defined(JSON_HAS_INT64)
+Value::Value( Int64 value )
+   : type_( intValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.int_ = value;
+}
+
+
+Value::Value( UInt64 value )
+   : type_( uintValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.uint_ = value;
+}
+#endif // defined(JSON_HAS_INT64)
+
+Value::Value( double value )
+   : type_( realValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.real_ = value;
+}
+
+Value::Value( const char *value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value );
+}
+
+
+Value::Value( const char *beginValue, 
+              const char *endValue )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( beginValue, 
+                                          (unsigned int)(endValue - beginValue) );
+}
+
+
+Value::Value( const std::string &value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value.c_str(), 
+                                          (unsigned int)value.length() );
+
+}
+
+Value::Value( const StaticString &value )
+   : type_( stringValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = const_cast<char *>( value.c_str() );
+}
+
+
+# ifdef JSON_USE_CPPTL
+Value::Value( const CppTL::ConstString &value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value, value.length() );
+}
+# endif
+
+Value::Value( bool value )
+   : type_( booleanValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.bool_ = value;
+}
+
+
+Value::Value( const Value &other )
+   : type_( other.type_ )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+      value_ = other.value_;
+      break;
+   case stringValue:
+      if ( other.value_.string_ )
+      {
+         value_.string_ = duplicateStringValue( other.value_.string_ );
+         allocated_ = true;
+      }
+      else
+         value_.string_ = 0;
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_ = new ObjectValues( *other.value_.map_ );
+      break;
+#else
+   case arrayValue:
+      value_.array_ = arrayAllocator()->newArrayCopy( *other.value_.array_ );
+      break;
+   case objectValue:
+      value_.map_ = mapAllocator()->newMapCopy( *other.value_.map_ );
+      break;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   if ( other.comments_ )
+   {
+      comments_ = new CommentInfo[numberOfCommentPlacement];
+      for ( int comment =0; comment < numberOfCommentPlacement; ++comment )
+      {
+         const CommentInfo &otherComment = other.comments_[comment];
+         if ( otherComment.comment_ )
+            comments_[comment].setComment( otherComment.comment_ );
+      }
+   }
+}
+
+
+Value::~Value()
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+      break;
+   case stringValue:
+      if ( allocated_ )
+         releaseStringValue( value_.string_ );
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      delete value_.map_;
+      break;
+#else
+   case arrayValue:
+      arrayAllocator()->destructArray( value_.array_ );
+      break;
+   case objectValue:
+      mapAllocator()->destructMap( value_.map_ );
+      break;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+
+   if ( comments_ )
+      delete[] comments_;
+}
+
+Value &
+Value::operator=( const Value &other )
+{
+   Value temp( other );
+   swap( temp );
+   return *this;
+}
+
+void 
+Value::swap( Value &other )
+{
+   ValueType temp = type_;
+   type_ = other.type_;
+   other.type_ = temp;
+   std::swap( value_, other.value_ );
+   int temp2 = allocated_;
+   allocated_ = other.allocated_;
+   other.allocated_ = temp2;
+}
+
+ValueType 
+Value::type() const
+{
+   return type_;
+}
+
+
+int 
+Value::compare( const Value &other ) const
+{
+   if ( *this < other )
+      return -1;
+   if ( *this > other )
+      return 1;
+   return 0;
+}
+
+
+bool 
+Value::operator <( const Value &other ) const
+{
+   int typeDelta = type_ - other.type_;
+   if ( typeDelta )
+      return typeDelta < 0 ? true : false;
+   switch ( type_ )
+   {
+   case nullValue:
+      return false;
+   case intValue:
+      return value_.int_ < other.value_.int_;
+   case uintValue:
+      return value_.uint_ < other.value_.uint_;
+   case realValue:
+      return value_.real_ < other.value_.real_;
+   case booleanValue:
+      return value_.bool_ < other.value_.bool_;
+   case stringValue:
+      return ( value_.string_ == 0  &&  other.value_.string_ )
+             || ( other.value_.string_  
+                  &&  value_.string_  
+                  && strcmp( value_.string_, other.value_.string_ ) < 0 );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      {
+         int delta = int( value_.map_->size() - other.value_.map_->size() );
+         if ( delta )
+            return delta < 0;
+         return (*value_.map_) < (*other.value_.map_);
+      }
+#else
+   case arrayValue:
+      return value_.array_->compare( *(other.value_.array_) ) < 0;
+   case objectValue:
+      return value_.map_->compare( *(other.value_.map_) ) < 0;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   return false;  // unreachable
+}
+
+bool 
+Value::operator <=( const Value &other ) const
+{
+   return !(other < *this);
+}
+
+bool 
+Value::operator >=( const Value &other ) const
+{
+   return !(*this < other);
+}
+
+bool 
+Value::operator >( const Value &other ) const
+{
+   return other < *this;
+}
+
+bool 
+Value::operator ==( const Value &other ) const
+{
+   //if ( type_ != other.type_ )
+   // GCC 2.95.3 says:
+   // attempt to take address of bit-field structure member `Json::Value::type_'
+   // Beats me, but a temp solves the problem.
+   int temp = other.type_;
+   if ( type_ != temp )
+      return false;
+   switch ( type_ )
+   {
+   case nullValue:
+      return true;
+   case intValue:
+      return value_.int_ == other.value_.int_;
+   case uintValue:
+      return value_.uint_ == other.value_.uint_;
+   case realValue:
+      return value_.real_ == other.value_.real_;
+   case booleanValue:
+      return value_.bool_ == other.value_.bool_;
+   case stringValue:
+      return ( value_.string_ == other.value_.string_ )
+             || ( other.value_.string_  
+                  &&  value_.string_  
+                  && strcmp( value_.string_, other.value_.string_ ) == 0 );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      return value_.map_->size() == other.value_.map_->size()
+             && (*value_.map_) == (*other.value_.map_);
+#else
+   case arrayValue:
+      return value_.array_->compare( *(other.value_.array_) ) == 0;
+   case objectValue:
+      return value_.map_->compare( *(other.value_.map_) ) == 0;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   return false;  // unreachable
+}
+
+bool 
+Value::operator !=( const Value &other ) const
+{
+   return !( *this == other );
+}
+
+const char *
+Value::asCString() const
+{
+   JSON_ASSERT( type_ == stringValue );
+   return value_.string_;
+}
+
+
+std::string 
+Value::asString() const
+{
+   switch ( type_ )
+   {
+   case nullValue:
+      return "";
+   case stringValue:
+      return value_.string_ ? value_.string_ : "";
+   case booleanValue:
+      return value_.bool_ ? "true" : "false";
+   case intValue:
+      return valueToString( value_.int_ );
+   case uintValue:
+      return valueToString( value_.uint_ );
+   case realValue:
+      return valueToString( value_.real_ );
+   default:
+      JSON_FAIL_MESSAGE( "Type is not convertible to string" );
+   }
+}
+
+# ifdef JSON_USE_CPPTL
+CppTL::ConstString 
+Value::asConstString() const
+{
+   return CppTL::ConstString( asString().c_str() );
+}
+# endif
+
+
+Value::Int 
+Value::asInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
+      return Int(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
+      return Int(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt), "double out of Int range");
+      return Int(value_.real_);
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to Int.");
+}
+
+
+Value::UInt 
+Value::asUInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
+      return UInt(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
+      return UInt(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt), "double out of UInt range");
+      return UInt( value_.real_ );
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
+}
+
+
+# if defined(JSON_HAS_INT64)
+
+Value::Int64
+Value::asInt64() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return Int64(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
+      return Int64(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), "double out of Int64 range");
+      return Int64(value_.real_);
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
+}
+
+
+Value::UInt64
+Value::asUInt64() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
+      return UInt64(value_.int_);
+   case uintValue:
+      return UInt64(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64), "double out of UInt64 range");
+      return UInt64( value_.real_ );
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
+}
+# endif // if defined(JSON_HAS_INT64)
+
+
+LargestInt 
+Value::asLargestInt() const
+{
+#if defined(JSON_NO_INT64)
+    return asInt();
+#else
+    return asInt64();
+#endif
+}
+
+
+LargestUInt 
+Value::asLargestUInt() const
+{
+#if defined(JSON_NO_INT64)
+    return asUInt();
+#else
+    return asUInt64();
+#endif
+}
+
+
+double 
+Value::asDouble() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return static_cast<double>( value_.int_ );
+   case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return static_cast<double>( value_.uint_ );
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return integerToDouble( value_.uint_ );
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+   case realValue:
+      return value_.real_;
+   case nullValue:
+      return 0.0;
+   case booleanValue:
+      return value_.bool_ ? 1.0 : 0.0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to double.");
+}
+
+float
+Value::asFloat() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return static_cast<float>( value_.int_ );
+   case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return static_cast<float>( value_.uint_ );
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return integerToDouble( value_.uint_ );
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+   case realValue:
+      return static_cast<float>( value_.real_ );
+   case nullValue:
+      return 0.0;
+   case booleanValue:
+      return value_.bool_ ? 1.0f : 0.0f;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to float.");
+}
+
+bool 
+Value::asBool() const
+{
+   switch ( type_ )
+   {
+   case booleanValue:
+      return value_.bool_;
+   case nullValue:
+      return false;
+   case intValue:
+      return value_.int_ ? true : false;
+   case uintValue:
+      return value_.uint_ ? true : false;
+   case realValue:
+      return value_.real_ ? true : false;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to bool.");
+}
+
+
+bool 
+Value::isConvertibleTo( ValueType other ) const
+{
+   switch ( other )
+   {
+   case nullValue:
+      return ( isNumeric() && asDouble() == 0.0 )
+             || ( type_ == booleanValue && value_.bool_ == false )
+             || ( type_ == stringValue && asString() == "" )
+             || ( type_ == arrayValue && value_.map_->size() == 0 )
+             || ( type_ == objectValue && value_.map_->size() == 0 )
+             || type_ == nullValue;
+   case intValue:
+      return isInt()
+             || (type_ == realValue && InRange(value_.real_, minInt, maxInt))
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case uintValue:
+      return isUInt()
+             || (type_ == realValue && InRange(value_.real_, 0, maxUInt))
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case realValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case booleanValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case stringValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == stringValue
+             || type_ == nullValue;
+   case arrayValue:
+      return type_ == arrayValue
+             || type_ == nullValue;
+   case objectValue:
+      return type_ == objectValue
+             || type_ == nullValue;
+   }
+   JSON_ASSERT_UNREACHABLE;
+   return false;
+}
+
+
+/// Number of values in array or object
+ArrayIndex 
+Value::size() const
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+   case stringValue:
+      return 0;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:  // size of the array is highest index + 1
+      if ( !value_.map_->empty() )
+      {
+         ObjectValues::const_iterator itLast = value_.map_->end();
+         --itLast;
+         return (*itLast).first.index()+1;
+      }
+      return 0;
+   case objectValue:
+      return ArrayIndex( value_.map_->size() );
+#else
+   case arrayValue:
+      return Int( value_.array_->size() );
+   case objectValue:
+      return Int( value_.map_->size() );
+#endif
+   }
+   JSON_ASSERT_UNREACHABLE;
+   return 0; // unreachable;
+}
+
+
+bool 
+Value::empty() const
+{
+   if ( isNull() || isArray() || isObject() )
+      return size() == 0u;
+   else
+      return false;
+}
+
+
+bool
+Value::operator!() const
+{
+   return isNull();
+}
+
+
+void 
+Value::clear()
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue  || type_ == objectValue );
+
+   switch ( type_ )
+   {
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_->clear();
+      break;
+#else
+   case arrayValue:
+      value_.array_->clear();
+      break;
+   case objectValue:
+      value_.map_->clear();
+      break;
+#endif
+   default:
+      break;
+   }
+}
+
+void 
+Value::resize( ArrayIndex newSize )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      *this = Value( arrayValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ArrayIndex oldSize = size();
+   if ( newSize == 0 )
+      clear();
+   else if ( newSize > oldSize )
+      (*this)[ newSize - 1 ];
+   else
+   {
+      for ( ArrayIndex index = newSize; index < oldSize; ++index )
+      {
+         value_.map_->erase( index );
+      }
+      assert( size() == newSize );
+   }
+#else
+   value_.array_->resize( newSize );
+#endif
+}
+
+
+Value &
+Value::operator[]( ArrayIndex index )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      *this = Value( arrayValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString key( index );
+   ObjectValues::iterator it = value_.map_->lower_bound( key );
+   if ( it != value_.map_->end()  &&  (*it).first == key )
+      return (*it).second;
+
+   ObjectValues::value_type defaultValue( key, null );
+   it = value_.map_->insert( it, defaultValue );
+   return (*it).second;
+#else
+   return value_.array_->resolveReference( index );
+#endif
+}
+
+
+Value &
+Value::operator[]( int index )
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
+const Value &
+Value::operator[]( ArrayIndex index ) const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString key( index );
+   ObjectValues::const_iterator it = value_.map_->find( key );
+   if ( it == value_.map_->end() )
+      return null;
+   return (*it).second;
+#else
+   Value *value = value_.array_->find( index );
+   return value ? *value : null;
+#endif
+}
+
+
+const Value &
+Value::operator[]( int index ) const
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
+Value &
+Value::operator[]( const char *key )
+{
+   return resolveReference( key, false );
+}
+
+
+Value &
+Value::resolveReference( const char *key, 
+                         bool isStatic )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      *this = Value( objectValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, isStatic ? CZString::noDuplication 
+                                     : CZString::duplicateOnCopy );
+   ObjectValues::iterator it = value_.map_->lower_bound( actualKey );
+   if ( it != value_.map_->end()  &&  (*it).first == actualKey )
+      return (*it).second;
+
+   ObjectValues::value_type defaultValue( actualKey, null );
+   it = value_.map_->insert( it, defaultValue );
+   Value &value = (*it).second;
+   return value;
+#else
+   return value_.map_->resolveReference( key, isStatic );
+#endif
+}
+
+
+Value 
+Value::get( ArrayIndex index, 
+            const Value &defaultValue ) const
+{
+   const Value *value = &((*this)[index]);
+   return value == &null ? defaultValue : *value;
+}
+
+
+bool 
+Value::isValidIndex( ArrayIndex index ) const
+{
+   return index < size();
+}
+
+
+
+const Value &
+Value::operator[]( const char *key ) const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, CZString::noDuplication );
+   ObjectValues::const_iterator it = value_.map_->find( actualKey );
+   if ( it == value_.map_->end() )
+      return null;
+   return (*it).second;
+#else
+   const Value *value = value_.map_->find( key );
+   return value ? *value : null;
+#endif
+}
+
+
+Value &
+Value::operator[]( const std::string &key )
+{
+   return (*this)[ key.c_str() ];
+}
+
+
+const Value &
+Value::operator[]( const std::string &key ) const
+{
+   return (*this)[ key.c_str() ];
+}
+
+Value &
+Value::operator[]( const StaticString &key )
+{
+   return resolveReference( key, true );
+}
+
+
+# ifdef JSON_USE_CPPTL
+Value &
+Value::operator[]( const CppTL::ConstString &key )
+{
+   return (*this)[ key.c_str() ];
+}
+
+
+const Value &
+Value::operator[]( const CppTL::ConstString &key ) const
+{
+   return (*this)[ key.c_str() ];
+}
+# endif
+
+
+Value &
+Value::append( const Value &value )
+{
+   return (*this)[size()] = value;
+}
+
+
+Value 
+Value::get( const char *key, 
+            const Value &defaultValue ) const
+{
+   const Value *value = &((*this)[key]);
+   return value == &null ? defaultValue : *value;
+}
+
+
+Value 
+Value::get( const std::string &key,
+            const Value &defaultValue ) const
+{
+   return get( key.c_str(), defaultValue );
+}
+
+Value
+Value::removeMember( const char* key )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, CZString::noDuplication );
+   ObjectValues::iterator it = value_.map_->find( actualKey );
+   if ( it == value_.map_->end() )
+      return null;
+   Value old(it->second);
+   value_.map_->erase(it);
+   return old;
+#else
+   Value *value = value_.map_->find( key );
+   if (value){
+      Value old(*value);
+      value_.map_.remove( key );
+      return old;
+   } else {
+      return null;
+   }
+#endif
+}
+
+Value
+Value::removeMember( const std::string &key )
+{
+   return removeMember( key.c_str() );
+}
+
+# ifdef JSON_USE_CPPTL
+Value 
+Value::get( const CppTL::ConstString &key,
+            const Value &defaultValue ) const
+{
+   return get( key.c_str(), defaultValue );
+}
+# endif
+
+bool 
+Value::isMember( const char *key ) const
+{
+   const Value *value = &((*this)[key]);
+   return value != &null;
+}
+
+
+bool 
+Value::isMember( const std::string &key ) const
+{
+   return isMember( key.c_str() );
+}
+
+
+# ifdef JSON_USE_CPPTL
+bool 
+Value::isMember( const CppTL::ConstString &key ) const
+{
+   return isMember( key.c_str() );
+}
+#endif
+
+Value::Members 
+Value::getMemberNames() const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+       return Value::Members();
+   Members members;
+   members.reserve( value_.map_->size() );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ObjectValues::const_iterator it = value_.map_->begin();
+   ObjectValues::const_iterator itEnd = value_.map_->end();
+   for ( ; it != itEnd; ++it )
+      members.push_back( std::string( (*it).first.c_str() ) );
+#else
+   ValueInternalMap::IteratorState it;
+   ValueInternalMap::IteratorState itEnd;
+   value_.map_->makeBeginIterator( it );
+   value_.map_->makeEndIterator( itEnd );
+   for ( ; !ValueInternalMap::equals( it, itEnd ); ValueInternalMap::increment(it) )
+      members.push_back( std::string( ValueInternalMap::key( it ) ) );
+#endif
+   return members;
+}
+//
+//# ifdef JSON_USE_CPPTL
+//EnumMemberNames
+//Value::enumMemberNames() const
+//{
+//   if ( type_ == objectValue )
+//   {
+//      return CppTL::Enum::any(  CppTL::Enum::transform(
+//         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
+//         MemberNamesTransform() ) );
+//   }
+//   return EnumMemberNames();
+//}
+//
+//
+//EnumValues 
+//Value::enumValues() const
+//{
+//   if ( type_ == objectValue  ||  type_ == arrayValue )
+//      return CppTL::Enum::anyValues( *(value_.map_), 
+//                                     CppTL::Type<const Value &>() );
+//   return EnumValues();
+//}
+//
+//# endif
+
+static bool IsIntegral(double d) {
+  double integral_part;
+  return modf(d, &integral_part) == 0.0;
+}
+
+
+bool
+Value::isNull() const
+{
+   return type_ == nullValue;
+}
+
+
+bool 
+Value::isBool() const
+{
+   return type_ == booleanValue;
+}
+
+
+bool 
+Value::isInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return value_.int_ >= minInt  &&  value_.int_ <= maxInt;
+   case uintValue:
+      return value_.uint_ <= UInt(maxInt);
+   case realValue:
+      return value_.real_ >= minInt &&
+             value_.real_ <= maxInt &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+   return false;
+}
+
+
+bool 
+Value::isUInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
+   case uintValue:
+      return value_.uint_ <= maxUInt;
+   case realValue:
+      return value_.real_ >= 0 &&
+             value_.real_ <= maxUInt &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+   return false;
+}
+
+bool 
+Value::isInt64() const
+{
+# if defined(JSON_HAS_INT64)
+   switch ( type_ )
+   {
+   case intValue:
+     return true;
+   case uintValue:
+      return value_.uint_ <= UInt64(maxInt64);
+   case realValue:
+      // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
+      // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
+      // require the value to be strictly less than the limit.
+      return value_.real_ >= double(minInt64) &&
+             value_.real_ < double(maxInt64) &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+# endif  // JSON_HAS_INT64
+   return false;
+}
+
+bool 
+Value::isUInt64() const
+{
+# if defined(JSON_HAS_INT64)
+   switch ( type_ )
+   {
+   case intValue:
+     return value_.int_ >= 0;
+   case uintValue:
+      return true;
+   case realValue:
+      // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+      // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+      // require the value to be strictly less than the limit.
+      return value_.real_ >= 0 &&
+             value_.real_ < maxUInt64AsDouble &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+# endif  // JSON_HAS_INT64
+   return false;
+}
+
+
+bool 
+Value::isIntegral() const
+{
+#if defined(JSON_HAS_INT64)
+  return isInt64() || isUInt64();
+#else
+  return isInt() || isUInt();
+#endif
+}
+
+
+bool 
+Value::isDouble() const
+{
+   return type_ == realValue || isIntegral();
+}
+
+
+bool 
+Value::isNumeric() const
+{
+   return isIntegral() || isDouble();
+}
+
+
+bool 
+Value::isString() const
+{
+   return type_ == stringValue;
+}
+
+
+bool 
+Value::isArray() const
+{
+   return type_ == arrayValue;
+}
+
+
+bool 
+Value::isObject() const
+{
+   return type_ == objectValue;
+}
+
+
+void 
+Value::setComment( const char *comment,
+                   CommentPlacement placement )
+{
+   if ( !comments_ )
+      comments_ = new CommentInfo[numberOfCommentPlacement];
+   comments_[placement].setComment( comment );
+}
+
+
+void 
+Value::setComment( const std::string &comment,
+                   CommentPlacement placement )
+{
+   setComment( comment.c_str(), placement );
+}
+
+
+bool 
+Value::hasComment( CommentPlacement placement ) const
+{
+   return comments_ != 0  &&  comments_[placement].comment_ != 0;
+}
+
+std::string 
+Value::getComment( CommentPlacement placement ) const
+{
+   if ( hasComment(placement) )
+      return comments_[placement].comment_;
+   return "";
+}
+
+
+std::string 
+Value::toStyledString() const
+{
+   StyledWriter writer;
+   return writer.write( *this );
+}
+
+
+Value::const_iterator 
+Value::begin() const
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeBeginIterator( it );
+         return const_iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeBeginIterator( it );
+         return const_iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return const_iterator( value_.map_->begin() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return const_iterator();
+}
+
+Value::const_iterator 
+Value::end() const
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeEndIterator( it );
+         return const_iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeEndIterator( it );
+         return const_iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return const_iterator( value_.map_->end() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return const_iterator();
+}
+
+
+Value::iterator 
+Value::begin()
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeBeginIterator( it );
+         return iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeBeginIterator( it );
+         return iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return iterator( value_.map_->begin() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return iterator();
+}
+
+Value::iterator 
+Value::end()
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeEndIterator( it );
+         return iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeEndIterator( it );
+         return iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return iterator( value_.map_->end() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return iterator();
+}
+
+
+// class PathArgument
+// //////////////////////////////////////////////////////////////////
+
+PathArgument::PathArgument()
+   : key_()
+   , index_()
+   , kind_( kindNone )
+{
+}
+
+
+PathArgument::PathArgument( ArrayIndex index )
+   : key_()
+   , index_( index )
+   , kind_( kindIndex )
+{
+}
+
+
+PathArgument::PathArgument( const char *key )
+   : key_( key )
+   , index_()
+   , kind_( kindKey )
+{
+}
+
+
+PathArgument::PathArgument( const std::string &key )
+   : key_( key.c_str() )
+   , index_()
+   , kind_( kindKey )
+{
+}
+
+// class Path
+// //////////////////////////////////////////////////////////////////
+
+Path::Path( const std::string &path,
+            const PathArgument &a1,
+            const PathArgument &a2,
+            const PathArgument &a3,
+            const PathArgument &a4,
+            const PathArgument &a5 )
+{
+   InArgs in;
+   in.push_back( &a1 );
+   in.push_back( &a2 );
+   in.push_back( &a3 );
+   in.push_back( &a4 );
+   in.push_back( &a5 );
+   makePath( path, in );
+}
+
+
+void 
+Path::makePath( const std::string &path,
+                const InArgs &in )
+{
+   const char *current = path.c_str();
+   const char *end = current + path.length();
+   InArgs::const_iterator itInArg = in.begin();
+   while ( current != end )
+   {
+      if ( *current == '[' )
+      {
+         ++current;
+         if ( *current == '%' )
+            addPathInArg( path, in, itInArg, PathArgument::kindIndex );
+         else
+         {
+            ArrayIndex index = 0;
+            for ( ; current != end && *current >= '0'  &&  *current <= '9'; ++current )
+               index = index * 10 + ArrayIndex(*current - '0');
+            args_.push_back( index );
+         }
+         if ( current == end  ||  *current++ != ']' )
+            invalidPath( path, int(current - path.c_str()) );
+      }
+      else if ( *current == '%' )
+      {
+         addPathInArg( path, in, itInArg, PathArgument::kindKey );
+         ++current;
+      }
+      else if ( *current == '.' )
+      {
+         ++current;
+      }
+      else
+      {
+         const char *beginName = current;
+         while ( current != end  &&  !strchr( "[.", *current ) )
+            ++current;
+         args_.push_back( std::string( beginName, current ) );
+      }
+   }
+}
+
+
+void 
+Path::addPathInArg( const std::string &path, 
+                    const InArgs &in, 
+                    InArgs::const_iterator &itInArg, 
+                    PathArgument::Kind kind )
+{
+   if ( itInArg == in.end() )
+   {
+      // Error: missing argument %d
+   }
+   else if ( (*itInArg)->kind_ != kind )
+   {
+      // Error: bad argument type
+   }
+   else
+   {
+      args_.push_back( **itInArg );
+   }
+}
+
+
+void 
+Path::invalidPath( const std::string &path, 
+                   int location )
+{
+   // Error: invalid path.
+}
+
+
+const Value &
+Path::resolve( const Value &root ) const
+{
+   const Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
+         {
+            // Error: unable to resolve path (array value expected at position...
+         }
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+         {
+            // Error: unable to resolve path (object value expected at position...)
+         }
+         node = &((*node)[arg.key_]);
+         if ( node == &Value::null )
+         {
+            // Error: unable to resolve path (object has no member named '' at position...)
+         }
+      }
+   }
+   return *node;
+}
+
+
+Value 
+Path::resolve( const Value &root, 
+               const Value &defaultValue ) const
+{
+   const Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
+            return defaultValue;
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+            return defaultValue;
+         node = &((*node)[arg.key_]);
+         if ( node == &Value::null )
+            return defaultValue;
+      }
+   }
+   return *node;
+}
+
+
+Value &
+Path::make( Value &root ) const
+{
+   Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray() )
+         {
+            // Error: node is not an array at position ...
+         }
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+         {
+            // Error: node is not an object at position...
+         }
+         node = &((*node)[arg.key_]);
+      }
+   }
+   return *node;
+}
+
+
+} // namespace Json
diff --git a/jsoncpp/devtools/__init__.py b/jsoncpp/devtools/__init__.py
new file mode 100644
index 0000000..c944e7c
--- /dev/null
+++ b/jsoncpp/devtools/__init__.py
@@ -0,0 +1 @@
+# module
\ No newline at end of file
diff --git a/jsoncpp/devtools/licenseupdater.py b/jsoncpp/devtools/licenseupdater.py
new file mode 100644
index 0000000..866eada
--- /dev/null
+++ b/jsoncpp/devtools/licenseupdater.py
@@ -0,0 +1,93 @@
+"""Updates the license text in source file.
+"""
+
+# An existing license is found if the file starts with the string below,
+# and ends with the first blank line.
+LICENSE_BEGIN = "// Copyright "
+
+BRIEF_LICENSE = LICENSE_BEGIN + """2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+""".replace('\r\n','\n')
+
+def update_license( path, dry_run, show_diff ):
+    """Update the license statement in the specified file.
+    Parameters:
+      path: path of the C++ source file to update.
+      dry_run: if True, just print the path of the file that would be updated,
+               but don't change it.
+      show_diff: if True, print the path of the file that would be modified,
+                 as well as the change made to the file. 
+    """
+    with open( path, 'rt' ) as fin:
+        original_text = fin.read().replace('\r\n','\n')
+        newline = fin.newlines and fin.newlines[0] or '\n'
+    if not original_text.startswith( LICENSE_BEGIN ):
+        # No existing license found => prepend it
+        new_text = BRIEF_LICENSE + original_text
+    else:
+        license_end_index = original_text.index( '\n\n' ) # search first blank line
+        new_text = BRIEF_LICENSE + original_text[license_end_index+2:]
+    if original_text != new_text:
+        if not dry_run:
+            with open( path, 'wb' ) as fout:
+                fout.write( new_text.replace('\n', newline ) )
+        print 'Updated', path
+        if show_diff:
+            import difflib
+            print '\n'.join( difflib.unified_diff( original_text.split('\n'),
+                                                   new_text.split('\n') ) )
+        return True
+    return False
+
+def update_license_in_source_directories( source_dirs, dry_run, show_diff ):
+    """Updates license text in C++ source files found in directory source_dirs.
+    Parameters:
+      source_dirs: list of directory to scan for C++ sources. Directories are
+                   scanned recursively.
+      dry_run: if True, just print the path of the file that would be updated,
+               but don't change it.
+      show_diff: if True, print the path of the file that would be modified,
+                 as well as the change made to the file. 
+    """
+    from devtools import antglob
+    prune_dirs = antglob.prune_dirs + 'scons-local* ./build* ./libs ./dist'
+    for source_dir in source_dirs:
+        cpp_sources = antglob.glob( source_dir,
+            includes = '''**/*.h **/*.cpp **/*.inl''',
+            prune_dirs = prune_dirs )
+        for source in cpp_sources:
+            update_license( source, dry_run, show_diff )
+
+def main():
+    usage = """%prog DIR [DIR2...]
+Updates license text in sources of the project in source files found
+in the directory specified on the command-line.
+
+Example of call:
+python devtools\licenseupdater.py include src -n --diff
+=> Show change that would be made to the sources.
+
+python devtools\licenseupdater.py include src
+=> Update license statement on all sources in directories include/ and src/.
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option('-n', '--dry-run', dest="dry_run", action='store_true', default=False,
+        help="""Only show what files are updated, do not update the files""")
+    parser.add_option('--diff', dest="show_diff", action='store_true', default=False,
+        help="""On update, show change made to the file.""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+    update_license_in_source_directories( args, options.dry_run, options.show_diff )
+    print 'Done'
+
+if __name__ == '__main__':
+    import sys
+    import os.path
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    main()
+
diff --git a/jsoncpp/doc/header.html b/jsoncpp/doc/header.html
new file mode 100644
index 0000000..1a6ad61
--- /dev/null
+++ b/jsoncpp/doc/header.html
@@ -0,0 +1,24 @@
+<html>
+<head>
+<title>
+JsonCpp - JSON data format manipulation library
+</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head>
+
+<body bgcolor="#ffffff"> 
+<table width="100%">
+  <tr>
+    <td width="40%" align="left" valign="center">
+      <a href="http://sourceforge.net/projects/jsoncpp/">
+      JsonCpp project page
+      </a>
+    </td>
+    <td width="40%" align="right" valign="center">
+      <a href="http://jsoncpp.sourceforge.net">JsonCpp home page</a>
+    </td>
+  </tr>
+</table>
+
+<hr>
diff --git a/jsoncpp/doc/jsoncpp.dox b/jsoncpp/doc/jsoncpp.dox
new file mode 100644
index 0000000..97cc108
--- /dev/null
+++ b/jsoncpp/doc/jsoncpp.dox
@@ -0,0 +1,126 @@
+/**
+\mainpage
+\section _intro Introduction
+
+<a HREF="http://www.json.org/">JSON (JavaScript Object Notation)</a>
+ is a lightweight data-interchange format. 
+It can represent integer, real number, string, an ordered sequence of value, and
+a collection of name/value pairs.
+
+Here is an example of JSON data:
+\verbatim
+// Configuration options
+{
+    // Default encoding for text
+    "encoding" : "UTF-8",
+    
+    // Plug-ins loaded at start-up
+    "plug-ins" : [
+        "python",
+        "c++",
+        "ruby"
+        ],
+        
+    // Tab indent size
+    "indent" : { "length" : 3, "use_space": true }
+}
+\endverbatim
+
+\section _features Features
+- read and write JSON document
+- attach C and C++ style comments to element during parsing
+- rewrite JSON document preserving original comments
+
+Notes: Comments used to be supported in JSON but where removed for 
+portability (C like comments are not supported in Python). Since
+comments are useful in configuration/input file, this feature was
+preserved.
+
+\section _example Code example
+
+\code
+Json::Value root;   // will contains the root value after parsing.
+Json::Reader reader;
+bool parsingSuccessful = reader.parse( config_doc, root );
+if ( !parsingSuccessful )
+{
+    // report to the user the failure and their locations in the document.
+    std::cout  << "Failed to parse configuration\n"
+               << reader.getFormattedErrorMessages();
+    return;
+}
+
+// Get the value of the member of root named 'encoding', return 'UTF-8' if there is no
+// such member.
+std::string encoding = root.get("encoding", "UTF-8" ).asString();
+// Get the value of the member of root named 'encoding', return a 'null' value if
+// there is no such member.
+const Json::Value plugins = root["plug-ins"];
+for ( int index = 0; index < plugins.size(); ++index )  // Iterates over the sequence elements.
+   loadPlugIn( plugins[index].asString() );
+   
+setIndentLength( root["indent"].get("length", 3).asInt() );
+setIndentUseSpace( root["indent"].get("use_space", true).asBool() );
+
+// ...
+// At application shutdown to make the new configuration document:
+// Since Json::Value has implicit constructor for all value types, it is not
+// necessary to explicitly construct the Json::Value object:
+root["encoding"] = getCurrentEncoding();
+root["indent"]["length"] = getCurrentIndentLength();
+root["indent"]["use_space"] = getCurrentIndentUseSpace();
+
+Json::StyledWriter writer;
+// Make a new JSON document for the configuration. Preserve original comments.
+std::string outputConfig = writer.write( root );
+
+// You can also use streams.  This will put the contents of any JSON
+// stream at a particular sub-value, if you'd like.
+std::cin >> root["subtree"];
+
+// And you can write to a stream, using the StyledWriter automatically.
+std::cout << root;
+\endcode
+
+\section _pbuild Build instructions
+The build instructions are located in the file 
+<a HREF="README.txt">README.txt</a> in the top-directory of the project.
+
+Permanent link to the latest revision of the file in subversion: 
+<a HREF="http://jsoncpp.svn.sourceforge.net/viewvc/jsoncpp/trunk/jsoncpp/README.txt?view=markup">latest README.txt</a>
+
+\section _pdownload Download
+The sources can be downloaded from 
+<a HREF="http://sourceforge.net/projects/jsoncpp/files/">SourceForge download page</a>.
+
+The latest version of the source is available in the project's subversion repository: 
+<a HREF="http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/">
+http://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/</a>
+
+To checkout the source, see the following 
+<a HREF="http://sourceforge.net/scm/?type=svn&group_id=144446">instructions</a>.
+
+\section _news What's New?
+The description of latest changes can be found in 
+<a HREF="NEWS.txt">NEWS.txt</a> in the top-directory of the project.
+
+Permanent link to the latest revision of the file in subversion: 
+<a HREF="http://svn.sourceforge.net/viewcvs.cgi/jsoncpp/README.txt?view=markup">latest NEWS.txt</a>
+
+\section _plinks Project links
+- <a HREF="http://jsoncpp.sourceforge.net">json-cpp home</a>
+- <a HREF="http://www.sourceforge.net/projects/jsoncpp/">json-cpp sourceforge project</a>
+
+\section _rlinks Related links
+- <a HREF="http://www.json.org/">JSON</a> Specification and alternate language implementations.
+- <a HREF="http://www.yaml.org/">YAML</a> A data format designed for human readability.
+- <a HREF="http://www.cl.cam.ac.uk/~mgk25/unicode.html">UTF-8 and Unicode FAQ</a>.
+
+\section _license License
+See file <a HREF="LICENSE">LICENSE</a> in the top-directory of the project.
+
+Basically JsonCpp is licensed under MIT license, or public domain if desired 
+and recognized in your jurisdiction.
+
+\author Baptiste Lepilleur <blep@users.sourceforge.net>
+*/
diff --git a/jsoncpp/doc/roadmap.dox b/jsoncpp/doc/roadmap.dox
new file mode 100644
index 0000000..e6fc17a
--- /dev/null
+++ b/jsoncpp/doc/roadmap.dox
@@ -0,0 +1,37 @@
+/*! \page roadmap JsonCpp roadmap
+  \section ms_release Makes JsonCpp ready for release
+  - Build system clean-up:
+	- Fix build on Windows (shared-library build is broken)
+	- Add enable/disable flag for static and shared library build
+	- Enhance help
+  - Platform portability check: (Notes: was ok on last check)
+	- linux/gcc, 
+	- solaris/cc, 
+	- windows/msvc678, 
+	- aix/vacpp
+  - Add JsonCpp version to header as numeric for use in preprocessor test
+  - Remove buggy experimental hash stuff
+  \section ms_strict Adds a strict mode to reader/parser
+	Strict JSON support as specific in RFC 4627 (http://www.ietf.org/rfc/rfc4627.txt?number=4627).
+	- Enforce only object or array as root element
+	- Disable comment support
+    - Get jsonchecker failing tests to pass in strict mode
+  \section ms_writer Writter control
+    Provides more control to determine how specific items are serialized when JSON allow choice:
+	- Optionally allow escaping of non-ASCII characters using unicode escape sequence "\\u".
+	- Optionally allow escaping of "/" using "\/".
+  \section ms_separation Expose json reader/writer API that do not impose using Json::Value.
+	Some typical use-case involve an application specific structure to/from a JSON document.
+    - Event base parser to allow unserializing a Json document directly in datastructure instead of
+      using the intermediate Json::Value.
+    - Stream based parser to serialized a Json document without using Json::Value as input.
+	- Performance oriented parser/writer:
+		- Provides an event based parser. Should allow pulling & skipping events for ease of use.
+		- Provides a JSON document builder: fast only.
+  \section ms_perfo Performance tuning
+    - Provides support for static property name definition avoiding allocation 
+    - Static property dictionnary can be provided to JSON reader
+    - Performance scenario & benchmarking
+  \section testing Testing
+    - Adds more tests for unicode parsing (e.g. including surrogate and error detection).
+*/
diff --git a/jsoncpp/doxybuild.py b/jsoncpp/doxybuild.py
new file mode 100644
index 0000000..03ad68d
--- /dev/null
+++ b/jsoncpp/doxybuild.py
@@ -0,0 +1,169 @@
+"""Script to generate doxygen documentation.
+"""
+
+import re
+import os
+import os.path
+import sys
+import shutil
+from devtools import tarball
+
+def find_program(*filenames):
+    """find a program in folders path_lst, and sets env[var]
+    @param filenames: a list of possible names of the program to search for
+    @return: the full path of the filename if found, or '' if filename could not be found
+"""
+    paths = os.environ.get('PATH', '').split(os.pathsep)
+    suffixes = ('win32' in sys.platform ) and '.exe .com .bat .cmd' or ''
+    for filename in filenames:
+        for name in [filename+ext for ext in suffixes.split()]:
+            for directory in paths:
+                full_path = os.path.join(directory, name)
+                if os.path.isfile(full_path):
+                    return full_path
+    return ''
+
+def do_subst_in_file(targetfile, sourcefile, dict):
+    """Replace all instances of the keys of dict with their values.
+    For example, if dict is {'%VERSION%': '1.2345', '%BASE%': 'MyProg'},
+    then all instances of %VERSION% in the file will be replaced with 1.2345 etc.
+    """
+    try:
+        f = open(sourcefile, 'rb')
+        contents = f.read()
+        f.close()
+    except:
+        print "Can't read source file %s"%sourcefile
+        raise
+    for (k,v) in dict.items():
+        v = v.replace('\\','\\\\') 
+        contents = re.sub(k, v, contents)
+    try:
+        f = open(targetfile, 'wb')
+        f.write(contents)
+        f.close()
+    except:
+        print "Can't write target file %s"%targetfile
+        raise
+
+def run_doxygen(doxygen_path, config_file, working_dir, is_silent):
+    config_file = os.path.abspath( config_file )
+    doxygen_path = doxygen_path
+    old_cwd = os.getcwd()
+    try:
+        os.chdir( working_dir )
+        cmd = [doxygen_path, config_file]
+        print 'Running:', ' '.join( cmd )
+        try:
+            import subprocess
+        except:
+            if os.system( ' '.join( cmd ) ) != 0:
+                print 'Documentation generation failed'
+                return False
+        else:
+            if is_silent:
+                process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT )
+            else:
+                process = subprocess.Popen( cmd )
+            stdout, _ = process.communicate()
+            if process.returncode:
+                print 'Documentation generation failed:'
+                print stdout
+                return False
+        return True
+    finally:
+        os.chdir( old_cwd )
+
+def build_doc( options,  make_release=False ):
+    if make_release:
+        options.make_tarball = True
+        options.with_dot = True
+        options.with_html_help = True
+        options.with_uml_look = True
+        options.open = False
+        options.silent = True
+
+    version = open('version','rt').read().strip()
+    output_dir = 'dist/doxygen' # relative to doc/doxyfile location.
+    if not os.path.isdir( output_dir ):
+        os.makedirs( output_dir )
+    top_dir = os.path.abspath( '.' )
+    html_output_dirname = 'jsoncpp-api-html-' + version
+    tarball_path = os.path.join( 'dist', html_output_dirname + '.tar.gz' )
+    warning_log_path = os.path.join( output_dir, '../jsoncpp-doxygen-warning.log' )
+    html_output_path = os.path.join( output_dir, html_output_dirname )
+    def yesno( bool ):
+        return bool and 'YES' or 'NO'
+    subst_keys = {
+        '%JSONCPP_VERSION%': version,
+        '%DOC_TOPDIR%': '',
+        '%TOPDIR%': top_dir,
+        '%HTML_OUTPUT%': os.path.join( '..', output_dir, html_output_dirname ),
+        '%HAVE_DOT%': yesno(options.with_dot),
+        '%DOT_PATH%': os.path.split(options.dot_path)[0],
+        '%HTML_HELP%': yesno(options.with_html_help),
+        '%UML_LOOK%': yesno(options.with_uml_look),
+        '%WARNING_LOG_PATH%': os.path.join( '..', warning_log_path )
+        }
+
+    if os.path.isdir( output_dir ):
+        print 'Deleting directory:', output_dir
+        shutil.rmtree( output_dir )
+    if not os.path.isdir( output_dir ):
+        os.makedirs( output_dir )
+
+    do_subst_in_file( 'doc/doxyfile', 'doc/doxyfile.in', subst_keys )
+    ok = run_doxygen( options.doxygen_path, 'doc/doxyfile', 'doc', is_silent=options.silent )
+    if not options.silent:
+        print open(warning_log_path, 'rb').read()
+    index_path = os.path.abspath(os.path.join(subst_keys['%HTML_OUTPUT%'], 'index.html'))
+    print 'Generated documentation can be found in:'
+    print index_path
+    if options.open:
+        import webbrowser
+        webbrowser.open( 'file://' + index_path )
+    if options.make_tarball:
+        print 'Generating doc tarball to', tarball_path
+        tarball_sources = [
+            output_dir,
+            'README.txt',
+            'LICENSE',
+            'NEWS.txt',
+            'version'
+            ]
+        tarball_basedir = os.path.join( output_dir, html_output_dirname )
+        tarball.make_tarball( tarball_path, tarball_sources, tarball_basedir, html_output_dirname )
+    return tarball_path, html_output_dirname
+
+def main():
+    usage = """%prog
+    Generates doxygen documentation in build/doxygen.
+    Optionaly makes a tarball of the documentation to dist/.
+
+    Must be started in the project top directory.    
+    """
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option('--with-dot', dest="with_dot", action='store_true', default=False,
+        help="""Enable usage of DOT to generate collaboration diagram""")
+    parser.add_option('--dot', dest="dot_path", action='store', default=find_program('dot'),
+        help="""Path to GraphViz dot tool. Must be full qualified path. [Default: %default]""")
+    parser.add_option('--doxygen', dest="doxygen_path", action='store', default=find_program('doxygen'),
+        help="""Path to Doxygen tool. [Default: %default]""")
+    parser.add_option('--with-html-help', dest="with_html_help", action='store_true', default=False,
+        help="""Enable generation of Microsoft HTML HELP""")
+    parser.add_option('--no-uml-look', dest="with_uml_look", action='store_false', default=True,
+        help="""Generates DOT graph without UML look [Default: False]""")
+    parser.add_option('--open', dest="open", action='store_true', default=False,
+        help="""Open the HTML index in the web browser after generation""")
+    parser.add_option('--tarball', dest="make_tarball", action='store_true', default=False,
+        help="""Generates a tarball of the documentation in dist/ directory""")
+    parser.add_option('-s', '--silent', dest="silent", action='store_true', default=False,
+        help="""Hides doxygen output""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+    build_doc( options )
+
+if __name__ == '__main__':
+    main()
diff --git a/jsoncpp/include/json/assertions.h b/jsoncpp/include/json/assertions.h
new file mode 100644
index 0000000..a480585
--- /dev/null
+++ b/jsoncpp/include/json/assertions.h
@@ -0,0 +1,31 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED
+# define CPPTL_JSON_ASSERTIONS_H_INCLUDED
+
+#include <stdlib.h>
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/config.h>
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+#if JSON_USE_EXCEPTION
+#define JSON_ASSERT( condition ) assert( condition );  // @todo <= change this into an exception throw
+#define JSON_FAIL_MESSAGE( message ) throw std::runtime_error( message );
+#else  // JSON_USE_EXCEPTION
+#define JSON_ASSERT( condition ) assert( condition );
+
+// The call to assert() will show the failure message in debug builds. In
+// release bugs we write to invalid memory in order to crash hard, so that a
+// debugger or crash reporter gets the chance to take over. We still call exit()
+// afterward in order to tell the compiler that this macro doesn't return.
+#define JSON_FAIL_MESSAGE( message ) { assert(false && message); strcpy(reinterpret_cast<char*>(666), message); exit(123); }
+
+#endif
+
+#define JSON_ASSERT_MESSAGE( condition, message ) if (!( condition )) { JSON_FAIL_MESSAGE( message ) }
+
+#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED
diff --git a/jsoncpp/include/json/autolink.h b/jsoncpp/include/json/autolink.h
new file mode 100644
index 0000000..02328d1
--- /dev/null
+++ b/jsoncpp/include/json/autolink.h
@@ -0,0 +1,24 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_AUTOLINK_H_INCLUDED
+# define JSON_AUTOLINK_H_INCLUDED
+
+# include "config.h"
+
+# ifdef JSON_IN_CPPTL
+#  include <cpptl/cpptl_autolink.h>
+# endif
+
+# if !defined(JSON_NO_AUTOLINK)  &&  !defined(JSON_DLL_BUILD)  &&  !defined(JSON_IN_CPPTL)
+#  define CPPTL_AUTOLINK_NAME "json"
+#  undef CPPTL_AUTOLINK_DLL
+#  ifdef JSON_DLL
+#   define CPPTL_AUTOLINK_DLL
+#  endif
+#  include "autolink.h"
+# endif
+
+#endif // JSON_AUTOLINK_H_INCLUDED
diff --git a/jsoncpp/include/json/config.h b/jsoncpp/include/json/config.h
new file mode 100644
index 0000000..72437c4
--- /dev/null
+++ b/jsoncpp/include/json/config.h
@@ -0,0 +1,98 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_CONFIG_H_INCLUDED
+# define JSON_CONFIG_H_INCLUDED
+
+/// If defined, indicates that json library is embedded in CppTL library.
+//# define JSON_IN_CPPTL 1
+
+/// If defined, indicates that json may leverage CppTL library
+//#  define JSON_USE_CPPTL 1
+/// If defined, indicates that cpptl vector based map should be used instead of std::map
+/// as Value container.
+//#  define JSON_USE_CPPTL_SMALLMAP 1
+/// If defined, indicates that Json specific container should be used
+/// (hash table & simple deque container with customizable allocator).
+/// THIS FEATURE IS STILL EXPERIMENTAL! There is know bugs: See #3177332
+//#  define JSON_VALUE_USE_INTERNAL_MAP 1
+/// Force usage of standard new/malloc based allocator instead of memory pool based allocator.
+/// The memory pools allocator used optimization (initializing Value and ValueInternalLink
+/// as if it was a POD) that may cause some validation tool to report errors.
+/// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
+//#  define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1
+
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+# ifndef JSON_USE_EXCEPTION
+# define JSON_USE_EXCEPTION 1
+# endif
+
+/// If defined, indicates that the source file is amalgated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgated header.
+// #define JSON_IS_AMALGAMATION
+
+
+# ifdef JSON_IN_CPPTL
+#  include <cpptl/config.h>
+#  ifndef JSON_USE_CPPTL
+#   define JSON_USE_CPPTL 1
+#  endif
+# endif
+
+# ifdef JSON_IN_CPPTL
+#  define JSON_API CPPTL_API
+# elif defined(JSON_DLL_BUILD)
+#  define JSON_API __declspec(dllexport)
+# elif defined(JSON_DLL)
+#  define JSON_API __declspec(dllimport)
+# else
+#  define JSON_API
+# endif
+
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for integer
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+#if defined(_MSC_VER)  &&  _MSC_VER <= 1200 // MSVC 6
+// Microsoft Visual Studio 6 only support conversion from __int64 to double
+// (no conversion from unsigned __int64).
+#define JSON_USE_INT64_DOUBLE_CONVERSION 1
+#endif // if defined(_MSC_VER)  &&  _MSC_VER < 1200 // MSVC 6
+
+#if defined(_MSC_VER)  &&  _MSC_VER >= 1500 // MSVC 2008
+/// Indicates that the following function is deprecated.
+# define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#endif
+
+#if !defined(JSONCPP_DEPRECATED)
+# define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+namespace Json {
+   typedef int Int;
+   typedef unsigned int UInt;
+# if defined(JSON_NO_INT64)
+   typedef int LargestInt;
+   typedef unsigned int LargestUInt;
+#  undef JSON_HAS_INT64
+# else // if defined(JSON_NO_INT64)
+   // For Microsoft Visual use specific types as long long is not supported
+#  if defined(_MSC_VER) // Microsoft Visual Studio
+   typedef __int64 Int64;
+   typedef unsigned __int64 UInt64;
+#  else // if defined(_MSC_VER) // Other platforms, use long long
+   typedef long long int Int64;
+   typedef unsigned long long int UInt64;
+#  endif // if defined(_MSC_VER)
+   typedef Int64 LargestInt;
+   typedef UInt64 LargestUInt;
+#  define JSON_HAS_INT64
+# endif // if defined(JSON_NO_INT64)
+} // end namespace Json
+
+
+#endif // JSON_CONFIG_H_INCLUDED
diff --git a/jsoncpp/include/json/features.h b/jsoncpp/include/json/features.h
new file mode 100644
index 0000000..4353278
--- /dev/null
+++ b/jsoncpp/include/json/features.h
@@ -0,0 +1,49 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_FEATURES_H_INCLUDED
+# define CPPTL_JSON_FEATURES_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+   /** \brief Configuration passed to reader and writer.
+    * This configuration object can be used to force the Reader or Writer
+    * to behave in a standard conforming way.
+    */
+   class JSON_API Features
+   {
+   public:
+      /** \brief A configuration that allows all features and assumes all strings are UTF-8.
+       * - C & C++ comments are allowed
+       * - Root object can be any JSON value
+       * - Assumes Value strings are encoded in UTF-8
+       */
+      static Features all();
+
+      /** \brief A configuration that is strictly compatible with the JSON specification.
+       * - Comments are forbidden.
+       * - Root object must be either an array or an object value.
+       * - Assumes Value strings are encoded in UTF-8
+       */
+      static Features strictMode();
+
+      /** \brief Initialize the configuration like JsonConfig::allFeatures;
+       */
+      Features();
+
+      /// \c true if comments are allowed. Default: \c true.
+      bool allowComments_;
+
+      /// \c true if root must be either an array or an object value. Default: \c false.
+      bool strictRoot_;
+   };
+
+} // namespace Json
+
+#endif // CPPTL_JSON_FEATURES_H_INCLUDED
diff --git a/jsoncpp/include/json/forwards.h b/jsoncpp/include/json/forwards.h
new file mode 100644
index 0000000..ab863da
--- /dev/null
+++ b/jsoncpp/include/json/forwards.h
@@ -0,0 +1,44 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FORWARDS_H_INCLUDED
+# define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+   // writer.h
+   class FastWriter;
+   class StyledWriter;
+
+   // reader.h
+   class Reader;
+
+   // features.h
+   class Features;
+
+   // value.h
+   typedef unsigned int ArrayIndex;
+   class StaticString;
+   class Path;
+   class PathArgument;
+   class Value;
+   class ValueIteratorBase;
+   class ValueIterator;
+   class ValueConstIterator;
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   class ValueMapAllocator;
+   class ValueInternalLink;
+   class ValueInternalArray;
+   class ValueInternalMap;
+#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+} // namespace Json
+
+
+#endif // JSON_FORWARDS_H_INCLUDED
diff --git a/jsoncpp/include/json/json.h b/jsoncpp/include/json/json.h
new file mode 100644
index 0000000..da5fc96
--- /dev/null
+++ b/jsoncpp/include/json/json.h
@@ -0,0 +1,15 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_JSON_H_INCLUDED
+# define JSON_JSON_H_INCLUDED
+
+# include "autolink.h"
+# include "value.h"
+# include "reader.h"
+# include "writer.h"
+# include "features.h"
+
+#endif // JSON_JSON_H_INCLUDED
diff --git a/jsoncpp/include/json/reader.h b/jsoncpp/include/json/reader.h
new file mode 100644
index 0000000..a3023b3
--- /dev/null
+++ b/jsoncpp/include/json/reader.h
@@ -0,0 +1,213 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_READER_H_INCLUDED
+# define CPPTL_JSON_READER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "features.h"
+# include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+# include <deque>
+# include <stack>
+# include <string>
+
+namespace Json {
+
+   /** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a Value.
+    *
+    */
+   class JSON_API Reader
+   {
+   public:
+      typedef char Char;
+      typedef const Char *Location;
+
+      /** \brief Constructs a Reader allowing all features
+       * for parsing.
+       */
+      Reader();
+
+      /** \brief Constructs a Reader allowing the specified feature set
+       * for parsing.
+       */
+      Reader( const Features &features );
+
+      /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
+       * \param document UTF-8 encoded string containing the document to read.
+       * \param root [out] Contains the root value of the document if it was
+       *             successfully parsed.
+       * \param collectComments \c true to collect comment and allow writing them back during
+       *                        serialization, \c false to discard comments.
+       *                        This parameter is ignored if Features::allowComments_
+       *                        is \c false.
+       * \return \c true if the document was successfully parsed, \c false if an error occurred.
+       */
+      bool parse( const std::string &document, 
+                  Value &root,
+                  bool collectComments = true );
+
+      /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
+       * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the document to read.
+       * \param endDoc Pointer on the end of the UTF-8 encoded string of the document to read. 
+       \               Must be >= beginDoc.
+       * \param root [out] Contains the root value of the document if it was
+       *             successfully parsed.
+       * \param collectComments \c true to collect comment and allow writing them back during
+       *                        serialization, \c false to discard comments.
+       *                        This parameter is ignored if Features::allowComments_
+       *                        is \c false.
+       * \return \c true if the document was successfully parsed, \c false if an error occurred.
+       */
+      bool parse( const char *beginDoc, const char *endDoc, 
+                  Value &root,
+                  bool collectComments = true );
+
+      /// \brief Parse from input stream.
+      /// \see Json::operator>>(std::istream&, Json::Value&).
+      bool parse( std::istream &is,
+                  Value &root,
+                  bool collectComments = true );
+
+      /** \brief Returns a user friendly string that list errors in the parsed document.
+       * \return Formatted error message with the list of errors with their location in 
+       *         the parsed document. An empty string is returned if no error occurred
+       *         during parsing.
+       * \deprecated Use getFormattedErrorMessages() instead (typo fix).
+       */
+      JSONCPP_DEPRECATED("Use getFormattedErrorMessages instead") 
+      std::string getFormatedErrorMessages() const;
+
+      /** \brief Returns a user friendly string that list errors in the parsed document.
+       * \return Formatted error message with the list of errors with their location in 
+       *         the parsed document. An empty string is returned if no error occurred
+       *         during parsing.
+       */
+      std::string getFormattedErrorMessages() const;
+
+   private:
+      enum TokenType
+      {
+         tokenEndOfStream = 0,
+         tokenObjectBegin,
+         tokenObjectEnd,
+         tokenArrayBegin,
+         tokenArrayEnd,
+         tokenString,
+         tokenNumber,
+         tokenTrue,
+         tokenFalse,
+         tokenNull,
+         tokenArraySeparator,
+         tokenMemberSeparator,
+         tokenComment,
+         tokenError
+      };
+
+      class Token
+      {
+      public:
+         TokenType type_;
+         Location start_;
+         Location end_;
+      };
+
+      class ErrorInfo
+      {
+      public:
+         Token token_;
+         std::string message_;
+         Location extra_;
+      };
+
+      typedef std::deque<ErrorInfo> Errors;
+
+      bool expectToken( TokenType type, Token &token, const char *message );
+      bool readToken( Token &token );
+      void skipSpaces();
+      bool match( Location pattern, 
+                  int patternLength );
+      bool readComment();
+      bool readCStyleComment();
+      bool readCppStyleComment();
+      bool readString();
+      void readNumber();
+      bool readValue();
+      bool readObject( Token &token );
+      bool readArray( Token &token );
+      bool decodeNumber( Token &token );
+      bool decodeString( Token &token );
+      bool decodeString( Token &token, std::string &decoded );
+      bool decodeDouble( Token &token );
+      bool decodeUnicodeCodePoint( Token &token, 
+                                   Location &current, 
+                                   Location end, 
+                                   unsigned int &unicode );
+      bool decodeUnicodeEscapeSequence( Token &token, 
+                                        Location &current, 
+                                        Location end, 
+                                        unsigned int &unicode );
+      bool addError( const std::string &message, 
+                     Token &token,
+                     Location extra = 0 );
+      bool recoverFromError( TokenType skipUntilToken );
+      bool addErrorAndRecover( const std::string &message, 
+                               Token &token,
+                               TokenType skipUntilToken );
+      void skipUntilSpace();
+      Value &currentValue();
+      Char getNextChar();
+      void getLocationLineAndColumn( Location location,
+                                     int &line,
+                                     int &column ) const;
+      std::string getLocationLineAndColumn( Location location ) const;
+      void addComment( Location begin, 
+                       Location end, 
+                       CommentPlacement placement );
+      void skipCommentTokens( Token &token );
+   
+      typedef std::stack<Value *> Nodes;
+      Nodes nodes_;
+      Errors errors_;
+      std::string document_;
+      Location begin_;
+      Location end_;
+      Location current_;
+      Location lastValueEnd_;
+      Value *lastValue_;
+      std::string commentsBefore_;
+      Features features_;
+      bool collectComments_;
+   };
+
+   /** \brief Read from 'sin' into 'root'.
+
+    Always keep comments from the input JSON.
+
+    This can be used to read a file into a particular sub-object.
+    For example:
+    \code
+    Json::Value root;
+    cin >> root["dir"]["file"];
+    cout << root;
+    \endcode
+    Result:
+    \verbatim
+    {
+    "dir": {
+        "file": {
+        // The input stream JSON would be nested here.
+        }
+    }
+    }
+    \endverbatim
+    \throw std::exception on parse error.
+    \see Json::operator<<()
+   */
+   std::istream& operator>>( std::istream&, Value& );
+
+} // namespace Json
+
+#endif // CPPTL_JSON_READER_H_INCLUDED
diff --git a/jsoncpp/include/json/value.h b/jsoncpp/include/json/value.h
new file mode 100644
index 0000000..b013c9b
--- /dev/null
+++ b/jsoncpp/include/json/value.h
@@ -0,0 +1,1109 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_H_INCLUDED
+# define CPPTL_JSON_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+# include <string>
+# include <vector>
+
+# ifndef JSON_USE_CPPTL_SMALLMAP
+#  include <map>
+# else
+#  include <cpptl/smallmap.h>
+# endif
+# ifdef JSON_USE_CPPTL
+#  include <cpptl/forwards.h>
+# endif
+
+/** \brief JSON (JavaScript Object Notation).
+ */
+namespace Json {
+
+   /** \brief Type of the value held by a Value object.
+    */
+   enum ValueType
+   {
+      nullValue = 0, ///< 'null' value
+      intValue,      ///< signed integer value
+      uintValue,     ///< unsigned integer value
+      realValue,     ///< double value
+      stringValue,   ///< UTF-8 string value
+      booleanValue,  ///< bool value
+      arrayValue,    ///< array value (ordered list)
+      objectValue    ///< object value (collection of name/value pairs).
+   };
+
+   enum CommentPlacement
+   {
+      commentBefore = 0,        ///< a comment placed on the line before a value
+      commentAfterOnSameLine,   ///< a comment just after a value on the same line
+      commentAfter,             ///< a comment on the line after a value (only make sense for root value)
+      numberOfCommentPlacement
+   };
+
+//# ifdef JSON_USE_CPPTL
+//   typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
+//   typedef CppTL::AnyEnumerator<const Value &> EnumValues;
+//# endif
+
+   /** \brief Lightweight wrapper to tag static string.
+    *
+    * Value constructor and objectValue member assignement takes advantage of the
+    * StaticString and avoid the cost of string duplication when storing the
+    * string or the member name.
+    *
+    * Example of usage:
+    * \code
+    * Json::Value aValue( StaticString("some text") );
+    * Json::Value object;
+    * static const StaticString code("code");
+    * object[code] = 1234;
+    * \endcode
+    */
+   class JSON_API StaticString
+   {
+   public:
+      explicit StaticString( const char *czstring )
+         : str_( czstring )
+      {
+      }
+
+      operator const char *() const
+      {
+         return str_;
+      }
+
+      const char *c_str() const
+      {
+         return str_;
+      }
+
+   private:
+      const char *str_;
+   };
+
+   /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
+    *
+    * This class is a discriminated union wrapper that can represents a:
+    * - signed integer [range: Value::minInt - Value::maxInt]
+    * - unsigned integer (range: 0 - Value::maxUInt)
+    * - double
+    * - UTF-8 string
+    * - boolean
+    * - 'null'
+    * - an ordered list of Value
+    * - collection of name/value pairs (javascript object)
+    *
+    * The type of the held value is represented by a #ValueType and 
+    * can be obtained using type().
+    *
+    * values of an #objectValue or #arrayValue can be accessed using operator[]() methods. 
+    * Non const methods will automatically create the a #nullValue element 
+    * if it does not exist. 
+    * The sequence of an #arrayValue will be automatically resize and initialized 
+    * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+    *
+    * The get() methods can be used to obtanis default value in the case the required element
+    * does not exist.
+    *
+    * It is possible to iterate over the list of a #objectValue values using 
+    * the getMemberNames() method.
+    */
+   class JSON_API Value 
+   {
+      friend class ValueIteratorBase;
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      friend class ValueInternalLink;
+      friend class ValueInternalMap;
+# endif
+   public:
+      typedef std::vector<std::string> Members;
+      typedef ValueIterator iterator;
+      typedef ValueConstIterator const_iterator;
+      typedef Json::UInt UInt;
+      typedef Json::Int Int;
+# if defined(JSON_HAS_INT64)
+      typedef Json::UInt64 UInt64;
+      typedef Json::Int64 Int64;
+#endif // defined(JSON_HAS_INT64)
+      typedef Json::LargestInt LargestInt;
+      typedef Json::LargestUInt LargestUInt;
+      typedef Json::ArrayIndex ArrayIndex;
+
+      static const Value null;
+      /// Minimum signed integer value that can be stored in a Json::Value.
+      static const LargestInt minLargestInt;
+      /// Maximum signed integer value that can be stored in a Json::Value.
+      static const LargestInt maxLargestInt;
+      /// Maximum unsigned integer value that can be stored in a Json::Value.
+      static const LargestUInt maxLargestUInt;
+
+      /// Minimum signed int value that can be stored in a Json::Value.
+      static const Int minInt;
+      /// Maximum signed int value that can be stored in a Json::Value.
+      static const Int maxInt;
+      /// Maximum unsigned int value that can be stored in a Json::Value.
+      static const UInt maxUInt;
+
+# if defined(JSON_HAS_INT64)
+      /// Minimum signed 64 bits int value that can be stored in a Json::Value.
+      static const Int64 minInt64;
+      /// Maximum signed 64 bits int value that can be stored in a Json::Value.
+      static const Int64 maxInt64;
+      /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
+      static const UInt64 maxUInt64;
+#endif // defined(JSON_HAS_INT64)
+
+   private:
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+# ifndef JSON_VALUE_USE_INTERNAL_MAP
+      class CZString 
+      {
+      public:
+         enum DuplicationPolicy 
+         {
+            noDuplication = 0,
+            duplicate,
+            duplicateOnCopy
+         };
+         CZString( ArrayIndex index );
+         CZString( const char *cstr, DuplicationPolicy allocate );
+         CZString( const CZString &other );
+         ~CZString();
+         CZString &operator =( const CZString &other );
+         bool operator<( const CZString &other ) const;
+         bool operator==( const CZString &other ) const;
+         ArrayIndex index() const;
+         const char *c_str() const;
+         bool isStaticString() const;
+      private:
+         void swap( CZString &other );
+         const char *cstr_;
+         ArrayIndex index_;
+      };
+
+   public:
+#  ifndef JSON_USE_CPPTL_SMALLMAP
+      typedef std::map<CZString, Value> ObjectValues;
+#  else
+      typedef CppTL::SmallMap<CZString, Value> ObjectValues;
+#  endif // ifndef JSON_USE_CPPTL_SMALLMAP
+# endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
+#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+   public:
+      /** \brief Create a default Value of the given type.
+
+        This is a very useful constructor.
+        To create an empty array, pass arrayValue.
+        To create an empty object, pass objectValue.
+        Another Value can then be set to this one by assignment.
+    This is useful since clear() and resize() will not alter types.
+
+        Examples:
+    \code
+    Json::Value null_value; // null
+    Json::Value arr_value(Json::arrayValue); // []
+    Json::Value obj_value(Json::objectValue); // {}
+    \endcode
+      */
+      Value( ValueType type = nullValue );
+      Value( Int value );
+      Value( UInt value );
+#if defined(JSON_HAS_INT64)
+      Value( Int64 value );
+      Value( UInt64 value );
+#endif // if defined(JSON_HAS_INT64)
+      Value( double value );
+      Value( const char *value );
+      Value( const char *beginValue, const char *endValue );
+      /** \brief Constructs a value from a static string.
+
+       * Like other value string constructor but do not duplicate the string for
+       * internal storage. The given string must remain alive after the call to this
+       * constructor.
+       * Example of usage:
+       * \code
+       * Json::Value aValue( StaticString("some text") );
+       * \endcode
+       */
+      Value( const StaticString &value );
+      Value( const std::string &value );
+# ifdef JSON_USE_CPPTL
+      Value( const CppTL::ConstString &value );
+# endif
+      Value( bool value );
+      Value( const Value &other );
+      ~Value();
+
+      Value &operator=( const Value &other );
+      /// Swap values.
+      /// \note Currently, comments are intentionally not swapped, for
+      /// both logic and efficiency.
+      void swap( Value &other );
+
+      ValueType type() const;
+
+      bool operator <( const Value &other ) const;
+      bool operator <=( const Value &other ) const;
+      bool operator >=( const Value &other ) const;
+      bool operator >( const Value &other ) const;
+
+      bool operator ==( const Value &other ) const;
+      bool operator !=( const Value &other ) const;
+
+      int compare( const Value &other ) const;
+
+      const char *asCString() const;
+      std::string asString() const;
+# ifdef JSON_USE_CPPTL
+      CppTL::ConstString asConstString() const;
+# endif
+      Int asInt() const;
+      UInt asUInt() const;
+#if defined(JSON_HAS_INT64)
+      Int64 asInt64() const;
+      UInt64 asUInt64() const;
+#endif // if defined(JSON_HAS_INT64)
+      LargestInt asLargestInt() const;
+      LargestUInt asLargestUInt() const;
+      float asFloat() const;
+      double asDouble() const;
+      bool asBool() const;
+
+      bool isNull() const;
+      bool isBool() const;
+      bool isInt() const;
+      bool isInt64() const;
+      bool isUInt() const;
+      bool isUInt64() const;
+      bool isIntegral() const;
+      bool isDouble() const;
+      bool isNumeric() const;
+      bool isString() const;
+      bool isArray() const;
+      bool isObject() const;
+
+      bool isConvertibleTo( ValueType other ) const;
+
+      /// Number of values in array or object
+      ArrayIndex size() const;
+
+      /// \brief Return true if empty array, empty object, or null;
+      /// otherwise, false.
+      bool empty() const;
+
+      /// Return isNull()
+      bool operator!() const;
+
+      /// Remove all object members and array elements.
+      /// \pre type() is arrayValue, objectValue, or nullValue
+      /// \post type() is unchanged
+      void clear();
+
+      /// Resize the array to size elements. 
+      /// New elements are initialized to null.
+      /// May only be called on nullValue or arrayValue.
+      /// \pre type() is arrayValue or nullValue
+      /// \post type() is arrayValue
+      void resize( ArrayIndex size );
+
+      /// Access an array element (zero based index ).
+      /// If the array contains less than index element, then null value are inserted
+      /// in the array so that its size is index+1.
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      Value &operator[]( ArrayIndex index );
+
+      /// Access an array element (zero based index ).
+      /// If the array contains less than index element, then null value are inserted
+      /// in the array so that its size is index+1.
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      Value &operator[]( int index );
+
+      /// Access an array element (zero based index )
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      const Value &operator[]( ArrayIndex index ) const;
+
+      /// Access an array element (zero based index )
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      const Value &operator[]( int index ) const;
+
+      /// If the array contains at least index+1 elements, returns the element value, 
+      /// otherwise returns defaultValue.
+      Value get( ArrayIndex index, 
+                 const Value &defaultValue ) const;
+      /// Return true if index < size().
+      bool isValidIndex( ArrayIndex index ) const;
+      /// \brief Append value to array at the end.
+      ///
+      /// Equivalent to jsonvalue[jsonvalue.size()] = value;
+      Value &append( const Value &value );
+
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const char *key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const char *key ) const;
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const std::string &key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const std::string &key ) const;
+      /** \brief Access an object value by name, create a null member if it does not exist.
+
+       * If the object as no entry for that name, then the member name used to store
+       * the new entry is not duplicated.
+       * Example of use:
+       * \code
+       * Json::Value object;
+       * static const StaticString code("code");
+       * object[code] = 1234;
+       * \endcode
+       */
+      Value &operator[]( const StaticString &key );
+# ifdef JSON_USE_CPPTL
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const CppTL::ConstString &key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const CppTL::ConstString &key ) const;
+# endif
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const char *key, 
+                 const Value &defaultValue ) const;
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const std::string &key,
+                 const Value &defaultValue ) const;
+# ifdef JSON_USE_CPPTL
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const CppTL::ConstString &key,
+                 const Value &defaultValue ) const;
+# endif
+      /// \brief Remove and return the named member.  
+      ///
+      /// Do nothing if it did not exist.
+      /// \return the removed Value, or null.
+      /// \pre type() is objectValue or nullValue
+      /// \post type() is unchanged
+      Value removeMember( const char* key );
+      /// Same as removeMember(const char*)
+      Value removeMember( const std::string &key );
+
+      /// Return true if the object has a member named key.
+      bool isMember( const char *key ) const;
+      /// Return true if the object has a member named key.
+      bool isMember( const std::string &key ) const;
+# ifdef JSON_USE_CPPTL
+      /// Return true if the object has a member named key.
+      bool isMember( const CppTL::ConstString &key ) const;
+# endif
+
+      /// \brief Return a list of the member names.
+      ///
+      /// If null, return an empty list.
+      /// \pre type() is objectValue or nullValue
+      /// \post if type() was nullValue, it remains nullValue
+      Members getMemberNames() const;
+
+//# ifdef JSON_USE_CPPTL
+//      EnumMemberNames enumMemberNames() const;
+//      EnumValues enumValues() const;
+//# endif
+
+      /// Comments must be //... or /* ... */
+      void setComment( const char *comment,
+                       CommentPlacement placement );
+      /// Comments must be //... or /* ... */
+      void setComment( const std::string &comment,
+                       CommentPlacement placement );
+      bool hasComment( CommentPlacement placement ) const;
+      /// Include delimiters and embedded newlines.
+      std::string getComment( CommentPlacement placement ) const;
+
+      std::string toStyledString() const;
+
+      const_iterator begin() const;
+      const_iterator end() const;
+
+      iterator begin();
+      iterator end();
+
+   private:
+      Value &resolveReference( const char *key, 
+                               bool isStatic );
+
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      inline bool isItemAvailable() const
+      {
+         return itemIsUsed_ == 0;
+      }
+
+      inline void setItemUsed( bool isUsed = true )
+      {
+         itemIsUsed_ = isUsed ? 1 : 0;
+      }
+
+      inline bool isMemberNameStatic() const
+      {
+         return memberNameIsStatic_ == 0;
+      }
+
+      inline void setMemberNameIsStatic( bool isStatic )
+      {
+         memberNameIsStatic_ = isStatic ? 1 : 0;
+      }
+# endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+   private:
+      struct CommentInfo
+      {
+         CommentInfo();
+         ~CommentInfo();
+
+         void setComment( const char *text );
+
+         char *comment_;
+      };
+
+      //struct MemberNamesTransform
+      //{
+      //   typedef const char *result_type;
+      //   const char *operator()( const CZString &name ) const
+      //   {
+      //      return name.c_str();
+      //   }
+      //};
+
+      union ValueHolder
+      {
+         LargestInt int_;
+         LargestUInt uint_;
+         double real_;
+         bool bool_;
+         char *string_;
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+         ValueInternalArray *array_;
+         ValueInternalMap *map_;
+#else
+         ObjectValues *map_;
+# endif
+      } value_;
+      ValueType type_ : 8;
+      int allocated_ : 1;     // Notes: if declared as bool, bitfield is useless.
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      unsigned int itemIsUsed_ : 1;      // used by the ValueInternalMap container.
+      int memberNameIsStatic_ : 1;       // used by the ValueInternalMap container.
+# endif
+      CommentInfo *comments_;
+   };
+
+
+   /** \brief Experimental and untested: represents an element of the "path" to access a node.
+    */
+   class PathArgument
+   {
+   public:
+      friend class Path;
+
+      PathArgument();
+      PathArgument( ArrayIndex index );
+      PathArgument( const char *key );
+      PathArgument( const std::string &key );
+
+   private:
+      enum Kind
+      {
+         kindNone = 0,
+         kindIndex,
+         kindKey
+      };
+      std::string key_;
+      ArrayIndex index_;
+      Kind kind_;
+   };
+
+   /** \brief Experimental and untested: represents a "path" to access a node.
+    *
+    * Syntax:
+    * - "." => root node
+    * - ".[n]" => elements at index 'n' of root node (an array value)
+    * - ".name" => member named 'name' of root node (an object value)
+    * - ".name1.name2.name3"
+    * - ".[0][1][2].name1[3]"
+    * - ".%" => member name is provided as parameter
+    * - ".[%]" => index is provied as parameter
+    */
+   class Path
+   {
+   public:
+      Path( const std::string &path,
+            const PathArgument &a1 = PathArgument(),
+            const PathArgument &a2 = PathArgument(),
+            const PathArgument &a3 = PathArgument(),
+            const PathArgument &a4 = PathArgument(),
+            const PathArgument &a5 = PathArgument() );
+
+      const Value &resolve( const Value &root ) const;
+      Value resolve( const Value &root, 
+                     const Value &defaultValue ) const;
+      /// Creates the "path" to access the specified node and returns a reference on the node.
+      Value &make( Value &root ) const;
+
+   private:
+      typedef std::vector<const PathArgument *> InArgs;
+      typedef std::vector<PathArgument> Args;
+
+      void makePath( const std::string &path,
+                     const InArgs &in );
+      void addPathInArg( const std::string &path, 
+                         const InArgs &in, 
+                         InArgs::const_iterator &itInArg, 
+                         PathArgument::Kind kind );
+      void invalidPath( const std::string &path, 
+                        int location );
+
+      Args args_;
+   };
+
+
+
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   /** \brief Allocator to customize Value internal map.
+    * Below is an example of a simple implementation (default implementation actually
+    * use memory pool for speed).
+    * \code
+      class DefaultValueMapAllocator : public ValueMapAllocator
+      {
+      public: // overridden from ValueMapAllocator
+         virtual ValueInternalMap *newMap()
+         {
+            return new ValueInternalMap();
+         }
+
+         virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
+         {
+            return new ValueInternalMap( other );
+         }
+
+         virtual void destructMap( ValueInternalMap *map )
+         {
+            delete map;
+         }
+
+         virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+         {
+            return new ValueInternalLink[size];
+         }
+
+         virtual void releaseMapBuckets( ValueInternalLink *links )
+         {
+            delete [] links;
+         }
+
+         virtual ValueInternalLink *allocateMapLink()
+         {
+            return new ValueInternalLink();
+         }
+
+         virtual void releaseMapLink( ValueInternalLink *link )
+         {
+            delete link;
+         }
+      };
+    * \endcode
+    */ 
+   class JSON_API ValueMapAllocator
+   {
+   public:
+      virtual ~ValueMapAllocator();
+      virtual ValueInternalMap *newMap() = 0;
+      virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) = 0;
+      virtual void destructMap( ValueInternalMap *map ) = 0;
+      virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) = 0;
+      virtual void releaseMapBuckets( ValueInternalLink *links ) = 0;
+      virtual ValueInternalLink *allocateMapLink() = 0;
+      virtual void releaseMapLink( ValueInternalLink *link ) = 0;
+   };
+
+   /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
+    * \internal previous_ & next_ allows for bidirectional traversal.
+    */
+   class JSON_API ValueInternalLink
+   {
+   public:
+      enum { itemPerLink = 6 };  // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
+      enum InternalFlags { 
+         flagAvailable = 0,
+         flagUsed = 1
+      };
+
+      ValueInternalLink();
+
+      ~ValueInternalLink();
+
+      Value items_[itemPerLink];
+      char *keys_[itemPerLink];
+      ValueInternalLink *previous_;
+      ValueInternalLink *next_;
+   };
+
+
+   /** \brief A linked page based hash-table implementation used internally by Value.
+    * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
+    * list in each bucket to handle collision. There is an addional twist in that
+    * each node of the collision linked list is a page containing a fixed amount of
+    * value. This provides a better compromise between memory usage and speed.
+    * 
+    * Each bucket is made up of a chained list of ValueInternalLink. The last
+    * link of a given bucket can be found in the 'previous_' field of the following bucket.
+    * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
+    * Only the last link of a bucket may contains 'available' item. The last link always
+    * contains at least one element unless is it the bucket one very first link.
+    */
+   class JSON_API ValueInternalMap
+   {
+      friend class ValueIteratorBase;
+      friend class Value;
+   public:
+      typedef unsigned int HashKey;
+      typedef unsigned int BucketIndex;
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+      struct IteratorState
+      {
+         IteratorState() 
+            : map_(0)
+            , link_(0)
+            , itemIndex_(0)
+            , bucketIndex_(0) 
+         {
+         }
+         ValueInternalMap *map_;
+         ValueInternalLink *link_;
+         BucketIndex itemIndex_;
+         BucketIndex bucketIndex_;
+      };
+# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+      ValueInternalMap();
+      ValueInternalMap( const ValueInternalMap &other );
+      ValueInternalMap &operator =( const ValueInternalMap &other );
+      ~ValueInternalMap();
+
+      void swap( ValueInternalMap &other );
+
+      BucketIndex size() const;
+
+      void clear();
+
+      bool reserveDelta( BucketIndex growth );
+
+      bool reserve( BucketIndex newItemCount );
+
+      const Value *find( const char *key ) const;
+
+      Value *find( const char *key );
+
+      Value &resolveReference( const char *key, 
+                               bool isStatic );
+
+      void remove( const char *key );
+
+      void doActualRemove( ValueInternalLink *link, 
+                           BucketIndex index,
+                           BucketIndex bucketIndex );
+
+      ValueInternalLink *&getLastLinkInBucket( BucketIndex bucketIndex );
+
+      Value &setNewItem( const char *key, 
+                         bool isStatic, 
+                         ValueInternalLink *link, 
+                         BucketIndex index );
+
+      Value &unsafeAdd( const char *key, 
+                        bool isStatic, 
+                        HashKey hashedKey );
+
+      HashKey hash( const char *key ) const;
+
+      int compare( const ValueInternalMap &other ) const;
+
+   private:
+      void makeBeginIterator( IteratorState &it ) const;
+      void makeEndIterator( IteratorState &it ) const;
+      static bool equals( const IteratorState &x, const IteratorState &other );
+      static void increment( IteratorState &iterator );
+      static void incrementBucket( IteratorState &iterator );
+      static void decrement( IteratorState &iterator );
+      static const char *key( const IteratorState &iterator );
+      static const char *key( const IteratorState &iterator, bool &isStatic );
+      static Value &value( const IteratorState &iterator );
+      static int distance( const IteratorState &x, const IteratorState &y );
+
+   private:
+      ValueInternalLink *buckets_;
+      ValueInternalLink *tailLink_;
+      BucketIndex bucketsSize_;
+      BucketIndex itemCount_;
+   };
+
+   /** \brief A simplified deque implementation used internally by Value.
+   * \internal
+   * It is based on a list of fixed "page", each page contains a fixed number of items.
+   * Instead of using a linked-list, a array of pointer is used for fast item look-up.
+   * Look-up for an element is as follow:
+   * - compute page index: pageIndex = itemIndex / itemsPerPage
+   * - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
+   *
+   * Insertion is amortized constant time (only the array containing the index of pointers
+   * need to be reallocated when items are appended).
+   */
+   class JSON_API ValueInternalArray
+   {
+      friend class Value;
+      friend class ValueIteratorBase;
+   public:
+      enum { itemsPerPage = 8 };    // should be a power of 2 for fast divide and modulo.
+      typedef Value::ArrayIndex ArrayIndex;
+      typedef unsigned int PageIndex;
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+      struct IteratorState // Must be a POD
+      {
+         IteratorState() 
+            : array_(0)
+            , currentPageIndex_(0)
+            , currentItemIndex_(0) 
+         {
+         }
+         ValueInternalArray *array_;
+         Value **currentPageIndex_;
+         unsigned int currentItemIndex_;
+      };
+# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+      ValueInternalArray();
+      ValueInternalArray( const ValueInternalArray &other );
+      ValueInternalArray &operator =( const ValueInternalArray &other );
+      ~ValueInternalArray();
+      void swap( ValueInternalArray &other );
+
+      void clear();
+      void resize( ArrayIndex newSize );
+
+      Value &resolveReference( ArrayIndex index );
+
+      Value *find( ArrayIndex index ) const;
+
+      ArrayIndex size() const;
+
+      int compare( const ValueInternalArray &other ) const;
+
+   private:
+      static bool equals( const IteratorState &x, const IteratorState &other );
+      static void increment( IteratorState &iterator );
+      static void decrement( IteratorState &iterator );
+      static Value &dereference( const IteratorState &iterator );
+      static Value &unsafeDereference( const IteratorState &iterator );
+      static int distance( const IteratorState &x, const IteratorState &y );
+      static ArrayIndex indexOf( const IteratorState &iterator );
+      void makeBeginIterator( IteratorState &it ) const;
+      void makeEndIterator( IteratorState &it ) const;
+      void makeIterator( IteratorState &it, ArrayIndex index ) const;
+
+      void makeIndexValid( ArrayIndex index );
+
+      Value **pages_;
+      ArrayIndex size_;
+      PageIndex pageCount_;
+   };
+
+   /** \brief Experimental: do not use. Allocator to customize Value internal array.
+    * Below is an example of a simple implementation (actual implementation use
+    * memory pool).
+      \code
+class DefaultValueArrayAllocator : public ValueArrayAllocator
+{
+public: // overridden from ValueArrayAllocator
+   virtual ~DefaultValueArrayAllocator()
+   {
+   }
+
+   virtual ValueInternalArray *newArray()
+   {
+      return new ValueInternalArray();
+   }
+
+   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
+   {
+      return new ValueInternalArray( other );
+   }
+
+   virtual void destruct( ValueInternalArray *array )
+   {
+      delete array;
+   }
+
+   virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                          ValueInternalArray::PageIndex &indexCount,
+                                          ValueInternalArray::PageIndex minNewIndexCount )
+   {
+      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
+      if ( minNewIndexCount > newIndexCount )
+         newIndexCount = minNewIndexCount;
+      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
+      if ( !newIndexes )
+         throw std::bad_alloc();
+      indexCount = newIndexCount;
+      indexes = static_cast<Value **>( newIndexes );
+   }
+   virtual void releaseArrayPageIndex( Value **indexes, 
+                                       ValueInternalArray::PageIndex indexCount )
+   {
+      if ( indexes )
+         free( indexes );
+   }
+
+   virtual Value *allocateArrayPage()
+   {
+      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
+   }
+
+   virtual void releaseArrayPage( Value *value )
+   {
+      if ( value )
+         free( value );
+   }
+};
+      \endcode
+    */ 
+   class JSON_API ValueArrayAllocator
+   {
+   public:
+      virtual ~ValueArrayAllocator();
+      virtual ValueInternalArray *newArray() = 0;
+      virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) = 0;
+      virtual void destructArray( ValueInternalArray *array ) = 0;
+      /** \brief Reallocate array page index.
+       * Reallocates an array of pointer on each page.
+       * \param indexes [input] pointer on the current index. May be \c NULL.
+       *                [output] pointer on the new index of at least 
+       *                         \a minNewIndexCount pages. 
+       * \param indexCount [input] current number of pages in the index.
+       *                   [output] number of page the reallocated index can handle.
+       *                            \b MUST be >= \a minNewIndexCount.
+       * \param minNewIndexCount Minimum number of page the new index must be able to
+       *                         handle.
+       */
+      virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                             ValueInternalArray::PageIndex &indexCount,
+                                             ValueInternalArray::PageIndex minNewIndexCount ) = 0;
+      virtual void releaseArrayPageIndex( Value **indexes, 
+                                          ValueInternalArray::PageIndex indexCount ) = 0;
+      virtual Value *allocateArrayPage() = 0;
+      virtual void releaseArrayPage( Value *value ) = 0;
+   };
+#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+
+   /** \brief base class for Value iterators.
+    *
+    */
+   class ValueIteratorBase
+   {
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef ValueIteratorBase SelfType;
+
+      ValueIteratorBase();
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueIteratorBase( const Value::ObjectValues::iterator &current );
+#else
+      ValueIteratorBase( const ValueInternalArray::IteratorState &state );
+      ValueIteratorBase( const ValueInternalMap::IteratorState &state );
+#endif
+
+      bool operator ==( const SelfType &other ) const
+      {
+         return isEqual( other );
+      }
+
+      bool operator !=( const SelfType &other ) const
+      {
+         return !isEqual( other );
+      }
+
+      difference_type operator -( const SelfType &other ) const
+      {
+         return computeDistance( other );
+      }
+
+      /// Return either the index or the member name of the referenced value as a Value.
+      Value key() const;
+
+      /// Return the index of the referenced Value. -1 if it is not an arrayValue.
+      UInt index() const;
+
+      /// Return the member name of the referenced Value. "" if it is not an objectValue.
+      const char *memberName() const;
+
+   protected:
+      Value &deref() const;
+
+      void increment();
+
+      void decrement();
+
+      difference_type computeDistance( const SelfType &other ) const;
+
+      bool isEqual( const SelfType &other ) const;
+
+      void copy( const SelfType &other );
+
+   private:
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      Value::ObjectValues::iterator current_;
+      // Indicates that iterator is for a null value.
+      bool isNull_;
+#else
+      union
+      {
+         ValueInternalArray::IteratorState array_;
+         ValueInternalMap::IteratorState map_;
+      } iterator_;
+      bool isArray_;
+#endif
+   };
+
+   /** \brief const iterator for object and array value.
+    *
+    */
+   class ValueConstIterator : public ValueIteratorBase
+   {
+      friend class Value;
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef const Value &reference;
+      typedef const Value *pointer;
+      typedef ValueConstIterator SelfType;
+
+      ValueConstIterator();
+   private:
+      /*! \internal Use by Value to create an iterator.
+       */
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueConstIterator( const Value::ObjectValues::iterator &current );
+#else
+      ValueConstIterator( const ValueInternalArray::IteratorState &state );
+      ValueConstIterator( const ValueInternalMap::IteratorState &state );
+#endif
+   public:
+      SelfType &operator =( const ValueIteratorBase &other );
+
+      SelfType operator++( int )
+      {
+         SelfType temp( *this );
+         ++*this;
+         return temp;
+      }
+
+      SelfType operator--( int )
+      {
+         SelfType temp( *this );
+         --*this;
+         return temp;
+      }
+
+      SelfType &operator--()
+      {
+         decrement();
+         return *this;
+      }
+
+      SelfType &operator++()
+      {
+         increment();
+         return *this;
+      }
+
+      reference operator *() const
+      {
+         return deref();
+      }
+   };
+
+
+   /** \brief Iterator for object and array value.
+    */
+   class ValueIterator : public ValueIteratorBase
+   {
+      friend class Value;
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef Value &reference;
+      typedef Value *pointer;
+      typedef ValueIterator SelfType;
+
+      ValueIterator();
+      ValueIterator( const ValueConstIterator &other );
+      ValueIterator( const ValueIterator &other );
+   private:
+      /*! \internal Use by Value to create an iterator.
+       */
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueIterator( const Value::ObjectValues::iterator &current );
+#else
+      ValueIterator( const ValueInternalArray::IteratorState &state );
+      ValueIterator( const ValueInternalMap::IteratorState &state );
+#endif
+   public:
+
+      SelfType &operator =( const SelfType &other );
+
+      SelfType operator++( int )
+      {
+         SelfType temp( *this );
+         ++*this;
+         return temp;
+      }
+
+      SelfType operator--( int )
+      {
+         SelfType temp( *this );
+         --*this;
+         return temp;
+      }
+
+      SelfType &operator--()
+      {
+         decrement();
+         return *this;
+      }
+
+      SelfType &operator++()
+      {
+         increment();
+         return *this;
+      }
+
+      reference operator *() const
+      {
+         return deref();
+      }
+   };
+
+
+} // namespace Json
+
+
+#endif // CPPTL_JSON_H_INCLUDED
diff --git a/jsoncpp/include/json/writer.h b/jsoncpp/include/json/writer.h
new file mode 100644
index 0000000..38d41e1
--- /dev/null
+++ b/jsoncpp/include/json/writer.h
@@ -0,0 +1,184 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_WRITER_H_INCLUDED
+# define JSON_WRITER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+# include <vector>
+# include <string>
+
+namespace Json {
+
+   class Value;
+
+   /** \brief Abstract class for writers.
+    */
+   class JSON_API Writer
+   {
+   public:
+      virtual ~Writer();
+
+      virtual std::string write( const Value &root ) = 0;
+   };
+
+   /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format without formatting (not human friendly).
+    *
+    * The JSON document is written in a single line. It is not intended for 'human' consumption,
+    * but may be usefull to support feature such as RPC where bandwith is limited.
+    * \sa Reader, Value
+    */
+   class JSON_API FastWriter : public Writer
+   {
+   public:
+      FastWriter();
+      virtual ~FastWriter(){}
+
+      void enableYAMLCompatibility();
+
+   public: // overridden from Writer
+      virtual std::string write( const Value &root );
+
+   private:
+      void writeValue( const Value &value );
+
+      std::string document_;
+      bool yamlCompatiblityEnabled_;
+   };
+
+   /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way.
+    *
+    * The rules for line break and indent are as follow:
+    * - Object value:
+    *     - if empty then print {} without indent and line break
+    *     - if not empty the print '{', line break & indent, print one value per line
+    *       and then unindent and line break and print '}'.
+    * - Array value:
+    *     - if empty then print [] without indent and line break
+    *     - if the array contains no object value, empty array or some other value types,
+    *       and all the values fit on one lines, then print the array on a single line.
+    *     - otherwise, it the values do not fit on one line, or the array contains
+    *       object or non empty array, then print one value per line.
+    *
+    * If the Value have comments then they are outputed according to their #CommentPlacement.
+    *
+    * \sa Reader, Value, Value::setComment()
+    */
+   class JSON_API StyledWriter: public Writer
+   {
+   public:
+      StyledWriter();
+      virtual ~StyledWriter(){}
+
+   public: // overridden from Writer
+      /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+       * \param root Value to serialize.
+       * \return String containing the JSON document that represents the root value.
+       */
+      virtual std::string write( const Value &root );
+
+   private:
+      void writeValue( const Value &value );
+      void writeArrayValue( const Value &value );
+      bool isMultineArray( const Value &value );
+      void pushValue( const std::string &value );
+      void writeIndent();
+      void writeWithIndent( const std::string &value );
+      void indent();
+      void unindent();
+      void writeCommentBeforeValue( const Value &root );
+      void writeCommentAfterValueOnSameLine( const Value &root );
+      bool hasCommentForValue( const Value &value );
+      static std::string normalizeEOL( const std::string &text );
+
+      typedef std::vector<std::string> ChildValues;
+
+      ChildValues childValues_;
+      std::string document_;
+      std::string indentString_;
+      int rightMargin_;
+      int indentSize_;
+      bool addChildValues_;
+   };
+
+   /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way,
+        to a stream rather than to a string.
+    *
+    * The rules for line break and indent are as follow:
+    * - Object value:
+    *     - if empty then print {} without indent and line break
+    *     - if not empty the print '{', line break & indent, print one value per line
+    *       and then unindent and line break and print '}'.
+    * - Array value:
+    *     - if empty then print [] without indent and line break
+    *     - if the array contains no object value, empty array or some other value types,
+    *       and all the values fit on one lines, then print the array on a single line.
+    *     - otherwise, it the values do not fit on one line, or the array contains
+    *       object or non empty array, then print one value per line.
+    *
+    * If the Value have comments then they are outputed according to their #CommentPlacement.
+    *
+    * \param indentation Each level will be indented by this amount extra.
+    * \sa Reader, Value, Value::setComment()
+    */
+   class JSON_API StyledStreamWriter
+   {
+   public:
+      StyledStreamWriter( std::string indentation="\t" );
+      ~StyledStreamWriter(){}
+
+   public:
+      /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+       * \param out Stream to write to. (Can be ostringstream, e.g.)
+       * \param root Value to serialize.
+       * \note There is no point in deriving from Writer, since write() should not return a value.
+       */
+      void write( std::ostream &out, const Value &root );
+
+   private:
+      void writeValue( const Value &value );
+      void writeArrayValue( const Value &value );
+      bool isMultineArray( const Value &value );
+      void pushValue( const std::string &value );
+      void writeIndent();
+      void writeWithIndent( const std::string &value );
+      void indent();
+      void unindent();
+      void writeCommentBeforeValue( const Value &root );
+      void writeCommentAfterValueOnSameLine( const Value &root );
+      bool hasCommentForValue( const Value &value );
+      static std::string normalizeEOL( const std::string &text );
+
+      typedef std::vector<std::string> ChildValues;
+
+      ChildValues childValues_;
+      std::ostream* document_;
+      std::string indentString_;
+      int rightMargin_;
+      std::string indentation_;
+      bool addChildValues_;
+   };
+
+# if defined(JSON_HAS_INT64)
+   std::string JSON_API valueToString( Int value );
+   std::string JSON_API valueToString( UInt value );
+# endif // if defined(JSON_HAS_INT64)
+   std::string JSON_API valueToString( LargestInt value );
+   std::string JSON_API valueToString( LargestUInt value );
+   std::string JSON_API valueToString( double value );
+   std::string JSON_API valueToString( bool value );
+   std::string JSON_API valueToQuotedString( const char *value );
+
+   /// \brief Output using the StyledStreamWriter.
+   /// \see Json::operator>>()
+   std::ostream& operator<<( std::ostream&, const Value &root );
+
+} // namespace Json
+
+
+
+#endif // JSON_WRITER_H_INCLUDED
diff --git a/jsoncpp/makerelease.py b/jsoncpp/makerelease.py
new file mode 100644
index 0000000..6b8eec3
--- /dev/null
+++ b/jsoncpp/makerelease.py
@@ -0,0 +1,380 @@
+"""Tag the sandbox for release, make source and doc tarballs.
+
+Requires Python 2.6
+
+Example of invocation (use to test the script):
+python makerelease.py --platform=msvc6,msvc71,msvc80,msvc90,mingw -ublep 0.6.0 0.7.0-dev
+
+When testing this script:
+python makerelease.py --force --retag --platform=msvc6,msvc71,msvc80,mingw -ublep test-0.6.0 test-0.6.1-dev
+
+Example of invocation when doing a release:
+python makerelease.py 0.5.0 0.6.0-dev
+"""
+import os.path
+import subprocess
+import sys
+import doxybuild
+import subprocess
+import xml.etree.ElementTree as ElementTree
+import shutil
+import urllib2
+import tempfile
+import os
+import time
+from devtools import antglob, fixeol, tarball
+import amalgamate
+
+SVN_ROOT = 'https://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/'
+SVN_TAG_ROOT = SVN_ROOT + 'tags/jsoncpp'
+SCONS_LOCAL_URL = 'http://sourceforge.net/projects/scons/files/scons-local/1.2.0/scons-local-1.2.0.tar.gz/download'
+SOURCEFORGE_PROJECT = 'jsoncpp'
+
+def set_version( version ):
+    with open('version','wb') as f:
+        f.write( version.strip() )
+
+def rmdir_if_exist( dir_path ):
+    if os.path.isdir( dir_path ):
+        shutil.rmtree( dir_path )
+
+class SVNError(Exception):
+    pass
+
+def svn_command( command, *args ):
+    cmd = ['svn', '--non-interactive', command] + list(args)
+    print 'Running:', ' '.join( cmd )
+    process = subprocess.Popen( cmd,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.STDOUT )
+    stdout = process.communicate()[0]
+    if process.returncode:
+        error = SVNError( 'SVN command failed:\n' + stdout )
+        error.returncode = process.returncode
+        raise error
+    return stdout
+
+def check_no_pending_commit():
+    """Checks that there is no pending commit in the sandbox."""
+    stdout = svn_command( 'status', '--xml' )
+    etree = ElementTree.fromstring( stdout )
+    msg = []
+    for entry in etree.getiterator( 'entry' ):
+        path = entry.get('path')
+        status = entry.find('wc-status').get('item')
+        if status != 'unversioned' and path != 'version':
+            msg.append( 'File "%s" has pending change (status="%s")' % (path, status) )
+    if msg:
+        msg.insert(0, 'Pending change to commit found in sandbox. Commit them first!' )
+    return '\n'.join( msg )
+
+def svn_join_url( base_url, suffix ):
+    if not base_url.endswith('/'):
+        base_url += '/'
+    if suffix.startswith('/'):
+        suffix = suffix[1:]
+    return base_url + suffix
+
+def svn_check_if_tag_exist( tag_url ):
+    """Checks if a tag exist.
+    Returns: True if the tag exist, False otherwise.
+    """
+    try:
+        list_stdout = svn_command( 'list', tag_url )
+    except SVNError, e:
+        if e.returncode != 1 or not str(e).find('tag_url'):
+            raise e
+        # otherwise ignore error, meaning tag does not exist
+        return False
+    return True
+
+def svn_commit( message ):
+    """Commit the sandbox, providing the specified comment.
+    """
+    svn_command( 'ci', '-m', message )
+
+def svn_tag_sandbox( tag_url, message ):
+    """Makes a tag based on the sandbox revisions.
+    """
+    svn_command( 'copy', '-m', message, '.', tag_url )
+
+def svn_remove_tag( tag_url, message ):
+    """Removes an existing tag.
+    """
+    svn_command( 'delete', '-m', message, tag_url )
+
+def svn_export( tag_url, export_dir ):
+    """Exports the tag_url revision to export_dir.
+       Target directory, including its parent is created if it does not exist.
+       If the directory export_dir exist, it is deleted before export proceed.
+    """
+    rmdir_if_exist( export_dir )
+    svn_command( 'export', tag_url, export_dir )
+
+def fix_sources_eol( dist_dir ):
+    """Set file EOL for tarball distribution.
+    """
+    print 'Preparing exported source file EOL for distribution...'
+    prune_dirs = antglob.prune_dirs + 'scons-local* ./build* ./libs ./dist'
+    win_sources = antglob.glob( dist_dir, 
+        includes = '**/*.sln **/*.vcproj',
+        prune_dirs = prune_dirs )
+    unix_sources = antglob.glob( dist_dir,
+        includes = '''**/*.h **/*.cpp **/*.inl **/*.txt **/*.dox **/*.py **/*.html **/*.in
+        sconscript *.json *.expected AUTHORS LICENSE''',
+        excludes = antglob.default_excludes + 'scons.py sconsign.py scons-*',
+        prune_dirs = prune_dirs )
+    for path in win_sources:
+        fixeol.fix_source_eol( path, is_dry_run = False, verbose = True, eol = '\r\n' )
+    for path in unix_sources:
+        fixeol.fix_source_eol( path, is_dry_run = False, verbose = True, eol = '\n' )
+
+def download( url, target_path ):
+    """Download file represented by url to target_path.
+    """
+    f = urllib2.urlopen( url )
+    try:
+        data = f.read()
+    finally:
+        f.close()
+    fout = open( target_path, 'wb' )
+    try:
+        fout.write( data )
+    finally:
+        fout.close()
+
+def check_compile( distcheck_top_dir, platform ):
+    cmd = [sys.executable, 'scons.py', 'platform=%s' % platform, 'check']
+    print 'Running:', ' '.join( cmd )
+    log_path = os.path.join( distcheck_top_dir, 'build-%s.log' % platform )
+    flog = open( log_path, 'wb' )
+    try:
+        process = subprocess.Popen( cmd,
+                                    stdout=flog,
+                                    stderr=subprocess.STDOUT,
+                                    cwd=distcheck_top_dir )
+        stdout = process.communicate()[0]
+        status = (process.returncode == 0)
+    finally:
+        flog.close()
+    return (status, log_path)
+
+def write_tempfile( content, **kwargs ):
+    fd, path = tempfile.mkstemp( **kwargs )
+    f = os.fdopen( fd, 'wt' )
+    try:
+        f.write( content )
+    finally:
+        f.close()
+    return path
+
+class SFTPError(Exception):
+    pass
+
+def run_sftp_batch( userhost, sftp, batch, retry=0 ):
+    path = write_tempfile( batch, suffix='.sftp', text=True )
+    # psftp -agent -C blep,jsoncpp@web.sourceforge.net -batch -b batch.sftp -bc
+    cmd = [sftp, '-agent', '-C', '-batch', '-b', path, '-bc', userhost]
+    error = None
+    for retry_index in xrange(0, max(1,retry)):
+        heading = retry_index == 0 and 'Running:' or 'Retrying:'
+        print heading, ' '.join( cmd )
+        process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT )
+        stdout = process.communicate()[0]
+        if process.returncode != 0:
+            error = SFTPError( 'SFTP batch failed:\n' + stdout )
+        else:
+            break
+    if error:
+        raise error
+    return stdout
+
+def sourceforge_web_synchro( sourceforge_project, doc_dir,
+                             user=None, sftp='sftp' ):
+    """Notes: does not synchronize sub-directory of doc-dir.
+    """
+    userhost = '%s,%s@web.sourceforge.net' % (user, sourceforge_project)
+    stdout = run_sftp_batch( userhost, sftp, """
+cd htdocs
+dir
+exit
+""" )
+    existing_paths = set()
+    collect = 0
+    for line in stdout.split('\n'):
+        line = line.strip()
+        if not collect and line.endswith('> dir'):
+            collect = True
+        elif collect and line.endswith('> exit'):
+            break
+        elif collect == 1:
+            collect = 2
+        elif collect == 2:
+            path = line.strip().split()[-1:]
+            if path and path[0] not in ('.', '..'):
+                existing_paths.add( path[0] )
+    upload_paths = set( [os.path.basename(p) for p in antglob.glob( doc_dir )] )
+    paths_to_remove = existing_paths - upload_paths
+    if paths_to_remove:
+        print 'Removing the following file from web:'
+        print '\n'.join( paths_to_remove )
+        stdout = run_sftp_batch( userhost, sftp, """cd htdocs
+rm %s
+exit""" % ' '.join(paths_to_remove) )
+    print 'Uploading %d files:' % len(upload_paths)
+    batch_size = 10
+    upload_paths = list(upload_paths)
+    start_time = time.time()
+    for index in xrange(0,len(upload_paths),batch_size):
+        paths = upload_paths[index:index+batch_size]
+        file_per_sec = (time.time() - start_time) / (index+1)
+        remaining_files = len(upload_paths) - index
+        remaining_sec = file_per_sec * remaining_files
+        print '%d/%d, ETA=%.1fs' % (index+1, len(upload_paths), remaining_sec)
+        run_sftp_batch( userhost, sftp, """cd htdocs
+lcd %s
+mput %s
+exit""" % (doc_dir, ' '.join(paths) ), retry=3 )
+
+def sourceforge_release_tarball( sourceforge_project, paths, user=None, sftp='sftp' ):
+    userhost = '%s,%s@frs.sourceforge.net' % (user, sourceforge_project)
+    run_sftp_batch( userhost, sftp, """
+mput %s
+exit
+""" % (' '.join(paths),) )
+
+
+def main():
+    usage = """%prog release_version next_dev_version
+Update 'version' file to release_version and commit.
+Generates the document tarball.
+Tags the sandbox revision with release_version.
+Update 'version' file to next_dev_version and commit.
+
+Performs an svn export of tag release version, and build a source tarball.    
+
+Must be started in the project top directory.
+
+Warning: --force should only be used when developping/testing the release script.
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option('--dot', dest="dot_path", action='store', default=doxybuild.find_program('dot'),
+        help="""Path to GraphViz dot tool. Must be full qualified path. [Default: %default]""")
+    parser.add_option('--doxygen', dest="doxygen_path", action='store', default=doxybuild.find_program('doxygen'),
+        help="""Path to Doxygen tool. [Default: %default]""")
+    parser.add_option('--force', dest="ignore_pending_commit", action='store_true', default=False,
+        help="""Ignore pending commit. [Default: %default]""")
+    parser.add_option('--retag', dest="retag_release", action='store_true', default=False,
+        help="""Overwrite release existing tag if it exist. [Default: %default]""")
+    parser.add_option('-p', '--platforms', dest="platforms", action='store', default='',
+        help="""Comma separated list of platform passed to scons for build check.""")
+    parser.add_option('--no-test', dest="no_test", action='store_true', default=False,
+        help="""Skips build check.""")
+    parser.add_option('--no-web', dest="no_web", action='store_true', default=False,
+        help="""Do not update web site.""")
+    parser.add_option('-u', '--upload-user', dest="user", action='store',
+                      help="""Sourceforge user for SFTP documentation upload.""")
+    parser.add_option('--sftp', dest='sftp', action='store', default=doxybuild.find_program('psftp', 'sftp'),
+                      help="""Path of the SFTP compatible binary used to upload the documentation.""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+
+    if len(args) != 2:
+        parser.error( 'release_version missing on command-line.' )
+    release_version = args[0]
+    next_version = args[1]
+
+    if not options.platforms and not options.no_test:
+        parser.error( 'You must specify either --platform or --no-test option.' )
+
+    if options.ignore_pending_commit:
+        msg = ''
+    else:
+        msg = check_no_pending_commit()
+    if not msg:
+        print 'Setting version to', release_version
+        set_version( release_version )
+        svn_commit( 'Release ' + release_version )
+        tag_url = svn_join_url( SVN_TAG_ROOT, release_version )
+        if svn_check_if_tag_exist( tag_url ):
+            if options.retag_release:
+                svn_remove_tag( tag_url, 'Overwriting previous tag' )
+            else:
+                print 'Aborting, tag %s already exist. Use --retag to overwrite it!' % tag_url
+                sys.exit( 1 )
+        svn_tag_sandbox( tag_url, 'Release ' + release_version )
+
+        print 'Generated doxygen document...'
+##        doc_dirname = r'jsoncpp-api-html-0.5.0'
+##        doc_tarball_path = r'e:\prg\vc\Lib\jsoncpp-trunk\dist\jsoncpp-api-html-0.5.0.tar.gz'
+        doc_tarball_path, doc_dirname = doxybuild.build_doc( options, make_release=True )
+        doc_distcheck_dir = 'dist/doccheck'
+        tarball.decompress( doc_tarball_path, doc_distcheck_dir )
+        doc_distcheck_top_dir = os.path.join( doc_distcheck_dir, doc_dirname )
+        
+        export_dir = 'dist/export'
+        svn_export( tag_url, export_dir )
+        fix_sources_eol( export_dir )
+        
+        source_dir = 'jsoncpp-src-' + release_version
+        source_tarball_path = 'dist/%s.tar.gz' % source_dir
+        print 'Generating source tarball to', source_tarball_path
+        tarball.make_tarball( source_tarball_path, [export_dir], export_dir, prefix_dir=source_dir )
+
+        amalgamation_tarball_path = 'dist/%s-amalgamation.tar.gz' % source_dir
+        print 'Generating amalgamation source tarball to', amalgamation_tarball_path
+        amalgamation_dir = 'dist/amalgamation'
+        amalgamate.amalgamate_source( export_dir, '%s/jsoncpp.cpp' % amalgamation_dir, 'json/json.h' )
+        amalgamation_source_dir = 'jsoncpp-src-amalgamation' + release_version
+        tarball.make_tarball( amalgamation_tarball_path, [amalgamation_dir],
+                              amalgamation_dir, prefix_dir=amalgamation_source_dir )
+
+        # Decompress source tarball, download and install scons-local
+        distcheck_dir = 'dist/distcheck'
+        distcheck_top_dir = distcheck_dir + '/' + source_dir
+        print 'Decompressing source tarball to', distcheck_dir
+        rmdir_if_exist( distcheck_dir )
+        tarball.decompress( source_tarball_path, distcheck_dir )
+        scons_local_path = 'dist/scons-local.tar.gz'
+        print 'Downloading scons-local to', scons_local_path
+        download( SCONS_LOCAL_URL, scons_local_path )
+        print 'Decompressing scons-local to', distcheck_top_dir
+        tarball.decompress( scons_local_path, distcheck_top_dir )
+
+        # Run compilation
+        print 'Compiling decompressed tarball'
+        all_build_status = True
+        for platform in options.platforms.split(','):
+            print 'Testing platform:', platform
+            build_status, log_path = check_compile( distcheck_top_dir, platform )
+            print 'see build log:', log_path
+            print build_status and '=> ok' or '=> FAILED'
+            all_build_status = all_build_status and build_status
+        if not build_status:
+            print 'Testing failed on at least one platform, aborting...'
+            svn_remove_tag( tag_url, 'Removing tag due to failed testing' )
+            sys.exit(1)
+        if options.user:
+            if not options.no_web:
+                print 'Uploading documentation using user', options.user
+                sourceforge_web_synchro( SOURCEFORGE_PROJECT, doc_distcheck_top_dir, user=options.user, sftp=options.sftp )
+                print 'Completed documentation upload'
+            print 'Uploading source and documentation tarballs for release using user', options.user
+            sourceforge_release_tarball( SOURCEFORGE_PROJECT,
+                                         [source_tarball_path, doc_tarball_path],
+                                         user=options.user, sftp=options.sftp )
+            print 'Source and doc release tarballs uploaded'
+        else:
+            print 'No upload user specified. Web site and download tarbal were not uploaded.'
+            print 'Tarball can be found at:', doc_tarball_path
+
+        # Set next version number and commit            
+        set_version( next_version )
+        svn_commit( 'Released ' + release_version )
+    else:
+        sys.stderr.write( msg + '\n' )
+ 
+if __name__ == '__main__':
+    main()
diff --git a/jsoncpp/src/jsontestrunner/main.cpp b/jsoncpp/src/jsontestrunner/main.cpp
new file mode 100644
index 0000000..74f0216
--- /dev/null
+++ b/jsoncpp/src/jsontestrunner/main.cpp
@@ -0,0 +1,293 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+/* This executable is used for testing parser/writer using real JSON files.
+ */
+
+
+#include <json/json.h>
+#include <algorithm> // sort
+#include <stdio.h>
+
+#if defined(_MSC_VER)  &&  _MSC_VER >= 1310
+# pragma warning( disable: 4996 )     // disable fopen deprecation warning
+#endif
+
+static std::string 
+normalizeFloatingPointStr( double value )
+{
+    char buffer[32];
+    sprintf( buffer, "%.16g", value );
+    buffer[sizeof(buffer)-1] = 0;
+    std::string s( buffer );
+    std::string::size_type index = s.find_last_of( "eE" );
+    if ( index != std::string::npos )
+    {
+        std::string::size_type hasSign = (s[index+1] == '+' || s[index+1] == '-') ? 1 : 0;
+        std::string::size_type exponentStartIndex = index + 1 + hasSign;
+        std::string normalized = s.substr( 0, exponentStartIndex );
+        std::string::size_type indexDigit = s.find_first_not_of( '0', exponentStartIndex );
+        std::string exponent = "0";
+        if ( indexDigit != std::string::npos ) // There is an exponent different from 0
+        {
+            exponent = s.substr( indexDigit );
+        }
+        return normalized + exponent;
+    }
+    return s;
+}
+
+
+static std::string
+readInputTestFile( const char *path )
+{
+   FILE *file = fopen( path, "rb" );
+   if ( !file )
+      return std::string("");
+   fseek( file, 0, SEEK_END );
+   long size = ftell( file );
+   fseek( file, 0, SEEK_SET );
+   std::string text;
+   char *buffer = new char[size+1];
+   buffer[size] = 0;
+   if ( fread( buffer, 1, size, file ) == (unsigned long)size )
+      text = buffer;
+   fclose( file );
+   delete[] buffer;
+   return text;
+}
+
+static void
+printValueTree( FILE *fout, Json::Value &value, const std::string &path = "." )
+{
+   switch ( value.type() )
+   {
+   case Json::nullValue:
+      fprintf( fout, "%s=null\n", path.c_str() );
+      break;
+   case Json::intValue:
+      fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestInt() ).c_str() );
+      break;
+   case Json::uintValue:
+      fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestUInt() ).c_str() );
+      break;
+   case Json::realValue:
+       fprintf( fout, "%s=%s\n", path.c_str(), normalizeFloatingPointStr(value.asDouble()).c_str() );
+      break;
+   case Json::stringValue:
+      fprintf( fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str() );
+      break;
+   case Json::booleanValue:
+      fprintf( fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false" );
+      break;
+   case Json::arrayValue:
+      {
+         fprintf( fout, "%s=[]\n", path.c_str() );
+         int size = value.size();
+         for ( int index =0; index < size; ++index )
+         {
+            static char buffer[16];
+            sprintf( buffer, "[%d]", index );
+            printValueTree( fout, value[index], path + buffer );
+         }
+      }
+      break;
+   case Json::objectValue:
+      {
+         fprintf( fout, "%s={}\n", path.c_str() );
+         Json::Value::Members members( value.getMemberNames() );
+         std::sort( members.begin(), members.end() );
+         std::string suffix = *(path.end()-1) == '.' ? "" : ".";
+         for ( Json::Value::Members::iterator it = members.begin(); 
+               it != members.end(); 
+               ++it )
+         {
+            const std::string &name = *it;
+            printValueTree( fout, value[name], path + suffix + name );
+         }
+      }
+      break;
+   default:
+      break;
+   }
+}
+
+
+static int
+parseAndSaveValueTree( const std::string &input, 
+                       const std::string &actual,
+                       const std::string &kind,
+                       Json::Value &root,
+                       const Json::Features &features,
+                       bool parseOnly )
+{
+   Json::Reader reader( features );
+   bool parsingSuccessful = reader.parse( input, root );
+   if ( !parsingSuccessful )
+   {
+      printf( "Failed to parse %s file: \n%s\n", 
+              kind.c_str(),
+              reader.getFormattedErrorMessages().c_str() );
+      return 1;
+   }
+
+   if ( !parseOnly )
+   {
+      FILE *factual = fopen( actual.c_str(), "wt" );
+      if ( !factual )
+      {
+         printf( "Failed to create %s actual file.\n", kind.c_str() );
+         return 2;
+      }
+      printValueTree( factual, root );
+      fclose( factual );
+   }
+   return 0;
+}
+
+
+static int
+rewriteValueTree( const std::string &rewritePath, 
+                  const Json::Value &root, 
+                  std::string &rewrite )
+{
+   //Json::FastWriter writer;
+   //writer.enableYAMLCompatibility();
+   Json::StyledWriter writer;
+   rewrite = writer.write( root );
+   FILE *fout = fopen( rewritePath.c_str(), "wt" );
+   if ( !fout )
+   {
+      printf( "Failed to create rewrite file: %s\n", rewritePath.c_str() );
+      return 2;
+   }
+   fprintf( fout, "%s\n", rewrite.c_str() );
+   fclose( fout );
+   return 0;
+}
+
+
+static std::string
+removeSuffix( const std::string &path, 
+              const std::string &extension )
+{
+   if ( extension.length() >= path.length() )
+      return std::string("");
+   std::string suffix = path.substr( path.length() - extension.length() );
+   if ( suffix != extension )
+      return std::string("");
+   return path.substr( 0, path.length() - extension.length() );
+}
+
+
+static void
+printConfig()
+{
+   // Print the configuration used to compile JsonCpp
+#if defined(JSON_NO_INT64)
+   printf( "JSON_NO_INT64=1\n" );
+#else
+   printf( "JSON_NO_INT64=0\n" );
+#endif
+}
+
+
+static int 
+printUsage( const char *argv[] )
+{
+   printf( "Usage: %s [--strict] input-json-file", argv[0] );
+   return 3;
+}
+
+
+int
+parseCommandLine( int argc, const char *argv[], 
+                  Json::Features &features, std::string &path,
+                  bool &parseOnly )
+{
+   parseOnly = false;
+   if ( argc < 2 )
+   {
+      return printUsage( argv );
+   }
+
+   int index = 1;
+   if ( std::string(argv[1]) == "--json-checker" )
+   {
+      features = Json::Features::strictMode();
+      parseOnly = true;
+      ++index;
+   }
+
+   if ( std::string(argv[1]) == "--json-config" )
+   {
+      printConfig();
+      return 3;
+   }
+
+   if ( index == argc  ||  index + 1 < argc )
+   {
+      return printUsage( argv );
+   }
+
+   path = argv[index];
+   return 0;
+}
+
+
+int main( int argc, const char *argv[] )
+{
+   std::string path;
+   Json::Features features;
+   bool parseOnly;
+   int exitCode = parseCommandLine( argc, argv, features, path, parseOnly );
+   if ( exitCode != 0 )
+   {
+      return exitCode;
+   }
+
+   try
+   {
+      std::string input = readInputTestFile( path.c_str() );
+      if ( input.empty() )
+      {
+         printf( "Failed to read input or empty input: %s\n", path.c_str() );
+         return 3;
+      }
+
+      std::string basePath = removeSuffix( argv[1], ".json" );
+      if ( !parseOnly  &&  basePath.empty() )
+      {
+         printf( "Bad input path. Path does not end with '.expected':\n%s\n", path.c_str() );
+         return 3;
+      }
+
+      std::string actualPath = basePath + ".actual";
+      std::string rewritePath = basePath + ".rewrite";
+      std::string rewriteActualPath = basePath + ".actual-rewrite";
+
+      Json::Value root;
+      exitCode = parseAndSaveValueTree( input, actualPath, "input", root, features, parseOnly );
+      if ( exitCode == 0  &&  !parseOnly )
+      {
+         std::string rewrite;
+         exitCode = rewriteValueTree( rewritePath, root, rewrite );
+         if ( exitCode == 0 )
+         {
+            Json::Value rewriteRoot;
+            exitCode = parseAndSaveValueTree( rewrite, rewriteActualPath, 
+               "rewrite", rewriteRoot, features, parseOnly );
+         }
+      }
+   }
+   catch ( const std::exception &e )
+   {
+      printf( "Unhandled exception:\n%s\n", e.what() );
+      exitCode = 1;
+   }
+
+   return exitCode;
+}
+
diff --git a/jsoncpp/src/jsontestrunner/sconscript b/jsoncpp/src/jsontestrunner/sconscript
new file mode 100644
index 0000000..6e68e31
--- /dev/null
+++ b/jsoncpp/src/jsontestrunner/sconscript
@@ -0,0 +1,9 @@
+Import( 'env_testing buildJSONTests' )
+
+buildJSONTests( env_testing, Split( """
+    main.cpp
+     """ ),
+    'jsontestrunner' )
+
+# For 'check' to work, 'libs' must be built first.
+env_testing.Depends('jsontestrunner', '#libs')
diff --git a/jsoncpp/src/lib_json/json_batchallocator.h b/jsoncpp/src/lib_json/json_batchallocator.h
new file mode 100644
index 0000000..2a7c024
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_batchallocator.h
@@ -0,0 +1,127 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
+# define JSONCPP_BATCHALLOCATOR_H_INCLUDED
+
+# include <stdlib.h>
+# include <assert.h>
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+namespace Json {
+
+/* Fast memory allocator.
+ *
+ * This memory allocator allocates memory for a batch of object (specified by
+ * the page size, the number of object in each page).
+ *
+ * It does not allow the destruction of a single object. All the allocated objects
+ * can be destroyed at once. The memory can be either released or reused for future
+ * allocation.
+ * 
+ * The in-place new operator must be used to construct the object using the pointer
+ * returned by allocate.
+ */
+template<typename AllocatedType
+        ,const unsigned int objectPerAllocation>
+class BatchAllocator
+{
+public:
+   BatchAllocator( unsigned int objectsPerPage = 255 )
+      : freeHead_( 0 )
+      , objectsPerPage_( objectsPerPage )
+   {
+//      printf( "Size: %d => %s\n", sizeof(AllocatedType), typeid(AllocatedType).name() );
+      assert( sizeof(AllocatedType) * objectPerAllocation >= sizeof(AllocatedType *) ); // We must be able to store a slist in the object free space.
+      assert( objectsPerPage >= 16 );
+      batches_ = allocateBatch( 0 );   // allocated a dummy page
+      currentBatch_ = batches_;
+   }
+
+   ~BatchAllocator()
+   {
+      for ( BatchInfo *batch = batches_; batch;  )
+      {
+         BatchInfo *nextBatch = batch->next_;
+         free( batch );
+         batch = nextBatch;
+      }
+   }
+
+   /// allocate space for an array of objectPerAllocation object.
+   /// @warning it is the responsability of the caller to call objects constructors.
+   AllocatedType *allocate()
+   {
+      if ( freeHead_ ) // returns node from free list.
+      {
+         AllocatedType *object = freeHead_;
+         freeHead_ = *(AllocatedType **)object;
+         return object;
+      }
+      if ( currentBatch_->used_ == currentBatch_->end_ )
+      {
+         currentBatch_ = currentBatch_->next_;
+         while ( currentBatch_  &&  currentBatch_->used_ == currentBatch_->end_ )
+            currentBatch_ = currentBatch_->next_;
+
+         if ( !currentBatch_  ) // no free batch found, allocate a new one
+         { 
+            currentBatch_ = allocateBatch( objectsPerPage_ );
+            currentBatch_->next_ = batches_; // insert at the head of the list
+            batches_ = currentBatch_;
+         }
+      }
+      AllocatedType *allocated = currentBatch_->used_;
+      currentBatch_->used_ += objectPerAllocation;
+      return allocated;
+   }
+
+   /// Release the object.
+   /// @warning it is the responsability of the caller to actually destruct the object.
+   void release( AllocatedType *object )
+   {
+      assert( object != 0 );
+      *(AllocatedType **)object = freeHead_;
+      freeHead_ = object;
+   }
+
+private:
+   struct BatchInfo
+   {
+      BatchInfo *next_;
+      AllocatedType *used_;
+      AllocatedType *end_;
+      AllocatedType buffer_[objectPerAllocation];
+   };
+
+   // disabled copy constructor and assignement operator.
+   BatchAllocator( const BatchAllocator & );
+   void operator =( const BatchAllocator &);
+
+   static BatchInfo *allocateBatch( unsigned int objectsPerPage )
+   {
+      const unsigned int mallocSize = sizeof(BatchInfo) - sizeof(AllocatedType)* objectPerAllocation
+                                + sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
+      BatchInfo *batch = static_cast<BatchInfo*>( malloc( mallocSize ) );
+      batch->next_ = 0;
+      batch->used_ = batch->buffer_;
+      batch->end_ = batch->buffer_ + objectsPerPage;
+      return batch;
+   }
+
+   BatchInfo *batches_;
+   BatchInfo *currentBatch_;
+   /// Head of a single linked list within the allocated space of freeed object
+   AllocatedType *freeHead_;
+   unsigned int objectsPerPage_;
+};
+
+
+} // namespace Json
+
+# endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
+
+#endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
diff --git a/jsoncpp/src/lib_json/json_internalarray.inl b/jsoncpp/src/lib_json/json_internalarray.inl
new file mode 100644
index 0000000..5e8b8ef
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_internalarray.inl
@@ -0,0 +1,454 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+// included by json_value.cpp
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueInternalArray
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueArrayAllocator::~ValueArrayAllocator()
+{
+}
+
+// //////////////////////////////////////////////////////////////////
+// class DefaultValueArrayAllocator
+// //////////////////////////////////////////////////////////////////
+#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+class DefaultValueArrayAllocator : public ValueArrayAllocator
+{
+public: // overridden from ValueArrayAllocator
+   virtual ~DefaultValueArrayAllocator()
+   {
+   }
+
+   virtual ValueInternalArray *newArray()
+   {
+      return new ValueInternalArray();
+   }
+
+   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
+   {
+      return new ValueInternalArray( other );
+   }
+
+   virtual void destructArray( ValueInternalArray *array )
+   {
+      delete array;
+   }
+
+   virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                          ValueInternalArray::PageIndex &indexCount,
+                                          ValueInternalArray::PageIndex minNewIndexCount )
+   {
+      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
+      if ( minNewIndexCount > newIndexCount )
+         newIndexCount = minNewIndexCount;
+      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
+      JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
+      indexCount = newIndexCount;
+      indexes = static_cast<Value **>( newIndexes );
+   }
+   virtual void releaseArrayPageIndex( Value **indexes, 
+                                       ValueInternalArray::PageIndex indexCount )
+   {
+      if ( indexes )
+         free( indexes );
+   }
+
+   virtual Value *allocateArrayPage()
+   {
+      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
+   }
+
+   virtual void releaseArrayPage( Value *value )
+   {
+      if ( value )
+         free( value );
+   }
+};
+
+#else // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+/// @todo make this thread-safe (lock when accessign batch allocator)
+class DefaultValueArrayAllocator : public ValueArrayAllocator
+{
+public: // overridden from ValueArrayAllocator
+   virtual ~DefaultValueArrayAllocator()
+   {
+   }
+
+   virtual ValueInternalArray *newArray()
+   {
+      ValueInternalArray *array = arraysAllocator_.allocate();
+      new (array) ValueInternalArray(); // placement new
+      return array;
+   }
+
+   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
+   {
+      ValueInternalArray *array = arraysAllocator_.allocate();
+      new (array) ValueInternalArray( other ); // placement new
+      return array;
+   }
+
+   virtual void destructArray( ValueInternalArray *array )
+   {
+      if ( array )
+      {
+         array->~ValueInternalArray();
+         arraysAllocator_.release( array );
+      }
+   }
+
+   virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                          ValueInternalArray::PageIndex &indexCount,
+                                          ValueInternalArray::PageIndex minNewIndexCount )
+   {
+      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
+      if ( minNewIndexCount > newIndexCount )
+         newIndexCount = minNewIndexCount;
+      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
+      JSON_ASSERT_MESSAGE(newIndexes, "Couldn't realloc.");
+      indexCount = newIndexCount;
+      indexes = static_cast<Value **>( newIndexes );
+   }
+   virtual void releaseArrayPageIndex( Value **indexes, 
+                                       ValueInternalArray::PageIndex indexCount )
+   {
+      if ( indexes )
+         free( indexes );
+   }
+
+   virtual Value *allocateArrayPage()
+   {
+      return static_cast<Value *>( pagesAllocator_.allocate() );
+   }
+
+   virtual void releaseArrayPage( Value *value )
+   {
+      if ( value )
+         pagesAllocator_.release( value );
+   }
+private:
+   BatchAllocator<ValueInternalArray,1> arraysAllocator_;
+   BatchAllocator<Value,ValueInternalArray::itemsPerPage> pagesAllocator_;
+};
+#endif // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+
+static ValueArrayAllocator *&arrayAllocator()
+{
+   static DefaultValueArrayAllocator defaultAllocator;
+   static ValueArrayAllocator *arrayAllocator = &defaultAllocator;
+   return arrayAllocator;
+}
+
+static struct DummyArrayAllocatorInitializer {
+   DummyArrayAllocatorInitializer() 
+   {
+      arrayAllocator();      // ensure arrayAllocator() statics are initialized before main().
+   }
+} dummyArrayAllocatorInitializer;
+
+// //////////////////////////////////////////////////////////////////
+// class ValueInternalArray
+// //////////////////////////////////////////////////////////////////
+bool 
+ValueInternalArray::equals( const IteratorState &x, 
+                            const IteratorState &other )
+{
+   return x.array_ == other.array_  
+          &&  x.currentItemIndex_ == other.currentItemIndex_  
+          &&  x.currentPageIndex_ == other.currentPageIndex_;
+}
+
+
+void 
+ValueInternalArray::increment( IteratorState &it )
+{
+   JSON_ASSERT_MESSAGE( it.array_  &&
+      (it.currentPageIndex_ - it.array_->pages_)*itemsPerPage + it.currentItemIndex_
+      != it.array_->size_,
+      "ValueInternalArray::increment(): moving iterator beyond end" );
+   ++(it.currentItemIndex_);
+   if ( it.currentItemIndex_ == itemsPerPage )
+   {
+      it.currentItemIndex_ = 0;
+      ++(it.currentPageIndex_);
+   }
+}
+
+
+void 
+ValueInternalArray::decrement( IteratorState &it )
+{
+   JSON_ASSERT_MESSAGE( it.array_  &&  it.currentPageIndex_ == it.array_->pages_ 
+                        &&  it.currentItemIndex_ == 0,
+      "ValueInternalArray::decrement(): moving iterator beyond end" );
+   if ( it.currentItemIndex_ == 0 )
+   {
+      it.currentItemIndex_ = itemsPerPage-1;
+      --(it.currentPageIndex_);
+   }
+   else
+   {
+      --(it.currentItemIndex_);
+   }
+}
+
+
+Value &
+ValueInternalArray::unsafeDereference( const IteratorState &it )
+{
+   return (*(it.currentPageIndex_))[it.currentItemIndex_];
+}
+
+
+Value &
+ValueInternalArray::dereference( const IteratorState &it )
+{
+   JSON_ASSERT_MESSAGE( it.array_  &&
+      (it.currentPageIndex_ - it.array_->pages_)*itemsPerPage + it.currentItemIndex_
+      < it.array_->size_,
+      "ValueInternalArray::dereference(): dereferencing invalid iterator" );
+   return unsafeDereference( it );
+}
+
+void 
+ValueInternalArray::makeBeginIterator( IteratorState &it ) const
+{
+   it.array_ = const_cast<ValueInternalArray *>( this );
+   it.currentItemIndex_ = 0;
+   it.currentPageIndex_ = pages_;
+}
+
+
+void 
+ValueInternalArray::makeIterator( IteratorState &it, ArrayIndex index ) const
+{
+   it.array_ = const_cast<ValueInternalArray *>( this );
+   it.currentItemIndex_ = index % itemsPerPage;
+   it.currentPageIndex_ = pages_ + index / itemsPerPage;
+}
+
+
+void 
+ValueInternalArray::makeEndIterator( IteratorState &it ) const
+{
+   makeIterator( it, size_ );
+}
+
+
+ValueInternalArray::ValueInternalArray()
+   : pages_( 0 )
+   , size_( 0 )
+   , pageCount_( 0 )
+{
+}
+
+
+ValueInternalArray::ValueInternalArray( const ValueInternalArray &other )
+   : pages_( 0 )
+   , size_( other.size_ )
+   , pageCount_( 0 )
+{
+   PageIndex minNewPages = other.size_ / itemsPerPage;
+   arrayAllocator()->reallocateArrayPageIndex( pages_, pageCount_, minNewPages );
+   JSON_ASSERT_MESSAGE( pageCount_ >= minNewPages, 
+                        "ValueInternalArray::reserve(): bad reallocation" );
+   IteratorState itOther;
+   other.makeBeginIterator( itOther );
+   Value *value;
+   for ( ArrayIndex index = 0; index < size_; ++index, increment(itOther) )
+   {
+      if ( index % itemsPerPage == 0 )
+      {
+         PageIndex pageIndex = index / itemsPerPage;
+         value = arrayAllocator()->allocateArrayPage();
+         pages_[pageIndex] = value;
+      }
+      new (value) Value( dereference( itOther ) );
+   }
+}
+
+
+ValueInternalArray &
+ValueInternalArray::operator =( const ValueInternalArray &other )
+{
+   ValueInternalArray temp( other );
+   swap( temp );
+   return *this;
+}
+
+
+ValueInternalArray::~ValueInternalArray()
+{
+   // destroy all constructed items
+   IteratorState it;
+   IteratorState itEnd;
+   makeBeginIterator( it);
+   makeEndIterator( itEnd );
+   for ( ; !equals(it,itEnd); increment(it) )
+   {
+      Value *value = &dereference(it);
+      value->~Value();
+   }
+   // release all pages
+   PageIndex lastPageIndex = size_ / itemsPerPage;
+   for ( PageIndex pageIndex = 0; pageIndex < lastPageIndex; ++pageIndex )
+      arrayAllocator()->releaseArrayPage( pages_[pageIndex] );
+   // release pages index
+   arrayAllocator()->releaseArrayPageIndex( pages_, pageCount_ );
+}
+
+
+void 
+ValueInternalArray::swap( ValueInternalArray &other )
+{
+   Value **tempPages = pages_;
+   pages_ = other.pages_;
+   other.pages_ = tempPages;
+   ArrayIndex tempSize = size_;
+   size_ = other.size_;
+   other.size_ = tempSize;
+   PageIndex tempPageCount = pageCount_;
+   pageCount_ = other.pageCount_;
+   other.pageCount_ = tempPageCount;
+}
+
+void 
+ValueInternalArray::clear()
+{
+   ValueInternalArray dummy;
+   swap( dummy );
+}
+
+
+void 
+ValueInternalArray::resize( ArrayIndex newSize )
+{
+   if ( newSize == 0 )
+      clear();
+   else if ( newSize < size_ )
+   {
+      IteratorState it;
+      IteratorState itEnd;
+      makeIterator( it, newSize );
+      makeIterator( itEnd, size_ );
+      for ( ; !equals(it,itEnd); increment(it) )
+      {
+         Value *value = &dereference(it);
+         value->~Value();
+      }
+      PageIndex pageIndex = (newSize + itemsPerPage - 1) / itemsPerPage;
+      PageIndex lastPageIndex = size_ / itemsPerPage;
+      for ( ; pageIndex < lastPageIndex; ++pageIndex )
+         arrayAllocator()->releaseArrayPage( pages_[pageIndex] );
+      size_ = newSize;
+   }
+   else if ( newSize > size_ )
+      resolveReference( newSize );
+}
+
+
+void 
+ValueInternalArray::makeIndexValid( ArrayIndex index )
+{
+   // Need to enlarge page index ?
+   if ( index >= pageCount_ * itemsPerPage )
+   {
+      PageIndex minNewPages = (index + 1) / itemsPerPage;
+      arrayAllocator()->reallocateArrayPageIndex( pages_, pageCount_, minNewPages );
+      JSON_ASSERT_MESSAGE( pageCount_ >= minNewPages, "ValueInternalArray::reserve(): bad reallocation" );
+   }
+
+   // Need to allocate new pages ?
+   ArrayIndex nextPageIndex = 
+      (size_ % itemsPerPage) != 0 ? size_ - (size_%itemsPerPage) + itemsPerPage
+                                  : size_;
+   if ( nextPageIndex <= index )
+   {
+      PageIndex pageIndex = nextPageIndex / itemsPerPage;
+      PageIndex pageToAllocate = (index - nextPageIndex) / itemsPerPage + 1;
+      for ( ; pageToAllocate-- > 0; ++pageIndex )
+         pages_[pageIndex] = arrayAllocator()->allocateArrayPage();
+   }
+
+   // Initialize all new entries
+   IteratorState it;
+   IteratorState itEnd;
+   makeIterator( it, size_ );
+   size_ = index + 1;
+   makeIterator( itEnd, size_ );
+   for ( ; !equals(it,itEnd); increment(it) )
+   {
+      Value *value = &dereference(it);
+      new (value) Value(); // Construct a default value using placement new
+   }
+}
+
+Value &
+ValueInternalArray::resolveReference( ArrayIndex index )
+{
+   if ( index >= size_ )
+      makeIndexValid( index );
+   return pages_[index/itemsPerPage][index%itemsPerPage];
+}
+
+Value *
+ValueInternalArray::find( ArrayIndex index ) const
+{
+   if ( index >= size_ )
+      return 0;
+   return &(pages_[index/itemsPerPage][index%itemsPerPage]);
+}
+
+ValueInternalArray::ArrayIndex 
+ValueInternalArray::size() const
+{
+   return size_;
+}
+
+int 
+ValueInternalArray::distance( const IteratorState &x, const IteratorState &y )
+{
+   return indexOf(y) - indexOf(x);
+}
+
+
+ValueInternalArray::ArrayIndex 
+ValueInternalArray::indexOf( const IteratorState &iterator )
+{
+   if ( !iterator.array_ )
+      return ArrayIndex(-1);
+   return ArrayIndex(
+      (iterator.currentPageIndex_ - iterator.array_->pages_) * itemsPerPage 
+      + iterator.currentItemIndex_ );
+}
+
+
+int 
+ValueInternalArray::compare( const ValueInternalArray &other ) const
+{
+   int sizeDiff( size_ - other.size_ );
+   if ( sizeDiff != 0 )
+      return sizeDiff;
+   
+   for ( ArrayIndex index =0; index < size_; ++index )
+   {
+      int diff = pages_[index/itemsPerPage][index%itemsPerPage].compare( 
+         other.pages_[index/itemsPerPage][index%itemsPerPage] );
+      if ( diff != 0 )
+         return diff;
+   }
+   return 0;
+}
+
+} // namespace Json
diff --git a/jsoncpp/src/lib_json/json_internalmap.inl b/jsoncpp/src/lib_json/json_internalmap.inl
new file mode 100644
index 0000000..f2fa160
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_internalmap.inl
@@ -0,0 +1,615 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+// included by json_value.cpp
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueInternalMap
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+/** \internal MUST be safely initialized using memset( this, 0, sizeof(ValueInternalLink) );
+   * This optimization is used by the fast allocator.
+   */
+ValueInternalLink::ValueInternalLink()
+   : previous_( 0 )
+   , next_( 0 )
+{
+}
+
+ValueInternalLink::~ValueInternalLink()
+{ 
+   for ( int index =0; index < itemPerLink; ++index )
+   {
+      if ( !items_[index].isItemAvailable() )
+      {
+         if ( !items_[index].isMemberNameStatic() )
+            free( keys_[index] );
+      }
+      else
+         break;
+   }
+}
+
+
+
+ValueMapAllocator::~ValueMapAllocator()
+{
+}
+
+#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+class DefaultValueMapAllocator : public ValueMapAllocator
+{
+public: // overridden from ValueMapAllocator
+   virtual ValueInternalMap *newMap()
+   {
+      return new ValueInternalMap();
+   }
+
+   virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
+   {
+      return new ValueInternalMap( other );
+   }
+
+   virtual void destructMap( ValueInternalMap *map )
+   {
+      delete map;
+   }
+
+   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+   {
+      return new ValueInternalLink[size];
+   }
+
+   virtual void releaseMapBuckets( ValueInternalLink *links )
+   {
+      delete [] links;
+   }
+
+   virtual ValueInternalLink *allocateMapLink()
+   {
+      return new ValueInternalLink();
+   }
+
+   virtual void releaseMapLink( ValueInternalLink *link )
+   {
+      delete link;
+   }
+};
+#else
+/// @todo make this thread-safe (lock when accessign batch allocator)
+class DefaultValueMapAllocator : public ValueMapAllocator
+{
+public: // overridden from ValueMapAllocator
+   virtual ValueInternalMap *newMap()
+   {
+      ValueInternalMap *map = mapsAllocator_.allocate();
+      new (map) ValueInternalMap(); // placement new
+      return map;
+   }
+
+   virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
+   {
+      ValueInternalMap *map = mapsAllocator_.allocate();
+      new (map) ValueInternalMap( other ); // placement new
+      return map;
+   }
+
+   virtual void destructMap( ValueInternalMap *map )
+   {
+      if ( map )
+      {
+         map->~ValueInternalMap();
+         mapsAllocator_.release( map );
+      }
+   }
+
+   virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+   {
+      return new ValueInternalLink[size];
+   }
+
+   virtual void releaseMapBuckets( ValueInternalLink *links )
+   {
+      delete [] links;
+   }
+
+   virtual ValueInternalLink *allocateMapLink()
+   {
+      ValueInternalLink *link = linksAllocator_.allocate();
+      memset( link, 0, sizeof(ValueInternalLink) );
+      return link;
+   }
+
+   virtual void releaseMapLink( ValueInternalLink *link )
+   {
+      link->~ValueInternalLink();
+      linksAllocator_.release( link );
+   }
+private:
+   BatchAllocator<ValueInternalMap,1> mapsAllocator_;
+   BatchAllocator<ValueInternalLink,1> linksAllocator_;
+};
+#endif
+
+static ValueMapAllocator *&mapAllocator()
+{
+   static DefaultValueMapAllocator defaultAllocator;
+   static ValueMapAllocator *mapAllocator = &defaultAllocator;
+   return mapAllocator;
+}
+
+static struct DummyMapAllocatorInitializer {
+   DummyMapAllocatorInitializer() 
+   {
+      mapAllocator();      // ensure mapAllocator() statics are initialized before main().
+   }
+} dummyMapAllocatorInitializer;
+
+
+
+// h(K) = value * K >> w ; with w = 32 & K prime w.r.t. 2^32.
+
+/*
+use linked list hash map. 
+buckets array is a container.
+linked list element contains 6 key/values. (memory = (16+4) * 6 + 4 = 124)
+value have extra state: valid, available, deleted
+*/
+
+
+ValueInternalMap::ValueInternalMap()
+   : buckets_( 0 )
+   , tailLink_( 0 )
+   , bucketsSize_( 0 )
+   , itemCount_( 0 )
+{
+}
+
+
+ValueInternalMap::ValueInternalMap( const ValueInternalMap &other )
+   : buckets_( 0 )
+   , tailLink_( 0 )
+   , bucketsSize_( 0 )
+   , itemCount_( 0 )
+{
+   reserve( other.itemCount_ );
+   IteratorState it;
+   IteratorState itEnd;
+   other.makeBeginIterator( it );
+   other.makeEndIterator( itEnd );
+   for ( ; !equals(it,itEnd); increment(it) )
+   {
+      bool isStatic;
+      const char *memberName = key( it, isStatic );
+      const Value &aValue = value( it );
+      resolveReference(memberName, isStatic) = aValue;
+   }
+}
+
+
+ValueInternalMap &
+ValueInternalMap::operator =( const ValueInternalMap &other )
+{
+   ValueInternalMap dummy( other );
+   swap( dummy );
+   return *this;
+}
+
+
+ValueInternalMap::~ValueInternalMap()
+{
+   if ( buckets_ )
+   {
+      for ( BucketIndex bucketIndex =0; bucketIndex < bucketsSize_; ++bucketIndex )
+      {
+         ValueInternalLink *link = buckets_[bucketIndex].next_;
+         while ( link )
+         {
+            ValueInternalLink *linkToRelease = link;
+            link = link->next_;
+            mapAllocator()->releaseMapLink( linkToRelease );
+         }
+      }
+      mapAllocator()->releaseMapBuckets( buckets_ );
+   }
+}
+
+
+void 
+ValueInternalMap::swap( ValueInternalMap &other )
+{
+   ValueInternalLink *tempBuckets = buckets_;
+   buckets_ = other.buckets_;
+   other.buckets_ = tempBuckets;
+   ValueInternalLink *tempTailLink = tailLink_;
+   tailLink_ = other.tailLink_;
+   other.tailLink_ = tempTailLink;
+   BucketIndex tempBucketsSize = bucketsSize_;
+   bucketsSize_ = other.bucketsSize_;
+   other.bucketsSize_ = tempBucketsSize;
+   BucketIndex tempItemCount = itemCount_;
+   itemCount_ = other.itemCount_;
+   other.itemCount_ = tempItemCount;
+}
+
+
+void 
+ValueInternalMap::clear()
+{
+   ValueInternalMap dummy;
+   swap( dummy );
+}
+
+
+ValueInternalMap::BucketIndex 
+ValueInternalMap::size() const
+{
+   return itemCount_;
+}
+
+bool 
+ValueInternalMap::reserveDelta( BucketIndex growth )
+{
+   return reserve( itemCount_ + growth );
+}
+
+bool 
+ValueInternalMap::reserve( BucketIndex newItemCount )
+{
+   if ( !buckets_  &&  newItemCount > 0 )
+   {
+      buckets_ = mapAllocator()->allocateMapBuckets( 1 );
+      bucketsSize_ = 1;
+      tailLink_ = &buckets_[0];
+   }
+//   BucketIndex idealBucketCount = (newItemCount + ValueInternalLink::itemPerLink) / ValueInternalLink::itemPerLink;
+   return true;
+}
+
+
+const Value *
+ValueInternalMap::find( const char *key ) const
+{
+   if ( !bucketsSize_ )
+      return 0;
+   HashKey hashedKey = hash( key );
+   BucketIndex bucketIndex = hashedKey % bucketsSize_;
+   for ( const ValueInternalLink *current = &buckets_[bucketIndex]; 
+         current != 0; 
+         current = current->next_ )
+   {
+      for ( BucketIndex index=0; index < ValueInternalLink::itemPerLink; ++index )
+      {
+         if ( current->items_[index].isItemAvailable() )
+            return 0;
+         if ( strcmp( key, current->keys_[index] ) == 0 )
+            return &current->items_[index];
+      }
+   }
+   return 0;
+}
+
+
+Value *
+ValueInternalMap::find( const char *key )
+{
+   const ValueInternalMap *constThis = this;
+   return const_cast<Value *>( constThis->find( key ) );
+}
+
+
+Value &
+ValueInternalMap::resolveReference( const char *key,
+                                    bool isStatic )
+{
+   HashKey hashedKey = hash( key );
+   if ( bucketsSize_ )
+   {
+      BucketIndex bucketIndex = hashedKey % bucketsSize_;
+      ValueInternalLink **previous = 0;
+      BucketIndex index;
+      for ( ValueInternalLink *current = &buckets_[bucketIndex]; 
+            current != 0; 
+            previous = &current->next_, current = current->next_ )
+      {
+         for ( index=0; index < ValueInternalLink::itemPerLink; ++index )
+         {
+            if ( current->items_[index].isItemAvailable() )
+               return setNewItem( key, isStatic, current, index );
+            if ( strcmp( key, current->keys_[index] ) == 0 )
+               return current->items_[index];
+         }
+      }
+   }
+
+   reserveDelta( 1 );
+   return unsafeAdd( key, isStatic, hashedKey );
+}
+
+
+void 
+ValueInternalMap::remove( const char *key )
+{
+   HashKey hashedKey = hash( key );
+   if ( !bucketsSize_ )
+      return;
+   BucketIndex bucketIndex = hashedKey % bucketsSize_;
+   for ( ValueInternalLink *link = &buckets_[bucketIndex]; 
+         link != 0; 
+         link = link->next_ )
+   {
+      BucketIndex index;
+      for ( index =0; index < ValueInternalLink::itemPerLink; ++index )
+      {
+         if ( link->items_[index].isItemAvailable() )
+            return;
+         if ( strcmp( key, link->keys_[index] ) == 0 )
+         {
+            doActualRemove( link, index, bucketIndex );
+            return;
+         }
+      }
+   }
+}
+
+void 
+ValueInternalMap::doActualRemove( ValueInternalLink *link, 
+                                  BucketIndex index,
+                                  BucketIndex bucketIndex )
+{
+   // find last item of the bucket and swap it with the 'removed' one.
+   // set removed items flags to 'available'.
+   // if last page only contains 'available' items, then desallocate it (it's empty)
+   ValueInternalLink *&lastLink = getLastLinkInBucket( index );
+   BucketIndex lastItemIndex = 1; // a link can never be empty, so start at 1
+   for ( ;   
+         lastItemIndex < ValueInternalLink::itemPerLink; 
+         ++lastItemIndex ) // may be optimized with dicotomic search
+   {
+      if ( lastLink->items_[lastItemIndex].isItemAvailable() )
+         break;
+   }
+   
+   BucketIndex lastUsedIndex = lastItemIndex - 1;
+   Value *valueToDelete = &link->items_[index];
+   Value *valueToPreserve = &lastLink->items_[lastUsedIndex];
+   if ( valueToDelete != valueToPreserve )
+      valueToDelete->swap( *valueToPreserve );
+   if ( lastUsedIndex == 0 )  // page is now empty
+   {  // remove it from bucket linked list and delete it.
+      ValueInternalLink *linkPreviousToLast = lastLink->previous_;
+      if ( linkPreviousToLast != 0 )   // can not deleted bucket link.
+      {
+         mapAllocator()->releaseMapLink( lastLink );
+         linkPreviousToLast->next_ = 0;
+         lastLink = linkPreviousToLast;
+      }
+   }
+   else
+   {
+      Value dummy;
+      valueToPreserve->swap( dummy ); // restore deleted to default Value.
+      valueToPreserve->setItemUsed( false );
+   }
+   --itemCount_;
+}
+
+
+ValueInternalLink *&
+ValueInternalMap::getLastLinkInBucket( BucketIndex bucketIndex )
+{
+   if ( bucketIndex == bucketsSize_ - 1 )
+      return tailLink_;
+   ValueInternalLink *&previous = buckets_[bucketIndex+1].previous_;
+   if ( !previous )
+      previous = &buckets_[bucketIndex];
+   return previous;
+}
+
+
+Value &
+ValueInternalMap::setNewItem( const char *key, 
+                              bool isStatic,
+                              ValueInternalLink *link, 
+                              BucketIndex index )
+{
+   char *duplicatedKey = makeMemberName( key );
+   ++itemCount_;
+   link->keys_[index] = duplicatedKey;
+   link->items_[index].setItemUsed();
+   link->items_[index].setMemberNameIsStatic( isStatic );
+   return link->items_[index]; // items already default constructed.
+}
+
+
+Value &
+ValueInternalMap::unsafeAdd( const char *key, 
+                             bool isStatic, 
+                             HashKey hashedKey )
+{
+   JSON_ASSERT_MESSAGE( bucketsSize_ > 0, "ValueInternalMap::unsafeAdd(): internal logic error." );
+   BucketIndex bucketIndex = hashedKey % bucketsSize_;
+   ValueInternalLink *&previousLink = getLastLinkInBucket( bucketIndex );
+   ValueInternalLink *link = previousLink;
+   BucketIndex index;
+   for ( index =0; index < ValueInternalLink::itemPerLink; ++index )
+   {
+      if ( link->items_[index].isItemAvailable() )
+         break;
+   }
+   if ( index == ValueInternalLink::itemPerLink ) // need to add a new page
+   {
+      ValueInternalLink *newLink = mapAllocator()->allocateMapLink();
+      index = 0;
+      link->next_ = newLink;
+      previousLink = newLink;
+      link = newLink;
+   }
+   return setNewItem( key, isStatic, link, index );
+}
+
+
+ValueInternalMap::HashKey 
+ValueInternalMap::hash( const char *key ) const
+{
+   HashKey hash = 0;
+   while ( *key )
+      hash += *key++ * 37;
+   return hash;
+}
+
+
+int 
+ValueInternalMap::compare( const ValueInternalMap &other ) const
+{
+   int sizeDiff( itemCount_ - other.itemCount_ );
+   if ( sizeDiff != 0 )
+      return sizeDiff;
+   // Strict order guaranty is required. Compare all keys FIRST, then compare values.
+   IteratorState it;
+   IteratorState itEnd;
+   makeBeginIterator( it );
+   makeEndIterator( itEnd );
+   for ( ; !equals(it,itEnd); increment(it) )
+   {
+      if ( !other.find( key( it ) ) )
+         return 1;
+   }
+
+   // All keys are equals, let's compare values
+   makeBeginIterator( it );
+   for ( ; !equals(it,itEnd); increment(it) )
+   {
+      const Value *otherValue = other.find( key( it ) );
+      int valueDiff = value(it).compare( *otherValue );
+      if ( valueDiff != 0 )
+         return valueDiff;
+   }
+   return 0;
+}
+
+
+void 
+ValueInternalMap::makeBeginIterator( IteratorState &it ) const
+{
+   it.map_ = const_cast<ValueInternalMap *>( this );
+   it.bucketIndex_ = 0;
+   it.itemIndex_ = 0;
+   it.link_ = buckets_;
+}
+
+
+void 
+ValueInternalMap::makeEndIterator( IteratorState &it ) const
+{
+   it.map_ = const_cast<ValueInternalMap *>( this );
+   it.bucketIndex_ = bucketsSize_;
+   it.itemIndex_ = 0;
+   it.link_ = 0;
+}
+
+
+bool 
+ValueInternalMap::equals( const IteratorState &x, const IteratorState &other )
+{
+   return x.map_ == other.map_  
+          &&  x.bucketIndex_ == other.bucketIndex_  
+          &&  x.link_ == other.link_
+          &&  x.itemIndex_ == other.itemIndex_;
+}
+
+
+void 
+ValueInternalMap::incrementBucket( IteratorState &iterator )
+{
+   ++iterator.bucketIndex_;
+   JSON_ASSERT_MESSAGE( iterator.bucketIndex_ <= iterator.map_->bucketsSize_,
+      "ValueInternalMap::increment(): attempting to iterate beyond end." );
+   if ( iterator.bucketIndex_ == iterator.map_->bucketsSize_ )
+      iterator.link_ = 0;
+   else
+      iterator.link_ = &(iterator.map_->buckets_[iterator.bucketIndex_]);
+   iterator.itemIndex_ = 0;
+}
+
+
+void 
+ValueInternalMap::increment( IteratorState &iterator )
+{
+   JSON_ASSERT_MESSAGE( iterator.map_, "Attempting to iterator using invalid iterator." );
+   ++iterator.itemIndex_;
+   if ( iterator.itemIndex_ == ValueInternalLink::itemPerLink )
+   {
+      JSON_ASSERT_MESSAGE( iterator.link_ != 0,
+         "ValueInternalMap::increment(): attempting to iterate beyond end." );
+      iterator.link_ = iterator.link_->next_;
+      if ( iterator.link_ == 0 )
+         incrementBucket( iterator );
+   }
+   else if ( iterator.link_->items_[iterator.itemIndex_].isItemAvailable() )
+   {
+      incrementBucket( iterator );
+   }
+}
+
+
+void 
+ValueInternalMap::decrement( IteratorState &iterator )
+{
+   if ( iterator.itemIndex_ == 0 )
+   {
+      JSON_ASSERT_MESSAGE( iterator.map_, "Attempting to iterate using invalid iterator." );
+      if ( iterator.link_ == &iterator.map_->buckets_[iterator.bucketIndex_] )
+      {
+         JSON_ASSERT_MESSAGE( iterator.bucketIndex_ > 0, "Attempting to iterate beyond beginning." );
+         --(iterator.bucketIndex_);
+      }
+      iterator.link_ = iterator.link_->previous_;
+      iterator.itemIndex_ = ValueInternalLink::itemPerLink - 1;
+   }
+}
+
+
+const char *
+ValueInternalMap::key( const IteratorState &iterator )
+{
+   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
+   return iterator.link_->keys_[iterator.itemIndex_];
+}
+
+const char *
+ValueInternalMap::key( const IteratorState &iterator, bool &isStatic )
+{
+   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
+   isStatic = iterator.link_->items_[iterator.itemIndex_].isMemberNameStatic();
+   return iterator.link_->keys_[iterator.itemIndex_];
+}
+
+
+Value &
+ValueInternalMap::value( const IteratorState &iterator )
+{
+   JSON_ASSERT_MESSAGE( iterator.link_, "Attempting to iterate using invalid iterator." );
+   return iterator.link_->items_[iterator.itemIndex_];
+}
+
+
+int 
+ValueInternalMap::distance( const IteratorState &x, const IteratorState &y )
+{
+   int offset = 0;
+   IteratorState it = x;
+   while ( !equals( it, y ) )
+      increment( it );
+   return offset;
+}
+
+} // namespace Json
diff --git a/jsoncpp/src/lib_json/json_reader.cpp b/jsoncpp/src/lib_json/json_reader.cpp
new file mode 100644
index 0000000..1f3873a
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_reader.cpp
@@ -0,0 +1,918 @@
+// Copyright 2007-2011 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/assertions.h>
+# include <json/reader.h>
+# include <json/value.h>
+# include "json_tool.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <utility>
+#include <cstdio>
+#include <cassert>
+#include <cstring>
+#include <stdexcept>
+
+#if _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
+#endif
+
+namespace Json {
+
+// Implementation of class Features
+// ////////////////////////////////
+
+Features::Features()
+   : allowComments_( true )
+   , strictRoot_( false )
+{
+}
+
+
+Features 
+Features::all()
+{
+   return Features();
+}
+
+
+Features 
+Features::strictMode()
+{
+   Features features;
+   features.allowComments_ = false;
+   features.strictRoot_ = true;
+   return features;
+}
+
+// Implementation of class Reader
+// ////////////////////////////////
+
+
+static inline bool 
+in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4 )
+{
+   return c == c1  ||  c == c2  ||  c == c3  ||  c == c4;
+}
+
+static inline bool 
+in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4, Reader::Char c5 )
+{
+   return c == c1  ||  c == c2  ||  c == c3  ||  c == c4  ||  c == c5;
+}
+
+
+static bool 
+containsNewLine( Reader::Location begin, 
+                 Reader::Location end )
+{
+   for ( ;begin < end; ++begin )
+      if ( *begin == '\n'  ||  *begin == '\r' )
+         return true;
+   return false;
+}
+
+
+// Class Reader
+// //////////////////////////////////////////////////////////////////
+
+Reader::Reader()
+    : errors_(),
+      document_(),
+      begin_(),
+      end_(),
+      current_(),
+      lastValueEnd_(),
+      lastValue_(),
+      commentsBefore_(),
+      features_( Features::all() ),
+      collectComments_()
+{
+}
+
+
+Reader::Reader( const Features &features )
+    : errors_(),
+      document_(),
+      begin_(),
+      end_(),
+      current_(),
+      lastValueEnd_(),
+      lastValue_(),
+      commentsBefore_(),
+      features_( features ),
+      collectComments_()
+{
+}
+
+
+bool
+Reader::parse( const std::string &document, 
+               Value &root,
+               bool collectComments )
+{
+   document_ = document;
+   const char *begin = document_.c_str();
+   const char *end = begin + document_.length();
+   return parse( begin, end, root, collectComments );
+}
+
+
+bool
+Reader::parse( std::istream& sin,
+               Value &root,
+               bool collectComments )
+{
+   //std::istream_iterator<char> begin(sin);
+   //std::istream_iterator<char> end;
+   // Those would allow streamed input from a file, if parse() were a
+   // template function.
+
+   // Since std::string is reference-counted, this at least does not
+   // create an extra copy.
+   std::string doc;
+   std::getline(sin, doc, (char)EOF);
+   return parse( doc, root, collectComments );
+}
+
+bool 
+Reader::parse( const char *beginDoc, const char *endDoc, 
+               Value &root,
+               bool collectComments )
+{
+   if ( !features_.allowComments_ )
+   {
+      collectComments = false;
+   }
+
+   begin_ = beginDoc;
+   end_ = endDoc;
+   collectComments_ = collectComments;
+   current_ = begin_;
+   lastValueEnd_ = 0;
+   lastValue_ = 0;
+   commentsBefore_ = "";
+   errors_.clear();
+   while ( !nodes_.empty() )
+      nodes_.pop();
+   nodes_.push( &root );
+   
+   bool successful = readValue();
+   Token token;
+   skipCommentTokens( token );
+   if ( collectComments_  &&  !commentsBefore_.empty() )
+      root.setComment( commentsBefore_, commentAfter );
+   if ( features_.strictRoot_ )
+   {
+      if ( !root.isArray()  &&  !root.isObject() )
+      {
+         // Set error location to start of doc, ideally should be first token found in doc
+         token.type_ = tokenError;
+         token.start_ = beginDoc;
+         token.end_ = endDoc;
+         addError( "A valid JSON document must be either an array or an object value.",
+                   token );
+         return false;
+      }
+   }
+   return successful;
+}
+
+
+bool
+Reader::readValue()
+{
+   Token token;
+   skipCommentTokens( token );
+   bool successful = true;
+
+   if ( collectComments_  &&  !commentsBefore_.empty() )
+   {
+      currentValue().setComment( commentsBefore_, commentBefore );
+      commentsBefore_ = "";
+   }
+
+
+   switch ( token.type_ )
+   {
+   case tokenObjectBegin:
+      successful = readObject( token );
+      break;
+   case tokenArrayBegin:
+      successful = readArray( token );
+      break;
+   case tokenNumber:
+      successful = decodeNumber( token );
+      break;
+   case tokenString:
+      successful = decodeString( token );
+      break;
+   case tokenTrue:
+      currentValue() = true;
+      break;
+   case tokenFalse:
+      currentValue() = false;
+      break;
+   case tokenNull:
+      currentValue() = Value();
+      break;
+   default:
+      return addError( "Syntax error: value, object or array expected.", token );
+   }
+
+   if ( collectComments_ )
+   {
+      lastValueEnd_ = current_;
+      lastValue_ = &currentValue();
+   }
+
+   return successful;
+}
+
+
+void 
+Reader::skipCommentTokens( Token &token )
+{
+   if ( features_.allowComments_ )
+   {
+      do
+      {
+         readToken( token );
+      }
+      while ( token.type_ == tokenComment );
+   }
+   else
+   {
+      readToken( token );
+   }
+}
+
+
+bool 
+Reader::expectToken( TokenType type, Token &token, const char *message )
+{
+   readToken( token );
+   if ( token.type_ != type )
+      return addError( message, token );
+   return true;
+}
+
+
+bool 
+Reader::readToken( Token &token )
+{
+   skipSpaces();
+   token.start_ = current_;
+   Char c = getNextChar();
+   bool ok = true;
+   switch ( c )
+   {
+   case '{':
+      token.type_ = tokenObjectBegin;
+      break;
+   case '}':
+      token.type_ = tokenObjectEnd;
+      break;
+   case '[':
+      token.type_ = tokenArrayBegin;
+      break;
+   case ']':
+      token.type_ = tokenArrayEnd;
+      break;
+   case '"':
+      token.type_ = tokenString;
+      ok = readString();
+      break;
+   case '/':
+      token.type_ = tokenComment;
+      ok = readComment();
+      break;
+   case '0':
+   case '1':
+   case '2':
+   case '3':
+   case '4':
+   case '5':
+   case '6':
+   case '7':
+   case '8':
+   case '9':
+   case '-':
+      token.type_ = tokenNumber;
+      readNumber();
+      break;
+   case 't':
+      token.type_ = tokenTrue;
+      ok = match( "rue", 3 );
+      break;
+   case 'f':
+      token.type_ = tokenFalse;
+      ok = match( "alse", 4 );
+      break;
+   case 'n':
+      token.type_ = tokenNull;
+      ok = match( "ull", 3 );
+      break;
+   case ',':
+      token.type_ = tokenArraySeparator;
+      break;
+   case ':':
+      token.type_ = tokenMemberSeparator;
+      break;
+   case 0:
+      token.type_ = tokenEndOfStream;
+      break;
+   default:
+      ok = false;
+      break;
+   }
+   if ( !ok )
+      token.type_ = tokenError;
+   token.end_ = current_;
+   return true;
+}
+
+
+void 
+Reader::skipSpaces()
+{
+   while ( current_ != end_ )
+   {
+      Char c = *current_;
+      if ( c == ' '  ||  c == '\t'  ||  c == '\r'  ||  c == '\n' )
+         ++current_;
+      else
+         break;
+   }
+}
+
+
+bool 
+Reader::match( Location pattern, 
+               int patternLength )
+{
+   if ( end_ - current_ < patternLength )
+      return false;
+   int index = patternLength;
+   while ( index-- )
+      if ( current_[index] != pattern[index] )
+         return false;
+   current_ += patternLength;
+   return true;
+}
+
+
+bool
+Reader::readComment()
+{
+   Location commentBegin = current_ - 1;
+   Char c = getNextChar();
+   bool successful = false;
+   if ( c == '*' )
+      successful = readCStyleComment();
+   else if ( c == '/' )
+      successful = readCppStyleComment();
+   if ( !successful )
+      return false;
+
+   if ( collectComments_ )
+   {
+      CommentPlacement placement = commentBefore;
+      if ( lastValueEnd_  &&  !containsNewLine( lastValueEnd_, commentBegin ) )
+      {
+         if ( c != '*'  ||  !containsNewLine( commentBegin, current_ ) )
+            placement = commentAfterOnSameLine;
+      }
+
+      addComment( commentBegin, current_, placement );
+   }
+   return true;
+}
+
+
+void 
+Reader::addComment( Location begin, 
+                    Location end, 
+                    CommentPlacement placement )
+{
+   assert( collectComments_ );
+   if ( placement == commentAfterOnSameLine )
+   {
+      assert( lastValue_ != 0 );
+      lastValue_->setComment( std::string( begin, end ), placement );
+   }
+   else
+   {
+      if ( !commentsBefore_.empty() )
+         commentsBefore_ += "\n";
+      commentsBefore_ += std::string( begin, end );
+   }
+}
+
+
+bool 
+Reader::readCStyleComment()
+{
+   while ( current_ != end_ )
+   {
+      Char c = getNextChar();
+      if ( c == '*'  &&  *current_ == '/' )
+         break;
+   }
+   return getNextChar() == '/';
+}
+
+
+bool 
+Reader::readCppStyleComment()
+{
+   while ( current_ != end_ )
+   {
+      Char c = getNextChar();
+      if (  c == '\r'  ||  c == '\n' )
+         break;
+   }
+   return true;
+}
+
+
+void 
+Reader::readNumber()
+{
+   while ( current_ != end_ )
+   {
+      if ( !(*current_ >= '0'  &&  *current_ <= '9')  &&
+           !in( *current_, '.', 'e', 'E', '+', '-' ) )
+         break;
+      ++current_;
+   }
+}
+
+bool
+Reader::readString()
+{
+   Char c = 0;
+   while ( current_ != end_ )
+   {
+      c = getNextChar();
+      if ( c == '\\' )
+         getNextChar();
+      else if ( c == '"' )
+         break;
+   }
+   return c == '"';
+}
+
+
+bool 
+Reader::readObject( Token &/*tokenStart*/ )
+{
+   Token tokenName;
+   std::string name;
+   currentValue() = Value( objectValue );
+   while ( readToken( tokenName ) )
+   {
+      bool initialTokenOk = true;
+      while ( tokenName.type_ == tokenComment  &&  initialTokenOk )
+         initialTokenOk = readToken( tokenName );
+      if  ( !initialTokenOk )
+         break;
+      if ( tokenName.type_ == tokenObjectEnd  &&  name.empty() )  // empty object
+         return true;
+      if ( tokenName.type_ != tokenString )
+         break;
+      
+      name = "";
+      if ( !decodeString( tokenName, name ) )
+         return recoverFromError( tokenObjectEnd );
+
+      Token colon;
+      if ( !readToken( colon ) ||  colon.type_ != tokenMemberSeparator )
+      {
+         return addErrorAndRecover( "Missing ':' after object member name", 
+                                    colon, 
+                                    tokenObjectEnd );
+      }
+      Value &value = currentValue()[ name ];
+      nodes_.push( &value );
+      bool ok = readValue();
+      nodes_.pop();
+      if ( !ok ) // error already set
+         return recoverFromError( tokenObjectEnd );
+
+      Token comma;
+      if ( !readToken( comma )
+            ||  ( comma.type_ != tokenObjectEnd  &&  
+                  comma.type_ != tokenArraySeparator &&
+                  comma.type_ != tokenComment ) )
+      {
+         return addErrorAndRecover( "Missing ',' or '}' in object declaration", 
+                                    comma, 
+                                    tokenObjectEnd );
+      }
+      bool finalizeTokenOk = true;
+      while ( comma.type_ == tokenComment &&
+              finalizeTokenOk )
+         finalizeTokenOk = readToken( comma );
+      if ( comma.type_ == tokenObjectEnd )
+         return true;
+   }
+   return addErrorAndRecover( "Missing '}' or object member name", 
+                              tokenName, 
+                              tokenObjectEnd );
+}
+
+
+bool 
+Reader::readArray( Token &/*tokenStart*/ )
+{
+   currentValue() = Value( arrayValue );
+   skipSpaces();
+   if ( *current_ == ']' ) // empty array
+   {
+      Token endArray;
+      readToken( endArray );
+      return true;
+   }
+   int index = 0;
+   for (;;)
+   {
+      Value &value = currentValue()[ index++ ];
+      nodes_.push( &value );
+      bool ok = readValue();
+      nodes_.pop();
+      if ( !ok ) // error already set
+         return recoverFromError( tokenArrayEnd );
+
+      Token token;
+      // Accept Comment after last item in the array.
+      ok = readToken( token );
+      while ( token.type_ == tokenComment  &&  ok )
+      {
+         ok = readToken( token );
+      }
+      bool badTokenType = ( token.type_ != tokenArraySeparator  &&
+                            token.type_ != tokenArrayEnd );
+      if ( !ok  ||  badTokenType )
+      {
+         return addErrorAndRecover( "Missing ',' or ']' in array declaration", 
+                                    token, 
+                                    tokenArrayEnd );
+      }
+      if ( token.type_ == tokenArrayEnd )
+         break;
+   }
+   return true;
+}
+
+
+bool 
+Reader::decodeNumber( Token &token )
+{
+   bool isDouble = false;
+   for ( Location inspect = token.start_; inspect != token.end_; ++inspect )
+   {
+      isDouble = isDouble  
+                 ||  in( *inspect, '.', 'e', 'E', '+' )  
+                 ||  ( *inspect == '-'  &&  inspect != token.start_ );
+   }
+   if ( isDouble )
+      return decodeDouble( token );
+   // Attempts to parse the number as an integer. If the number is
+   // larger than the maximum supported value of an integer then
+   // we decode the number as a double.
+   Location current = token.start_;
+   bool isNegative = *current == '-';
+   if ( isNegative )
+      ++current;
+   Value::LargestUInt maxIntegerValue = isNegative ? Value::LargestUInt(-Value::minLargestInt) 
+                                                   : Value::maxLargestUInt;
+   Value::LargestUInt threshold = maxIntegerValue / 10;
+   Value::LargestUInt value = 0;
+   while ( current < token.end_ )
+   {
+      Char c = *current++;
+      if ( c < '0'  ||  c > '9' )
+         return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
+      Value::UInt digit(c - '0');
+      if ( value >= threshold )
+      {
+         // We've hit or exceeded the max value divided by 10 (rounded down). If
+         // a) we've only just touched the limit, b) this is the last digit, and
+         // c) it's small enough to fit in that rounding delta, we're okay.
+         // Otherwise treat this number as a double to avoid overflow.
+         if (value > threshold ||
+             current != token.end_ ||
+             digit > maxIntegerValue % 10)
+         {
+            return decodeDouble( token );
+         }
+      }
+      value = value * 10 + digit;
+   }
+   if ( isNegative )
+      currentValue() = -Value::LargestInt( value );
+   else if ( value <= Value::LargestUInt(Value::maxInt) )
+      currentValue() = Value::LargestInt( value );
+   else
+      currentValue() = value;
+   return true;
+}
+
+
+bool 
+Reader::decodeDouble( Token &token )
+{
+   double value = 0;
+   const int bufferSize = 32;
+   int count;
+   int length = int(token.end_ - token.start_);
+
+   // Sanity check to avoid buffer overflow exploits.
+   if (length < 0) {
+      return addError( "Unable to parse token length", token );
+   }
+
+   // Avoid using a string constant for the format control string given to
+   // sscanf, as this can cause hard to debug crashes on OS X. See here for more
+   // info:
+   //
+   //     http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html
+   char format[] = "%lf";
+
+   if ( length <= bufferSize )
+   {
+      Char buffer[bufferSize+1];
+      memcpy( buffer, token.start_, length );
+      buffer[length] = 0;
+      count = sscanf( buffer, format, &value );
+   }
+   else
+   {
+      std::string buffer( token.start_, token.end_ );
+      count = sscanf( buffer.c_str(), format, &value );
+   }
+
+   if ( count != 1 )
+      return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
+   currentValue() = value;
+   return true;
+}
+
+
+bool 
+Reader::decodeString( Token &token )
+{
+   std::string decoded;
+   if ( !decodeString( token, decoded ) )
+      return false;
+   currentValue() = decoded;
+   return true;
+}
+
+
+bool 
+Reader::decodeString( Token &token, std::string &decoded )
+{
+   decoded.reserve( token.end_ - token.start_ - 2 );
+   Location current = token.start_ + 1; // skip '"'
+   Location end = token.end_ - 1;      // do not include '"'
+   while ( current != end )
+   {
+      Char c = *current++;
+      if ( c == '"' )
+         break;
+      else if ( c == '\\' )
+      {
+         if ( current == end )
+            return addError( "Empty escape sequence in string", token, current );
+         Char escape = *current++;
+         switch ( escape )
+         {
+         case '"': decoded += '"'; break;
+         case '/': decoded += '/'; break;
+         case '\\': decoded += '\\'; break;
+         case 'b': decoded += '\b'; break;
+         case 'f': decoded += '\f'; break;
+         case 'n': decoded += '\n'; break;
+         case 'r': decoded += '\r'; break;
+         case 't': decoded += '\t'; break;
+         case 'u':
+            {
+               unsigned int unicode;
+               if ( !decodeUnicodeCodePoint( token, current, end, unicode ) )
+                  return false;
+               decoded += codePointToUTF8(unicode);
+            }
+            break;
+         default:
+            return addError( "Bad escape sequence in string", token, current );
+         }
+      }
+      else
+      {
+         decoded += c;
+      }
+   }
+   return true;
+}
+
+bool
+Reader::decodeUnicodeCodePoint( Token &token, 
+                                     Location &current, 
+                                     Location end, 
+                                     unsigned int &unicode )
+{
+
+   if ( !decodeUnicodeEscapeSequence( token, current, end, unicode ) )
+      return false;
+   if (unicode >= 0xD800 && unicode <= 0xDBFF)
+   {
+      // surrogate pairs
+      if (end - current < 6)
+         return addError( "additional six characters expected to parse unicode surrogate pair.", token, current );
+      unsigned int surrogatePair;
+      if (*(current++) == '\\' && *(current++)== 'u')
+      {
+         if (decodeUnicodeEscapeSequence( token, current, end, surrogatePair ))
+         {
+            unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+         } 
+         else
+            return false;
+      } 
+      else
+         return addError( "expecting another \\u token to begin the second half of a unicode surrogate pair", token, current );
+   }
+   return true;
+}
+
+bool 
+Reader::decodeUnicodeEscapeSequence( Token &token, 
+                                     Location &current, 
+                                     Location end, 
+                                     unsigned int &unicode )
+{
+   if ( end - current < 4 )
+      return addError( "Bad unicode escape sequence in string: four digits expected.", token, current );
+   unicode = 0;
+   for ( int index =0; index < 4; ++index )
+   {
+      Char c = *current++;
+      unicode *= 16;
+      if ( c >= '0'  &&  c <= '9' )
+         unicode += c - '0';
+      else if ( c >= 'a'  &&  c <= 'f' )
+         unicode += c - 'a' + 10;
+      else if ( c >= 'A'  &&  c <= 'F' )
+         unicode += c - 'A' + 10;
+      else
+         return addError( "Bad unicode escape sequence in string: hexadecimal digit expected.", token, current );
+   }
+   return true;
+}
+
+
+bool 
+Reader::addError( const std::string &message, 
+                  Token &token,
+                  Location extra )
+{
+   ErrorInfo info;
+   info.token_ = token;
+   info.message_ = message;
+   info.extra_ = extra;
+   errors_.push_back( info );
+   return false;
+}
+
+
+bool 
+Reader::recoverFromError( TokenType skipUntilToken )
+{
+   int errorCount = int(errors_.size());
+   Token skip;
+   for (;;)
+   {
+      if ( !readToken(skip) )
+         errors_.resize( errorCount ); // discard errors caused by recovery
+      if ( skip.type_ == skipUntilToken  ||  skip.type_ == tokenEndOfStream )
+         break;
+   }
+   errors_.resize( errorCount );
+   return false;
+}
+
+
+bool 
+Reader::addErrorAndRecover( const std::string &message, 
+                            Token &token,
+                            TokenType skipUntilToken )
+{
+   addError( message, token );
+   return recoverFromError( skipUntilToken );
+}
+
+
+Value &
+Reader::currentValue()
+{
+   return *(nodes_.top());
+}
+
+
+Reader::Char 
+Reader::getNextChar()
+{
+   if ( current_ == end_ )
+      return 0;
+   return *current_++;
+}
+
+
+void 
+Reader::getLocationLineAndColumn( Location location,
+                                  int &line,
+                                  int &column ) const
+{
+   Location current = begin_;
+   Location lastLineStart = current;
+   line = 0;
+   while ( current < location  &&  current != end_ )
+   {
+      Char c = *current++;
+      if ( c == '\r' )
+      {
+         if ( *current == '\n' )
+            ++current;
+         lastLineStart = current;
+         ++line;
+      }
+      else if ( c == '\n' )
+      {
+         lastLineStart = current;
+         ++line;
+      }
+   }
+   // column & line start at 1
+   column = int(location - lastLineStart) + 1;
+   ++line;
+}
+
+
+std::string
+Reader::getLocationLineAndColumn( Location location ) const
+{
+   int line, column;
+   getLocationLineAndColumn( location, line, column );
+   char buffer[18+16+16+1];
+   sprintf( buffer, "Line %d, Column %d", line, column );
+   return buffer;
+}
+
+
+// Deprecated. Preserved for backward compatibility
+std::string 
+Reader::getFormatedErrorMessages() const
+{
+    return getFormattedErrorMessages();
+}
+
+
+std::string 
+Reader::getFormattedErrorMessages() const
+{
+   std::string formattedMessage;
+   for ( Errors::const_iterator itError = errors_.begin();
+         itError != errors_.end();
+         ++itError )
+   {
+      const ErrorInfo &error = *itError;
+      formattedMessage += "* " + getLocationLineAndColumn( error.token_.start_ ) + "\n";
+      formattedMessage += "  " + error.message_ + "\n";
+      if ( error.extra_ )
+         formattedMessage += "See " + getLocationLineAndColumn( error.extra_ ) + " for detail.\n";
+   }
+   return formattedMessage;
+}
+
+
+std::istream& operator>>( std::istream &sin, Value &root )
+{
+    Json::Reader reader;
+    bool ok = reader.parse(sin, root, true);
+    if (!ok) {
+      fprintf(
+          stderr,
+          "Error from reader: %s",
+          reader.getFormattedErrorMessages().c_str());
+
+      JSON_FAIL_MESSAGE("reader error");
+    }
+    return sin;
+}
+
+
+} // namespace Json
diff --git a/jsoncpp/src/lib_json/json_tool.h b/jsoncpp/src/lib_json/json_tool.h
new file mode 100644
index 0000000..658031b
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_tool.h
@@ -0,0 +1,93 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+# define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+
+/* This header provides common string manipulation support, such as UTF-8,
+ * portable conversion from/to string...
+ *
+ * It is an internal header that must not be exposed.
+ */
+
+namespace Json {
+
+/// Converts a unicode code-point to UTF-8.
+static inline std::string 
+codePointToUTF8(unsigned int cp)
+{
+   std::string result;
+   
+   // based on description from http://en.wikipedia.org/wiki/UTF-8
+
+   if (cp <= 0x7f) 
+   {
+      result.resize(1);
+      result[0] = static_cast<char>(cp);
+   } 
+   else if (cp <= 0x7FF) 
+   {
+      result.resize(2);
+      result[1] = static_cast<char>(0x80 | (0x3f & cp));
+      result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
+   } 
+   else if (cp <= 0xFFFF) 
+   {
+      result.resize(3);
+      result[2] = static_cast<char>(0x80 | (0x3f & cp));
+      result[1] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
+      result[0] = 0xE0 | static_cast<char>((0xf & (cp >> 12)));
+   }
+   else if (cp <= 0x10FFFF) 
+   {
+      result.resize(4);
+      result[3] = static_cast<char>(0x80 | (0x3f & cp));
+      result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+      result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
+      result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
+   }
+
+   return result;
+}
+
+
+/// Returns true if ch is a control character (in range [0,32[).
+static inline bool 
+isControlCharacter(char ch)
+{
+   return ch > 0 && ch <= 0x1F;
+}
+
+
+enum { 
+   /// Constant that specify the size of the buffer that must be passed to uintToString.
+   uintToStringBufferSize = 3*sizeof(LargestUInt)+1 
+};
+
+// Defines a char buffer for use with uintToString().
+typedef char UIntToStringBuffer[uintToStringBufferSize];
+
+
+/** Converts an unsigned integer to string.
+ * @param value Unsigned interger to convert to string
+ * @param current Input/Output string buffer. 
+ *        Must have at least uintToStringBufferSize chars free.
+ */
+static inline void 
+uintToString( LargestUInt value, 
+              char *&current )
+{
+   *--current = 0;
+   do
+   {
+      *--current = char(value % 10) + '0';
+      value /= 10;
+   }
+   while ( value != 0 );
+}
+
+} // namespace Json {
+
+#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
diff --git a/jsoncpp/src/lib_json/json_value.cpp b/jsoncpp/src/lib_json/json_value.cpp
new file mode 100644
index 0000000..91f312e
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_value.cpp
@@ -0,0 +1,1920 @@
+// Copyright 2011 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/assertions.h>
+# include <json/value.h>
+# include <json/writer.h>
+# ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#  include "json_batchallocator.h"
+# endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <math.h>
+#include <sstream>
+#include <utility>
+#include <stdexcept>
+#include <cstring>
+#include <cassert>
+#ifdef JSON_USE_CPPTL
+# include <cpptl/conststring.h>
+#endif
+#include <cstddef>    // size_t
+
+#define JSON_ASSERT_UNREACHABLE assert( false )
+
+namespace Json {
+
+const Value Value::null;
+const Int Value::minInt = Int( ~(UInt(-1)/2) );
+const Int Value::maxInt = Int( UInt(-1)/2 );
+const UInt Value::maxUInt = UInt(-1);
+# if defined(JSON_HAS_INT64)
+const Int64 Value::minInt64 = Int64( ~(UInt64(-1)/2) );
+const Int64 Value::maxInt64 = Int64( UInt64(-1)/2 );
+const UInt64 Value::maxUInt64 = UInt64(-1);
+// The constant is hard-coded because some compiler have trouble
+// converting Value::maxUInt64 to a double correctly (AIX/xlC).
+// Assumes that UInt64 is a 64 bits integer.
+static const double maxUInt64AsDouble = 18446744073709551615.0;
+#endif // defined(JSON_HAS_INT64)
+const LargestInt Value::minLargestInt = LargestInt( ~(LargestUInt(-1)/2) );
+const LargestInt Value::maxLargestInt = LargestInt( LargestUInt(-1)/2 );
+const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
+
+
+/// Unknown size marker
+static const unsigned int unknown = (unsigned)-1;
+
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+   return d >= min && d <= max;
+}
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double integerToDouble( Json::UInt64 value )
+{
+    return static_cast<double>( Int64(value/2) ) * 2.0 + Int64(value & 1);
+}
+
+template<typename T>
+static inline double integerToDouble( T value )
+{
+    return static_cast<double>( value );
+}
+
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+   return d >= integerToDouble(min) && d <= integerToDouble(max);
+}
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+
+
+/** Duplicates the specified string value.
+ * @param value Pointer to the string to duplicate. Must be zero-terminated if
+ *              length is "unknown".
+ * @param length Length of the value. if equals to unknown, then it will be
+ *               computed using strlen(value).
+ * @return Pointer on the duplicate instance of string.
+ */
+static inline char *
+duplicateStringValue( const char *value, 
+                      unsigned int length = unknown )
+{
+   if ( length == unknown )
+      length = (unsigned int)strlen(value);
+
+   // Avoid an integer overflow in the call to malloc below by limiting length
+   // to a sane value.
+   if (length >= (unsigned)Value::maxInt)
+      length = Value::maxInt - 1;
+
+   char *newString = static_cast<char *>( malloc( length + 1 ) );
+   JSON_ASSERT_MESSAGE( newString != 0, "Failed to allocate string value buffer" );
+   memcpy( newString, value, length );
+   newString[length] = 0;
+   return newString;
+}
+
+
+/** Free the string duplicated by duplicateStringValue().
+ */
+static inline void 
+releaseStringValue( char *value )
+{
+   if ( value )
+      free( value );
+}
+
+} // namespace Json
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// ValueInternals...
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+#if !defined(JSON_IS_AMALGAMATION)
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+#  include "json_internalarray.inl"
+#  include "json_internalmap.inl"
+# endif // JSON_VALUE_USE_INTERNAL_MAP
+
+# include "json_valueiterator.inl"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::CommentInfo
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+
+Value::CommentInfo::CommentInfo()
+   : comment_( 0 )
+{
+}
+
+Value::CommentInfo::~CommentInfo()
+{
+   if ( comment_ )
+      releaseStringValue( comment_ );
+}
+
+
+void 
+Value::CommentInfo::setComment( const char *text )
+{
+   if ( comment_ )
+      releaseStringValue( comment_ );
+   JSON_ASSERT( text != 0 );
+   JSON_ASSERT_MESSAGE( text[0]=='\0' || text[0]=='/', "Comments must start with /");
+   // It seems that /**/ style comments are acceptable as well.
+   comment_ = duplicateStringValue( text );
+}
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::CZString
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+# ifndef JSON_VALUE_USE_INTERNAL_MAP
+
+// Notes: index_ indicates if the string was allocated when
+// a string is stored.
+
+Value::CZString::CZString( ArrayIndex index )
+   : cstr_( 0 )
+   , index_( index )
+{
+}
+
+Value::CZString::CZString( const char *cstr, DuplicationPolicy allocate )
+   : cstr_( allocate == duplicate ? duplicateStringValue(cstr) 
+                                  : cstr )
+   , index_( allocate )
+{
+}
+
+Value::CZString::CZString( const CZString &other )
+: cstr_( other.index_ != noDuplication &&  other.cstr_ != 0
+                ?  duplicateStringValue( other.cstr_ )
+                : other.cstr_ )
+   , index_( other.cstr_ ? (other.index_ == noDuplication ? noDuplication : duplicate)
+                         : other.index_ )
+{
+}
+
+Value::CZString::~CZString()
+{
+   if ( cstr_  &&  index_ == duplicate )
+      releaseStringValue( const_cast<char *>( cstr_ ) );
+}
+
+void 
+Value::CZString::swap( CZString &other )
+{
+   std::swap( cstr_, other.cstr_ );
+   std::swap( index_, other.index_ );
+}
+
+Value::CZString &
+Value::CZString::operator =( const CZString &other )
+{
+   CZString temp( other );
+   swap( temp );
+   return *this;
+}
+
+bool 
+Value::CZString::operator<( const CZString &other ) const 
+{
+   if ( cstr_ )
+      return strcmp( cstr_, other.cstr_ ) < 0;
+   return index_ < other.index_;
+}
+
+bool 
+Value::CZString::operator==( const CZString &other ) const 
+{
+   if ( cstr_ )
+      return strcmp( cstr_, other.cstr_ ) == 0;
+   return index_ == other.index_;
+}
+
+
+ArrayIndex 
+Value::CZString::index() const
+{
+   return index_;
+}
+
+
+const char *
+Value::CZString::c_str() const
+{
+   return cstr_;
+}
+
+bool 
+Value::CZString::isStaticString() const
+{
+   return index_ == noDuplication;
+}
+
+#endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::Value
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+/*! \internal Default constructor initialization must be equivalent to:
+ * memset( this, 0, sizeof(Value) )
+ * This optimization is used in ValueInternalMap fast allocator.
+ */
+Value::Value( ValueType type )
+   : type_( type )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   switch ( type )
+   {
+   case nullValue:
+      break;
+   case intValue:
+   case uintValue:
+      value_.int_ = 0;
+      break;
+   case realValue:
+      value_.real_ = 0.0;
+      break;
+   case stringValue:
+      value_.string_ = 0;
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_ = new ObjectValues();
+      break;
+#else
+   case arrayValue:
+      value_.array_ = arrayAllocator()->newArray();
+      break;
+   case objectValue:
+      value_.map_ = mapAllocator()->newMap();
+      break;
+#endif
+   case booleanValue:
+      value_.bool_ = false;
+      break;
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+}
+
+
+Value::Value( UInt value )
+   : type_( uintValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.uint_ = value;
+}
+
+Value::Value( Int value )
+   : type_( intValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.int_ = value;
+}
+
+
+# if defined(JSON_HAS_INT64)
+Value::Value( Int64 value )
+   : type_( intValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.int_ = value;
+}
+
+
+Value::Value( UInt64 value )
+   : type_( uintValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.uint_ = value;
+}
+#endif // defined(JSON_HAS_INT64)
+
+Value::Value( double value )
+   : type_( realValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.real_ = value;
+}
+
+Value::Value( const char *value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value );
+}
+
+
+Value::Value( const char *beginValue, 
+              const char *endValue )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( beginValue, 
+                                          (unsigned int)(endValue - beginValue) );
+}
+
+
+Value::Value( const std::string &value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value.c_str(), 
+                                          (unsigned int)value.length() );
+
+}
+
+Value::Value( const StaticString &value )
+   : type_( stringValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = const_cast<char *>( value.c_str() );
+}
+
+
+# ifdef JSON_USE_CPPTL
+Value::Value( const CppTL::ConstString &value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value, value.length() );
+}
+# endif
+
+Value::Value( bool value )
+   : type_( booleanValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.bool_ = value;
+}
+
+
+Value::Value( const Value &other )
+   : type_( other.type_ )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+      value_ = other.value_;
+      break;
+   case stringValue:
+      if ( other.value_.string_ )
+      {
+         value_.string_ = duplicateStringValue( other.value_.string_ );
+         allocated_ = true;
+      }
+      else
+         value_.string_ = 0;
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_ = new ObjectValues( *other.value_.map_ );
+      break;
+#else
+   case arrayValue:
+      value_.array_ = arrayAllocator()->newArrayCopy( *other.value_.array_ );
+      break;
+   case objectValue:
+      value_.map_ = mapAllocator()->newMapCopy( *other.value_.map_ );
+      break;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   if ( other.comments_ )
+   {
+      comments_ = new CommentInfo[numberOfCommentPlacement];
+      for ( int comment =0; comment < numberOfCommentPlacement; ++comment )
+      {
+         const CommentInfo &otherComment = other.comments_[comment];
+         if ( otherComment.comment_ )
+            comments_[comment].setComment( otherComment.comment_ );
+      }
+   }
+}
+
+
+Value::~Value()
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+      break;
+   case stringValue:
+      if ( allocated_ )
+         releaseStringValue( value_.string_ );
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      delete value_.map_;
+      break;
+#else
+   case arrayValue:
+      arrayAllocator()->destructArray( value_.array_ );
+      break;
+   case objectValue:
+      mapAllocator()->destructMap( value_.map_ );
+      break;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+
+   if ( comments_ )
+      delete[] comments_;
+}
+
+Value &
+Value::operator=( const Value &other )
+{
+   Value temp( other );
+   swap( temp );
+   return *this;
+}
+
+void 
+Value::swap( Value &other )
+{
+   ValueType temp = type_;
+   type_ = other.type_;
+   other.type_ = temp;
+   std::swap( value_, other.value_ );
+   int temp2 = allocated_;
+   allocated_ = other.allocated_;
+   other.allocated_ = temp2;
+}
+
+ValueType 
+Value::type() const
+{
+   return type_;
+}
+
+
+int 
+Value::compare( const Value &other ) const
+{
+   if ( *this < other )
+      return -1;
+   if ( *this > other )
+      return 1;
+   return 0;
+}
+
+
+bool 
+Value::operator <( const Value &other ) const
+{
+   int typeDelta = type_ - other.type_;
+   if ( typeDelta )
+      return typeDelta < 0 ? true : false;
+   switch ( type_ )
+   {
+   case nullValue:
+      return false;
+   case intValue:
+      return value_.int_ < other.value_.int_;
+   case uintValue:
+      return value_.uint_ < other.value_.uint_;
+   case realValue:
+      return value_.real_ < other.value_.real_;
+   case booleanValue:
+      return value_.bool_ < other.value_.bool_;
+   case stringValue:
+      return ( value_.string_ == 0  &&  other.value_.string_ )
+             || ( other.value_.string_  
+                  &&  value_.string_  
+                  && strcmp( value_.string_, other.value_.string_ ) < 0 );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      {
+         int delta = int( value_.map_->size() - other.value_.map_->size() );
+         if ( delta )
+            return delta < 0;
+         return (*value_.map_) < (*other.value_.map_);
+      }
+#else
+   case arrayValue:
+      return value_.array_->compare( *(other.value_.array_) ) < 0;
+   case objectValue:
+      return value_.map_->compare( *(other.value_.map_) ) < 0;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   return false;  // unreachable
+}
+
+bool 
+Value::operator <=( const Value &other ) const
+{
+   return !(other < *this);
+}
+
+bool 
+Value::operator >=( const Value &other ) const
+{
+   return !(*this < other);
+}
+
+bool 
+Value::operator >( const Value &other ) const
+{
+   return other < *this;
+}
+
+bool 
+Value::operator ==( const Value &other ) const
+{
+   //if ( type_ != other.type_ )
+   // GCC 2.95.3 says:
+   // attempt to take address of bit-field structure member `Json::Value::type_'
+   // Beats me, but a temp solves the problem.
+   int temp = other.type_;
+   if ( type_ != temp )
+      return false;
+   switch ( type_ )
+   {
+   case nullValue:
+      return true;
+   case intValue:
+      return value_.int_ == other.value_.int_;
+   case uintValue:
+      return value_.uint_ == other.value_.uint_;
+   case realValue:
+      return value_.real_ == other.value_.real_;
+   case booleanValue:
+      return value_.bool_ == other.value_.bool_;
+   case stringValue:
+      return ( value_.string_ == other.value_.string_ )
+             || ( other.value_.string_  
+                  &&  value_.string_  
+                  && strcmp( value_.string_, other.value_.string_ ) == 0 );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      return value_.map_->size() == other.value_.map_->size()
+             && (*value_.map_) == (*other.value_.map_);
+#else
+   case arrayValue:
+      return value_.array_->compare( *(other.value_.array_) ) == 0;
+   case objectValue:
+      return value_.map_->compare( *(other.value_.map_) ) == 0;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   return false;  // unreachable
+}
+
+bool 
+Value::operator !=( const Value &other ) const
+{
+   return !( *this == other );
+}
+
+const char *
+Value::asCString() const
+{
+   JSON_ASSERT( type_ == stringValue );
+   return value_.string_;
+}
+
+
+std::string 
+Value::asString() const
+{
+   switch ( type_ )
+   {
+   case nullValue:
+      return "";
+   case stringValue:
+      return value_.string_ ? value_.string_ : "";
+   case booleanValue:
+      return value_.bool_ ? "true" : "false";
+   case intValue:
+      return valueToString( value_.int_ );
+   case uintValue:
+      return valueToString( value_.uint_ );
+   case realValue:
+      return valueToString( value_.real_ );
+   default:
+      JSON_FAIL_MESSAGE( "Type is not convertible to string" );
+   }
+}
+
+# ifdef JSON_USE_CPPTL
+CppTL::ConstString 
+Value::asConstString() const
+{
+   return CppTL::ConstString( asString().c_str() );
+}
+# endif
+
+
+Value::Int 
+Value::asInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
+      return Int(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
+      return Int(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt), "double out of Int range");
+      return Int(value_.real_);
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to Int.");
+}
+
+
+Value::UInt 
+Value::asUInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
+      return UInt(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
+      return UInt(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt), "double out of UInt range");
+      return UInt( value_.real_ );
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
+}
+
+
+# if defined(JSON_HAS_INT64)
+
+Value::Int64
+Value::asInt64() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return Int64(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
+      return Int64(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), "double out of Int64 range");
+      return Int64(value_.real_);
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
+}
+
+
+Value::UInt64
+Value::asUInt64() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
+      return UInt64(value_.int_);
+   case uintValue:
+      return UInt64(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64), "double out of UInt64 range");
+      return UInt64( value_.real_ );
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
+}
+# endif // if defined(JSON_HAS_INT64)
+
+
+LargestInt 
+Value::asLargestInt() const
+{
+#if defined(JSON_NO_INT64)
+    return asInt();
+#else
+    return asInt64();
+#endif
+}
+
+
+LargestUInt 
+Value::asLargestUInt() const
+{
+#if defined(JSON_NO_INT64)
+    return asUInt();
+#else
+    return asUInt64();
+#endif
+}
+
+
+double 
+Value::asDouble() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return static_cast<double>( value_.int_ );
+   case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return static_cast<double>( value_.uint_ );
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return integerToDouble( value_.uint_ );
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+   case realValue:
+      return value_.real_;
+   case nullValue:
+      return 0.0;
+   case booleanValue:
+      return value_.bool_ ? 1.0 : 0.0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to double.");
+}
+
+float
+Value::asFloat() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return static_cast<float>( value_.int_ );
+   case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return static_cast<float>( value_.uint_ );
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return integerToDouble( value_.uint_ );
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+   case realValue:
+      return static_cast<float>( value_.real_ );
+   case nullValue:
+      return 0.0;
+   case booleanValue:
+      return value_.bool_ ? 1.0f : 0.0f;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to float.");
+}
+
+bool 
+Value::asBool() const
+{
+   switch ( type_ )
+   {
+   case booleanValue:
+      return value_.bool_;
+   case nullValue:
+      return false;
+   case intValue:
+      return value_.int_ ? true : false;
+   case uintValue:
+      return value_.uint_ ? true : false;
+   case realValue:
+      return value_.real_ ? true : false;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to bool.");
+}
+
+
+bool 
+Value::isConvertibleTo( ValueType other ) const
+{
+   switch ( other )
+   {
+   case nullValue:
+      return ( isNumeric() && asDouble() == 0.0 )
+             || ( type_ == booleanValue && value_.bool_ == false )
+             || ( type_ == stringValue && asString() == "" )
+             || ( type_ == arrayValue && value_.map_->size() == 0 )
+             || ( type_ == objectValue && value_.map_->size() == 0 )
+             || type_ == nullValue;
+   case intValue:
+      return isInt()
+             || (type_ == realValue && InRange(value_.real_, minInt, maxInt))
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case uintValue:
+      return isUInt()
+             || (type_ == realValue && InRange(value_.real_, 0, maxUInt))
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case realValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case booleanValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case stringValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == stringValue
+             || type_ == nullValue;
+   case arrayValue:
+      return type_ == arrayValue
+             || type_ == nullValue;
+   case objectValue:
+      return type_ == objectValue
+             || type_ == nullValue;
+   }
+   JSON_ASSERT_UNREACHABLE;
+   return false;
+}
+
+
+/// Number of values in array or object
+ArrayIndex 
+Value::size() const
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+   case stringValue:
+      return 0;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:  // size of the array is highest index + 1
+      if ( !value_.map_->empty() )
+      {
+         ObjectValues::const_iterator itLast = value_.map_->end();
+         --itLast;
+         return (*itLast).first.index()+1;
+      }
+      return 0;
+   case objectValue:
+      return ArrayIndex( value_.map_->size() );
+#else
+   case arrayValue:
+      return Int( value_.array_->size() );
+   case objectValue:
+      return Int( value_.map_->size() );
+#endif
+   }
+   JSON_ASSERT_UNREACHABLE;
+   return 0; // unreachable;
+}
+
+
+bool 
+Value::empty() const
+{
+   if ( isNull() || isArray() || isObject() )
+      return size() == 0u;
+   else
+      return false;
+}
+
+
+bool
+Value::operator!() const
+{
+   return isNull();
+}
+
+
+void 
+Value::clear()
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue  || type_ == objectValue );
+
+   switch ( type_ )
+   {
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_->clear();
+      break;
+#else
+   case arrayValue:
+      value_.array_->clear();
+      break;
+   case objectValue:
+      value_.map_->clear();
+      break;
+#endif
+   default:
+      break;
+   }
+}
+
+void 
+Value::resize( ArrayIndex newSize )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      *this = Value( arrayValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ArrayIndex oldSize = size();
+   if ( newSize == 0 )
+      clear();
+   else if ( newSize > oldSize )
+      (*this)[ newSize - 1 ];
+   else
+   {
+      for ( ArrayIndex index = newSize; index < oldSize; ++index )
+      {
+         value_.map_->erase( index );
+      }
+      assert( size() == newSize );
+   }
+#else
+   value_.array_->resize( newSize );
+#endif
+}
+
+
+Value &
+Value::operator[]( ArrayIndex index )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      *this = Value( arrayValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString key( index );
+   ObjectValues::iterator it = value_.map_->lower_bound( key );
+   if ( it != value_.map_->end()  &&  (*it).first == key )
+      return (*it).second;
+
+   ObjectValues::value_type defaultValue( key, null );
+   it = value_.map_->insert( it, defaultValue );
+   return (*it).second;
+#else
+   return value_.array_->resolveReference( index );
+#endif
+}
+
+
+Value &
+Value::operator[]( int index )
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
+const Value &
+Value::operator[]( ArrayIndex index ) const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString key( index );
+   ObjectValues::const_iterator it = value_.map_->find( key );
+   if ( it == value_.map_->end() )
+      return null;
+   return (*it).second;
+#else
+   Value *value = value_.array_->find( index );
+   return value ? *value : null;
+#endif
+}
+
+
+const Value &
+Value::operator[]( int index ) const
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
+Value &
+Value::operator[]( const char *key )
+{
+   return resolveReference( key, false );
+}
+
+
+Value &
+Value::resolveReference( const char *key, 
+                         bool isStatic )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      *this = Value( objectValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, isStatic ? CZString::noDuplication 
+                                     : CZString::duplicateOnCopy );
+   ObjectValues::iterator it = value_.map_->lower_bound( actualKey );
+   if ( it != value_.map_->end()  &&  (*it).first == actualKey )
+      return (*it).second;
+
+   ObjectValues::value_type defaultValue( actualKey, null );
+   it = value_.map_->insert( it, defaultValue );
+   Value &value = (*it).second;
+   return value;
+#else
+   return value_.map_->resolveReference( key, isStatic );
+#endif
+}
+
+
+Value 
+Value::get( ArrayIndex index, 
+            const Value &defaultValue ) const
+{
+   const Value *value = &((*this)[index]);
+   return value == &null ? defaultValue : *value;
+}
+
+
+bool 
+Value::isValidIndex( ArrayIndex index ) const
+{
+   return index < size();
+}
+
+
+
+const Value &
+Value::operator[]( const char *key ) const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, CZString::noDuplication );
+   ObjectValues::const_iterator it = value_.map_->find( actualKey );
+   if ( it == value_.map_->end() )
+      return null;
+   return (*it).second;
+#else
+   const Value *value = value_.map_->find( key );
+   return value ? *value : null;
+#endif
+}
+
+
+Value &
+Value::operator[]( const std::string &key )
+{
+   return (*this)[ key.c_str() ];
+}
+
+
+const Value &
+Value::operator[]( const std::string &key ) const
+{
+   return (*this)[ key.c_str() ];
+}
+
+Value &
+Value::operator[]( const StaticString &key )
+{
+   return resolveReference( key, true );
+}
+
+
+# ifdef JSON_USE_CPPTL
+Value &
+Value::operator[]( const CppTL::ConstString &key )
+{
+   return (*this)[ key.c_str() ];
+}
+
+
+const Value &
+Value::operator[]( const CppTL::ConstString &key ) const
+{
+   return (*this)[ key.c_str() ];
+}
+# endif
+
+
+Value &
+Value::append( const Value &value )
+{
+   return (*this)[size()] = value;
+}
+
+
+Value 
+Value::get( const char *key, 
+            const Value &defaultValue ) const
+{
+   const Value *value = &((*this)[key]);
+   return value == &null ? defaultValue : *value;
+}
+
+
+Value 
+Value::get( const std::string &key,
+            const Value &defaultValue ) const
+{
+   return get( key.c_str(), defaultValue );
+}
+
+Value
+Value::removeMember( const char* key )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, CZString::noDuplication );
+   ObjectValues::iterator it = value_.map_->find( actualKey );
+   if ( it == value_.map_->end() )
+      return null;
+   Value old(it->second);
+   value_.map_->erase(it);
+   return old;
+#else
+   Value *value = value_.map_->find( key );
+   if (value){
+      Value old(*value);
+      value_.map_.remove( key );
+      return old;
+   } else {
+      return null;
+   }
+#endif
+}
+
+Value
+Value::removeMember( const std::string &key )
+{
+   return removeMember( key.c_str() );
+}
+
+# ifdef JSON_USE_CPPTL
+Value 
+Value::get( const CppTL::ConstString &key,
+            const Value &defaultValue ) const
+{
+   return get( key.c_str(), defaultValue );
+}
+# endif
+
+bool 
+Value::isMember( const char *key ) const
+{
+   const Value *value = &((*this)[key]);
+   return value != &null;
+}
+
+
+bool 
+Value::isMember( const std::string &key ) const
+{
+   return isMember( key.c_str() );
+}
+
+
+# ifdef JSON_USE_CPPTL
+bool 
+Value::isMember( const CppTL::ConstString &key ) const
+{
+   return isMember( key.c_str() );
+}
+#endif
+
+Value::Members 
+Value::getMemberNames() const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+       return Value::Members();
+   Members members;
+   members.reserve( value_.map_->size() );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ObjectValues::const_iterator it = value_.map_->begin();
+   ObjectValues::const_iterator itEnd = value_.map_->end();
+   for ( ; it != itEnd; ++it )
+      members.push_back( std::string( (*it).first.c_str() ) );
+#else
+   ValueInternalMap::IteratorState it;
+   ValueInternalMap::IteratorState itEnd;
+   value_.map_->makeBeginIterator( it );
+   value_.map_->makeEndIterator( itEnd );
+   for ( ; !ValueInternalMap::equals( it, itEnd ); ValueInternalMap::increment(it) )
+      members.push_back( std::string( ValueInternalMap::key( it ) ) );
+#endif
+   return members;
+}
+//
+//# ifdef JSON_USE_CPPTL
+//EnumMemberNames
+//Value::enumMemberNames() const
+//{
+//   if ( type_ == objectValue )
+//   {
+//      return CppTL::Enum::any(  CppTL::Enum::transform(
+//         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
+//         MemberNamesTransform() ) );
+//   }
+//   return EnumMemberNames();
+//}
+//
+//
+//EnumValues 
+//Value::enumValues() const
+//{
+//   if ( type_ == objectValue  ||  type_ == arrayValue )
+//      return CppTL::Enum::anyValues( *(value_.map_), 
+//                                     CppTL::Type<const Value &>() );
+//   return EnumValues();
+//}
+//
+//# endif
+
+static bool IsIntegral(double d) {
+  double integral_part;
+  return modf(d, &integral_part) == 0.0;
+}
+
+
+bool
+Value::isNull() const
+{
+   return type_ == nullValue;
+}
+
+
+bool 
+Value::isBool() const
+{
+   return type_ == booleanValue;
+}
+
+
+bool 
+Value::isInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return value_.int_ >= minInt  &&  value_.int_ <= maxInt;
+   case uintValue:
+      return value_.uint_ <= UInt(maxInt);
+   case realValue:
+      return value_.real_ >= minInt &&
+             value_.real_ <= maxInt &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+   return false;
+}
+
+
+bool 
+Value::isUInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
+   case uintValue:
+      return value_.uint_ <= maxUInt;
+   case realValue:
+      return value_.real_ >= 0 &&
+             value_.real_ <= maxUInt &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+   return false;
+}
+
+bool 
+Value::isInt64() const
+{
+# if defined(JSON_HAS_INT64)
+   switch ( type_ )
+   {
+   case intValue:
+     return true;
+   case uintValue:
+      return value_.uint_ <= UInt64(maxInt64);
+   case realValue:
+      // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
+      // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
+      // require the value to be strictly less than the limit.
+      return value_.real_ >= double(minInt64) &&
+             value_.real_ < double(maxInt64) &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+# endif  // JSON_HAS_INT64
+   return false;
+}
+
+bool 
+Value::isUInt64() const
+{
+# if defined(JSON_HAS_INT64)
+   switch ( type_ )
+   {
+   case intValue:
+     return value_.int_ >= 0;
+   case uintValue:
+      return true;
+   case realValue:
+      // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+      // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+      // require the value to be strictly less than the limit.
+      return value_.real_ >= 0 &&
+             value_.real_ < maxUInt64AsDouble &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+# endif  // JSON_HAS_INT64
+   return false;
+}
+
+
+bool 
+Value::isIntegral() const
+{
+#if defined(JSON_HAS_INT64)
+  return isInt64() || isUInt64();
+#else
+  return isInt() || isUInt();
+#endif
+}
+
+
+bool 
+Value::isDouble() const
+{
+   return type_ == realValue || isIntegral();
+}
+
+
+bool 
+Value::isNumeric() const
+{
+   return isIntegral() || isDouble();
+}
+
+
+bool 
+Value::isString() const
+{
+   return type_ == stringValue;
+}
+
+
+bool 
+Value::isArray() const
+{
+   return type_ == arrayValue;
+}
+
+
+bool 
+Value::isObject() const
+{
+   return type_ == objectValue;
+}
+
+
+void 
+Value::setComment( const char *comment,
+                   CommentPlacement placement )
+{
+   if ( !comments_ )
+      comments_ = new CommentInfo[numberOfCommentPlacement];
+   comments_[placement].setComment( comment );
+}
+
+
+void 
+Value::setComment( const std::string &comment,
+                   CommentPlacement placement )
+{
+   setComment( comment.c_str(), placement );
+}
+
+
+bool 
+Value::hasComment( CommentPlacement placement ) const
+{
+   return comments_ != 0  &&  comments_[placement].comment_ != 0;
+}
+
+std::string 
+Value::getComment( CommentPlacement placement ) const
+{
+   if ( hasComment(placement) )
+      return comments_[placement].comment_;
+   return "";
+}
+
+
+std::string 
+Value::toStyledString() const
+{
+   StyledWriter writer;
+   return writer.write( *this );
+}
+
+
+Value::const_iterator 
+Value::begin() const
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeBeginIterator( it );
+         return const_iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeBeginIterator( it );
+         return const_iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return const_iterator( value_.map_->begin() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return const_iterator();
+}
+
+Value::const_iterator 
+Value::end() const
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeEndIterator( it );
+         return const_iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeEndIterator( it );
+         return const_iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return const_iterator( value_.map_->end() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return const_iterator();
+}
+
+
+Value::iterator 
+Value::begin()
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeBeginIterator( it );
+         return iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeBeginIterator( it );
+         return iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return iterator( value_.map_->begin() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return iterator();
+}
+
+Value::iterator 
+Value::end()
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeEndIterator( it );
+         return iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeEndIterator( it );
+         return iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return iterator( value_.map_->end() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return iterator();
+}
+
+
+// class PathArgument
+// //////////////////////////////////////////////////////////////////
+
+PathArgument::PathArgument()
+   : key_()
+   , index_()
+   , kind_( kindNone )
+{
+}
+
+
+PathArgument::PathArgument( ArrayIndex index )
+   : key_()
+   , index_( index )
+   , kind_( kindIndex )
+{
+}
+
+
+PathArgument::PathArgument( const char *key )
+   : key_( key )
+   , index_()
+   , kind_( kindKey )
+{
+}
+
+
+PathArgument::PathArgument( const std::string &key )
+   : key_( key.c_str() )
+   , index_()
+   , kind_( kindKey )
+{
+}
+
+// class Path
+// //////////////////////////////////////////////////////////////////
+
+Path::Path( const std::string &path,
+            const PathArgument &a1,
+            const PathArgument &a2,
+            const PathArgument &a3,
+            const PathArgument &a4,
+            const PathArgument &a5 )
+{
+   InArgs in;
+   in.push_back( &a1 );
+   in.push_back( &a2 );
+   in.push_back( &a3 );
+   in.push_back( &a4 );
+   in.push_back( &a5 );
+   makePath( path, in );
+}
+
+
+void 
+Path::makePath( const std::string &path,
+                const InArgs &in )
+{
+   const char *current = path.c_str();
+   const char *end = current + path.length();
+   InArgs::const_iterator itInArg = in.begin();
+   while ( current != end )
+   {
+      if ( *current == '[' )
+      {
+         ++current;
+         if ( *current == '%' )
+            addPathInArg( path, in, itInArg, PathArgument::kindIndex );
+         else
+         {
+            ArrayIndex index = 0;
+            for ( ; current != end && *current >= '0'  &&  *current <= '9'; ++current )
+               index = index * 10 + ArrayIndex(*current - '0');
+            args_.push_back( index );
+         }
+         if ( current == end  ||  *current++ != ']' )
+            invalidPath( path, int(current - path.c_str()) );
+      }
+      else if ( *current == '%' )
+      {
+         addPathInArg( path, in, itInArg, PathArgument::kindKey );
+         ++current;
+      }
+      else if ( *current == '.' )
+      {
+         ++current;
+      }
+      else
+      {
+         const char *beginName = current;
+         while ( current != end  &&  !strchr( "[.", *current ) )
+            ++current;
+         args_.push_back( std::string( beginName, current ) );
+      }
+   }
+}
+
+
+void 
+Path::addPathInArg( const std::string &path, 
+                    const InArgs &in, 
+                    InArgs::const_iterator &itInArg, 
+                    PathArgument::Kind kind )
+{
+   if ( itInArg == in.end() )
+   {
+      // Error: missing argument %d
+   }
+   else if ( (*itInArg)->kind_ != kind )
+   {
+      // Error: bad argument type
+   }
+   else
+   {
+      args_.push_back( **itInArg );
+   }
+}
+
+
+void 
+Path::invalidPath( const std::string &path, 
+                   int location )
+{
+   // Error: invalid path.
+}
+
+
+const Value &
+Path::resolve( const Value &root ) const
+{
+   const Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
+         {
+            // Error: unable to resolve path (array value expected at position...
+         }
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+         {
+            // Error: unable to resolve path (object value expected at position...)
+         }
+         node = &((*node)[arg.key_]);
+         if ( node == &Value::null )
+         {
+            // Error: unable to resolve path (object has no member named '' at position...)
+         }
+      }
+   }
+   return *node;
+}
+
+
+Value 
+Path::resolve( const Value &root, 
+               const Value &defaultValue ) const
+{
+   const Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
+            return defaultValue;
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+            return defaultValue;
+         node = &((*node)[arg.key_]);
+         if ( node == &Value::null )
+            return defaultValue;
+      }
+   }
+   return *node;
+}
+
+
+Value &
+Path::make( Value &root ) const
+{
+   Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray() )
+         {
+            // Error: node is not an array at position ...
+         }
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+         {
+            // Error: node is not an object at position...
+         }
+         node = &((*node)[arg.key_]);
+      }
+   }
+   return *node;
+}
+
+
+} // namespace Json
diff --git a/jsoncpp/src/lib_json/json_valueiterator.inl b/jsoncpp/src/lib_json/json_valueiterator.inl
new file mode 100644
index 0000000..7457ca3
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_valueiterator.inl
@@ -0,0 +1,299 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+// included by json_value.cpp
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIteratorBase
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIteratorBase::ValueIteratorBase()
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   : current_()
+   , isNull_( true )
+{
+}
+#else
+   : isArray_( true )
+   , isNull_( true )
+{
+   iterator_.array_ = ValueInternalArray::IteratorState();
+}
+#endif
+
+
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ValueIteratorBase::ValueIteratorBase( const Value::ObjectValues::iterator &current )
+   : current_( current )
+   , isNull_( false )
+{
+}
+#else
+ValueIteratorBase::ValueIteratorBase( const ValueInternalArray::IteratorState &state )
+   : isArray_( true )
+{
+   iterator_.array_ = state;
+}
+
+
+ValueIteratorBase::ValueIteratorBase( const ValueInternalMap::IteratorState &state )
+   : isArray_( false )
+{
+   iterator_.map_ = state;
+}
+#endif
+
+Value &
+ValueIteratorBase::deref() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   return current_->second;
+#else
+   if ( isArray_ )
+      return ValueInternalArray::dereference( iterator_.array_ );
+   return ValueInternalMap::value( iterator_.map_ );
+#endif
+}
+
+
+void 
+ValueIteratorBase::increment()
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ++current_;
+#else
+   if ( isArray_ )
+      ValueInternalArray::increment( iterator_.array_ );
+   ValueInternalMap::increment( iterator_.map_ );
+#endif
+}
+
+
+void 
+ValueIteratorBase::decrement()
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   --current_;
+#else
+   if ( isArray_ )
+      ValueInternalArray::decrement( iterator_.array_ );
+   ValueInternalMap::decrement( iterator_.map_ );
+#endif
+}
+
+
+ValueIteratorBase::difference_type 
+ValueIteratorBase::computeDistance( const SelfType &other ) const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+# ifdef JSON_USE_CPPTL_SMALLMAP
+   return current_ - other.current_;
+# else
+   // Iterator for null value are initialized using the default
+   // constructor, which initialize current_ to the default
+   // std::map::iterator. As begin() and end() are two instance 
+   // of the default std::map::iterator, they can not be compared.
+   // To allow this, we handle this comparison specifically.
+   if ( isNull_  &&  other.isNull_ )
+   {
+      return 0;
+   }
+
+
+   // Usage of std::distance is not portable (does not compile with Sun Studio 12 RogueWave STL,
+   // which is the one used by default).
+   // Using a portable hand-made version for non random iterator instead:
+   //   return difference_type( std::distance( current_, other.current_ ) );
+   difference_type myDistance = 0;
+   for ( Value::ObjectValues::iterator it = current_; it != other.current_; ++it )
+   {
+      ++myDistance;
+   }
+   return myDistance;
+# endif
+#else
+   if ( isArray_ )
+      return ValueInternalArray::distance( iterator_.array_, other.iterator_.array_ );
+   return ValueInternalMap::distance( iterator_.map_, other.iterator_.map_ );
+#endif
+}
+
+
+bool 
+ValueIteratorBase::isEqual( const SelfType &other ) const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   if ( isNull_ )
+   {
+      return other.isNull_;
+   }
+   return current_ == other.current_;
+#else
+   if ( isArray_ )
+      return ValueInternalArray::equals( iterator_.array_, other.iterator_.array_ );
+   return ValueInternalMap::equals( iterator_.map_, other.iterator_.map_ );
+#endif
+}
+
+
+void 
+ValueIteratorBase::copy( const SelfType &other )
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   current_ = other.current_;
+#else
+   if ( isArray_ )
+      iterator_.array_ = other.iterator_.array_;
+   iterator_.map_ = other.iterator_.map_;
+#endif
+}
+
+
+Value 
+ValueIteratorBase::key() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   const Value::CZString czstring = (*current_).first;
+   if ( czstring.c_str() )
+   {
+      if ( czstring.isStaticString() )
+         return Value( StaticString( czstring.c_str() ) );
+      return Value( czstring.c_str() );
+   }
+   return Value( czstring.index() );
+#else
+   if ( isArray_ )
+      return Value( ValueInternalArray::indexOf( iterator_.array_ ) );
+   bool isStatic;
+   const char *memberName = ValueInternalMap::key( iterator_.map_, isStatic );
+   if ( isStatic )
+      return Value( StaticString( memberName ) );
+   return Value( memberName );
+#endif
+}
+
+
+UInt 
+ValueIteratorBase::index() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   const Value::CZString czstring = (*current_).first;
+   if ( !czstring.c_str() )
+      return czstring.index();
+   return Value::UInt( -1 );
+#else
+   if ( isArray_ )
+      return Value::UInt( ValueInternalArray::indexOf( iterator_.array_ ) );
+   return Value::UInt( -1 );
+#endif
+}
+
+
+const char *
+ValueIteratorBase::memberName() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   const char *name = (*current_).first.c_str();
+   return name ? name : "";
+#else
+   if ( !isArray_ )
+      return ValueInternalMap::key( iterator_.map_ );
+   return "";
+#endif
+}
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueConstIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueConstIterator::ValueConstIterator()
+{
+}
+
+
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ValueConstIterator::ValueConstIterator( const Value::ObjectValues::iterator &current )
+   : ValueIteratorBase( current )
+{
+}
+#else
+ValueConstIterator::ValueConstIterator( const ValueInternalArray::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+
+ValueConstIterator::ValueConstIterator( const ValueInternalMap::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+#endif
+
+ValueConstIterator &
+ValueConstIterator::operator =( const ValueIteratorBase &other )
+{
+   copy( other );
+   return *this;
+}
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIterator::ValueIterator()
+{
+}
+
+
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ValueIterator::ValueIterator( const Value::ObjectValues::iterator &current )
+   : ValueIteratorBase( current )
+{
+}
+#else
+ValueIterator::ValueIterator( const ValueInternalArray::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+
+ValueIterator::ValueIterator( const ValueInternalMap::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+#endif
+
+ValueIterator::ValueIterator( const ValueConstIterator &other )
+   : ValueIteratorBase( other )
+{
+}
+
+ValueIterator::ValueIterator( const ValueIterator &other )
+   : ValueIteratorBase( other )
+{
+}
+
+ValueIterator &
+ValueIterator::operator =( const SelfType &other )
+{
+   copy( other );
+   return *this;
+}
+
+} // namespace Json
diff --git a/jsoncpp/src/lib_json/json_writer.cpp b/jsoncpp/src/lib_json/json_writer.cpp
new file mode 100644
index 0000000..b44def3
--- /dev/null
+++ b/jsoncpp/src/lib_json/json_writer.cpp
@@ -0,0 +1,841 @@
+// Copyright 2011 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/writer.h>
+# include "json_tool.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <utility>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <sstream>
+#include <iomanip>
+
+#if _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
+#endif
+
+namespace Json {
+
+static bool containsControlCharacter( const char* str )
+{
+   while ( *str ) 
+   {
+      if ( isControlCharacter( *(str++) ) )
+         return true;
+   }
+   return false;
+}
+
+
+std::string valueToString( LargestInt value )
+{
+   UIntToStringBuffer buffer;
+   char *current = buffer + sizeof(buffer);
+   bool isNegative = value < 0;
+   if ( isNegative )
+      value = -value;
+   uintToString( LargestUInt(value), current );
+   if ( isNegative )
+      *--current = '-';
+   assert( current >= buffer );
+   return current;
+}
+
+
+std::string valueToString( LargestUInt value )
+{
+   UIntToStringBuffer buffer;
+   char *current = buffer + sizeof(buffer);
+   uintToString( value, current );
+   assert( current >= buffer );
+   return current;
+}
+
+#if defined(JSON_HAS_INT64)
+
+std::string valueToString( Int value )
+{
+   return valueToString( LargestInt(value) );
+}
+
+
+std::string valueToString( UInt value )
+{
+   return valueToString( LargestUInt(value) );
+}
+
+#endif // # if defined(JSON_HAS_INT64)
+
+
+std::string valueToString( double value )
+{
+   char buffer[32];
+#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with visual studio 2005 to avoid warning. 
+   sprintf_s(buffer, sizeof(buffer), "%#.16g", value); 
+#else	
+   sprintf(buffer, "%#.16g", value); 
+#endif
+   char* ch = buffer + strlen(buffer) - 1;
+   if (*ch != '0') return buffer; // nothing to truncate, so save time
+   while(ch > buffer && *ch == '0'){
+     --ch;
+   }
+   char* last_nonzero = ch;
+   while(ch >= buffer){
+     switch(*ch){
+     case '0':
+     case '1':
+     case '2':
+     case '3':
+     case '4':
+     case '5':
+     case '6':
+     case '7':
+     case '8':
+     case '9':
+       --ch;
+       continue;
+     case '.':
+       // Truncate zeroes to save bytes in output, but keep one.
+       *(last_nonzero+2) = '\0';
+       return buffer;
+     default:
+       return buffer;
+     }
+   }
+   return buffer;
+}
+
+
+std::string valueToString( bool value )
+{
+   return value ? "true" : "false";
+}
+
+std::string valueToQuotedString( const char *value )
+{
+   if (value == NULL)
+      return "";
+   // Not sure how to handle unicode...
+   if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL && !containsControlCharacter( value ))
+      return std::string("\"") + value + "\"";
+   // We have to walk value and escape any special characters.
+   // Appending to std::string is not efficient, but this should be rare.
+   // (Note: forward slashes are *not* rare, but I am not escaping them.)
+   std::string::size_type maxsize = strlen(value)*2 + 3; // allescaped+quotes+NULL
+   std::string result;
+   result.reserve(maxsize); // to avoid lots of mallocs
+   result += "\"";
+   for (const char* c=value; *c != 0; ++c)
+   {
+      switch(*c)
+      {
+         case '\"':
+            result += "\\\"";
+            break;
+         case '\\':
+            result += "\\\\";
+            break;
+         case '\b':
+            result += "\\b";
+            break;
+         case '\f':
+            result += "\\f";
+            break;
+         case '\n':
+            result += "\\n";
+            break;
+         case '\r':
+            result += "\\r";
+            break;
+         case '\t':
+            result += "\\t";
+            break;
+         //case '/':
+            // Even though \/ is considered a legal escape in JSON, a bare
+            // slash is also legal, so I see no reason to escape it.
+            // (I hope I am not misunderstanding something.
+            // blep notes: actually escaping \/ may be useful in javascript to avoid </ 
+            // sequence.
+            // Should add a flag to allow this compatibility mode and prevent this 
+            // sequence from occurring.
+         default:
+            if ( isControlCharacter( *c ) )
+            {
+               std::ostringstream oss;
+               oss << "\\u" << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << static_cast<int>(*c);
+               result += oss.str();
+            }
+            else
+            {
+               result += *c;
+            }
+            break;
+      }
+   }
+   result += "\"";
+   return result;
+}
+
+// Class Writer
+// //////////////////////////////////////////////////////////////////
+Writer::~Writer()
+{
+}
+
+
+// Class FastWriter
+// //////////////////////////////////////////////////////////////////
+
+FastWriter::FastWriter()
+   : yamlCompatiblityEnabled_( false )
+{
+}
+
+
+void 
+FastWriter::enableYAMLCompatibility()
+{
+   yamlCompatiblityEnabled_ = true;
+}
+
+
+std::string 
+FastWriter::write( const Value &root )
+{
+   document_ = "";
+   writeValue( root );
+   document_ += "\n";
+   return document_;
+}
+
+
+void 
+FastWriter::writeValue( const Value &value )
+{
+   switch ( value.type() )
+   {
+   case nullValue:
+      document_ += "null";
+      break;
+   case intValue:
+      document_ += valueToString( value.asLargestInt() );
+      break;
+   case uintValue:
+      document_ += valueToString( value.asLargestUInt() );
+      break;
+   case realValue:
+      document_ += valueToString( value.asDouble() );
+      break;
+   case stringValue:
+      document_ += valueToQuotedString( value.asCString() );
+      break;
+   case booleanValue:
+      document_ += valueToString( value.asBool() );
+      break;
+   case arrayValue:
+      {
+         document_ += "[";
+         int size = value.size();
+         for ( int index =0; index < size; ++index )
+         {
+            if ( index > 0 )
+               document_ += ",";
+            writeValue( value[index] );
+         }
+         document_ += "]";
+      }
+      break;
+   case objectValue:
+      {
+         Value::Members members( value.getMemberNames() );
+         document_ += "{";
+         for ( Value::Members::iterator it = members.begin(); 
+               it != members.end(); 
+               ++it )
+         {
+            const std::string &name = *it;
+            if ( it != members.begin() )
+               document_ += ",";
+            document_ += valueToQuotedString( name.c_str() );
+            document_ += yamlCompatiblityEnabled_ ? ": " 
+                                                  : ":";
+            writeValue( value[name] );
+         }
+         document_ += "}";
+      }
+      break;
+   }
+}
+
+
+// Class StyledWriter
+// //////////////////////////////////////////////////////////////////
+
+StyledWriter::StyledWriter()
+   : rightMargin_( 74 )
+   , indentSize_( 3 )
+   , addChildValues_()
+{
+}
+
+
+std::string 
+StyledWriter::write( const Value &root )
+{
+   document_ = "";
+   addChildValues_ = false;
+   indentString_ = "";
+   writeCommentBeforeValue( root );
+   writeValue( root );
+   writeCommentAfterValueOnSameLine( root );
+   document_ += "\n";
+   return document_;
+}
+
+
+void 
+StyledWriter::writeValue( const Value &value )
+{
+   switch ( value.type() )
+   {
+   case nullValue:
+      pushValue( "null" );
+      break;
+   case intValue:
+      pushValue( valueToString( value.asLargestInt() ) );
+      break;
+   case uintValue:
+      pushValue( valueToString( value.asLargestUInt() ) );
+      break;
+   case realValue:
+      pushValue( valueToString( value.asDouble() ) );
+      break;
+   case stringValue:
+      pushValue( valueToQuotedString( value.asCString() ) );
+      break;
+   case booleanValue:
+      pushValue( valueToString( value.asBool() ) );
+      break;
+   case arrayValue:
+      writeArrayValue( value);
+      break;
+   case objectValue:
+      {
+         Value::Members members( value.getMemberNames() );
+         if ( members.empty() )
+            pushValue( "{}" );
+         else
+         {
+            writeWithIndent( "{" );
+            indent();
+            Value::Members::iterator it = members.begin();
+            for (;;)
+            {
+               const std::string &name = *it;
+               const Value &childValue = value[name];
+               writeCommentBeforeValue( childValue );
+               writeWithIndent( valueToQuotedString( name.c_str() ) );
+               document_ += " : ";
+               writeValue( childValue );
+               if ( ++it == members.end() )
+               {
+                  writeCommentAfterValueOnSameLine( childValue );
+                  break;
+               }
+               document_ += ",";
+               writeCommentAfterValueOnSameLine( childValue );
+            }
+            unindent();
+            writeWithIndent( "}" );
+         }
+      }
+      break;
+   }
+}
+
+
+void 
+StyledWriter::writeArrayValue( const Value &value )
+{
+   unsigned size = value.size();
+   if ( size == 0 )
+      pushValue( "[]" );
+   else
+   {
+      bool isArrayMultiLine = isMultineArray( value );
+      if ( isArrayMultiLine )
+      {
+         writeWithIndent( "[" );
+         indent();
+         bool hasChildValue = !childValues_.empty();
+         unsigned index =0;
+         for (;;)
+         {
+            const Value &childValue = value[index];
+            writeCommentBeforeValue( childValue );
+            if ( hasChildValue )
+               writeWithIndent( childValues_[index] );
+            else
+            {
+               writeIndent();
+               writeValue( childValue );
+            }
+            if ( ++index == size )
+            {
+               writeCommentAfterValueOnSameLine( childValue );
+               break;
+            }
+            document_ += ",";
+            writeCommentAfterValueOnSameLine( childValue );
+         }
+         unindent();
+         writeWithIndent( "]" );
+      }
+      else // output on a single line
+      {
+         assert( childValues_.size() == size );
+         document_ += "[ ";
+         for ( unsigned index =0; index < size; ++index )
+         {
+            if ( index > 0 )
+               document_ += ", ";
+            document_ += childValues_[index];
+         }
+         document_ += " ]";
+      }
+   }
+}
+
+
+bool 
+StyledWriter::isMultineArray( const Value &value )
+{
+   int size = value.size();
+   bool isMultiLine = size*3 >= rightMargin_ ;
+   childValues_.clear();
+   for ( int index =0; index < size  &&  !isMultiLine; ++index )
+   {
+      const Value &childValue = value[index];
+      isMultiLine = isMultiLine  ||
+                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
+                        childValue.size() > 0 );
+   }
+   if ( !isMultiLine ) // check if line length > max line length
+   {
+      childValues_.reserve( size );
+      addChildValues_ = true;
+      int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
+      for ( int index =0; index < size  &&  !isMultiLine; ++index )
+      {
+         writeValue( value[index] );
+         lineLength += int( childValues_[index].length() );
+         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
+      }
+      addChildValues_ = false;
+      isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;
+   }
+   return isMultiLine;
+}
+
+
+void 
+StyledWriter::pushValue( const std::string &value )
+{
+   if ( addChildValues_ )
+      childValues_.push_back( value );
+   else
+      document_ += value;
+}
+
+
+void 
+StyledWriter::writeIndent()
+{
+   if ( !document_.empty() )
+   {
+      char last = document_[document_.length()-1];
+      if ( last == ' ' )     // already indented
+         return;
+      if ( last != '\n' )    // Comments may add new-line
+         document_ += '\n';
+   }
+   document_ += indentString_;
+}
+
+
+void 
+StyledWriter::writeWithIndent( const std::string &value )
+{
+   writeIndent();
+   document_ += value;
+}
+
+
+void 
+StyledWriter::indent()
+{
+   indentString_ += std::string( indentSize_, ' ' );
+}
+
+
+void 
+StyledWriter::unindent()
+{
+   assert( int(indentString_.size()) >= indentSize_ );
+   indentString_.resize( indentString_.size() - indentSize_ );
+}
+
+
+void 
+StyledWriter::writeCommentBeforeValue( const Value &root )
+{
+   if ( !root.hasComment( commentBefore ) )
+      return;
+   document_ += normalizeEOL( root.getComment( commentBefore ) );
+   document_ += "\n";
+}
+
+
+void 
+StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )
+{
+   if ( root.hasComment( commentAfterOnSameLine ) )
+      document_ += " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
+
+   if ( root.hasComment( commentAfter ) )
+   {
+      document_ += "\n";
+      document_ += normalizeEOL( root.getComment( commentAfter ) );
+      document_ += "\n";
+   }
+}
+
+
+bool 
+StyledWriter::hasCommentForValue( const Value &value )
+{
+   return value.hasComment( commentBefore )
+          ||  value.hasComment( commentAfterOnSameLine )
+          ||  value.hasComment( commentAfter );
+}
+
+
+std::string 
+StyledWriter::normalizeEOL( const std::string &text )
+{
+   std::string normalized;
+   normalized.reserve( text.length() );
+   const char *begin = text.c_str();
+   const char *end = begin + text.length();
+   const char *current = begin;
+   while ( current != end )
+   {
+      char c = *current++;
+      if ( c == '\r' ) // mac or dos EOL
+      {
+         if ( *current == '\n' ) // convert dos EOL
+            ++current;
+         normalized += '\n';
+      }
+      else // handle unix EOL & other char
+         normalized += c;
+   }
+   return normalized;
+}
+
+
+// Class StyledStreamWriter
+// //////////////////////////////////////////////////////////////////
+
+StyledStreamWriter::StyledStreamWriter( std::string indentation )
+   : document_(NULL)
+   , rightMargin_( 74 )
+   , indentation_( indentation )
+   , addChildValues_()
+{
+}
+
+
+void
+StyledStreamWriter::write( std::ostream &out, const Value &root )
+{
+   document_ = &out;
+   addChildValues_ = false;
+   indentString_ = "";
+   writeCommentBeforeValue( root );
+   writeValue( root );
+   writeCommentAfterValueOnSameLine( root );
+   *document_ << "\n";
+   document_ = NULL; // Forget the stream, for safety.
+}
+
+
+void 
+StyledStreamWriter::writeValue( const Value &value )
+{
+   switch ( value.type() )
+   {
+   case nullValue:
+      pushValue( "null" );
+      break;
+   case intValue:
+      pushValue( valueToString( value.asLargestInt() ) );
+      break;
+   case uintValue:
+      pushValue( valueToString( value.asLargestUInt() ) );
+      break;
+   case realValue:
+      pushValue( valueToString( value.asDouble() ) );
+      break;
+   case stringValue:
+      pushValue( valueToQuotedString( value.asCString() ) );
+      break;
+   case booleanValue:
+      pushValue( valueToString( value.asBool() ) );
+      break;
+   case arrayValue:
+      writeArrayValue( value);
+      break;
+   case objectValue:
+      {
+         Value::Members members( value.getMemberNames() );
+         if ( members.empty() )
+            pushValue( "{}" );
+         else
+         {
+            writeWithIndent( "{" );
+            indent();
+            Value::Members::iterator it = members.begin();
+            for (;;)
+            {
+               const std::string &name = *it;
+               const Value &childValue = value[name];
+               writeCommentBeforeValue( childValue );
+               writeWithIndent( valueToQuotedString( name.c_str() ) );
+               *document_ << " : ";
+               writeValue( childValue );
+               if ( ++it == members.end() )
+               {
+                  writeCommentAfterValueOnSameLine( childValue );
+                  break;
+               }
+               *document_ << ",";
+               writeCommentAfterValueOnSameLine( childValue );
+            }
+            unindent();
+            writeWithIndent( "}" );
+         }
+      }
+      break;
+   }
+}
+
+
+void 
+StyledStreamWriter::writeArrayValue( const Value &value )
+{
+   unsigned size = value.size();
+   if ( size == 0 )
+      pushValue( "[]" );
+   else
+   {
+      bool isArrayMultiLine = isMultineArray( value );
+      if ( isArrayMultiLine )
+      {
+         writeWithIndent( "[" );
+         indent();
+         bool hasChildValue = !childValues_.empty();
+         unsigned index =0;
+         for (;;)
+         {
+            const Value &childValue = value[index];
+            writeCommentBeforeValue( childValue );
+            if ( hasChildValue )
+               writeWithIndent( childValues_[index] );
+            else
+            {
+               writeIndent();
+               writeValue( childValue );
+            }
+            if ( ++index == size )
+            {
+               writeCommentAfterValueOnSameLine( childValue );
+               break;
+            }
+            *document_ << ",";
+            writeCommentAfterValueOnSameLine( childValue );
+         }
+         unindent();
+         writeWithIndent( "]" );
+      }
+      else // output on a single line
+      {
+         assert( childValues_.size() == size );
+         *document_ << "[ ";
+         for ( unsigned index =0; index < size; ++index )
+         {
+            if ( index > 0 )
+               *document_ << ", ";
+            *document_ << childValues_[index];
+         }
+         *document_ << " ]";
+      }
+   }
+}
+
+
+bool 
+StyledStreamWriter::isMultineArray( const Value &value )
+{
+   int size = value.size();
+   bool isMultiLine = size*3 >= rightMargin_ ;
+   childValues_.clear();
+   for ( int index =0; index < size  &&  !isMultiLine; ++index )
+   {
+      const Value &childValue = value[index];
+      isMultiLine = isMultiLine  ||
+                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
+                        childValue.size() > 0 );
+   }
+   if ( !isMultiLine ) // check if line length > max line length
+   {
+      childValues_.reserve( size );
+      addChildValues_ = true;
+      int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
+      for ( int index =0; index < size  &&  !isMultiLine; ++index )
+      {
+         writeValue( value[index] );
+         lineLength += int( childValues_[index].length() );
+         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
+      }
+      addChildValues_ = false;
+      isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;
+   }
+   return isMultiLine;
+}
+
+
+void 
+StyledStreamWriter::pushValue( const std::string &value )
+{
+   if ( addChildValues_ )
+      childValues_.push_back( value );
+   else
+      *document_ << value;
+}
+
+
+void 
+StyledStreamWriter::writeIndent()
+{
+  /*
+    Some comments in this method would have been nice. ;-)
+
+   if ( !document_.empty() )
+   {
+      char last = document_[document_.length()-1];
+      if ( last == ' ' )     // already indented
+         return;
+      if ( last != '\n' )    // Comments may add new-line
+         *document_ << '\n';
+   }
+  */
+   *document_ << '\n' << indentString_;
+}
+
+
+void 
+StyledStreamWriter::writeWithIndent( const std::string &value )
+{
+   writeIndent();
+   *document_ << value;
+}
+
+
+void 
+StyledStreamWriter::indent()
+{
+   indentString_ += indentation_;
+}
+
+
+void 
+StyledStreamWriter::unindent()
+{
+   assert( indentString_.size() >= indentation_.size() );
+   indentString_.resize( indentString_.size() - indentation_.size() );
+}
+
+
+void 
+StyledStreamWriter::writeCommentBeforeValue( const Value &root )
+{
+   if ( !root.hasComment( commentBefore ) )
+      return;
+   *document_ << normalizeEOL( root.getComment( commentBefore ) );
+   *document_ << "\n";
+}
+
+
+void 
+StyledStreamWriter::writeCommentAfterValueOnSameLine( const Value &root )
+{
+   if ( root.hasComment( commentAfterOnSameLine ) )
+      *document_ << " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
+
+   if ( root.hasComment( commentAfter ) )
+   {
+      *document_ << "\n";
+      *document_ << normalizeEOL( root.getComment( commentAfter ) );
+      *document_ << "\n";
+   }
+}
+
+
+bool 
+StyledStreamWriter::hasCommentForValue( const Value &value )
+{
+   return value.hasComment( commentBefore )
+          ||  value.hasComment( commentAfterOnSameLine )
+          ||  value.hasComment( commentAfter );
+}
+
+
+std::string 
+StyledStreamWriter::normalizeEOL( const std::string &text )
+{
+   std::string normalized;
+   normalized.reserve( text.length() );
+   const char *begin = text.c_str();
+   const char *end = begin + text.length();
+   const char *current = begin;
+   while ( current != end )
+   {
+      char c = *current++;
+      if ( c == '\r' ) // mac or dos EOL
+      {
+         if ( *current == '\n' ) // convert dos EOL
+            ++current;
+         normalized += '\n';
+      }
+      else // handle unix EOL & other char
+         normalized += c;
+   }
+   return normalized;
+}
+
+
+std::ostream& operator<<( std::ostream &sout, const Value &root )
+{
+   Json::StyledStreamWriter writer;
+   writer.write(sout, root);
+   return sout;
+}
+
+
+} // namespace Json
diff --git a/jsoncpp/src/lib_json/sconscript b/jsoncpp/src/lib_json/sconscript
new file mode 100644
index 0000000..6e7c6c8
--- /dev/null
+++ b/jsoncpp/src/lib_json/sconscript
@@ -0,0 +1,8 @@
+Import( 'env buildLibrary' )
+
+buildLibrary( env, Split( """
+    json_reader.cpp 
+    json_value.cpp 
+    json_writer.cpp
+     """ ),
+    'json' )
diff --git a/jsoncpp/src/test_lib_json/jsontest.cpp b/jsoncpp/src/test_lib_json/jsontest.cpp
new file mode 100644
index 0000000..327d344
--- /dev/null
+++ b/jsoncpp/src/test_lib_json/jsontest.cpp
@@ -0,0 +1,575 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
+#include "jsontest.h"
+#include <stdio.h>
+#include <string>
+
+#if defined(_MSC_VER)
+// Used to install a report hook that prevent dialog on assertion and error.
+# include <crtdbg.h>
+#endif // if defined(_MSC_VER)
+
+#if defined(_WIN32)
+// Used to prevent dialog on memory fault.
+// Limits headers included by Windows.h
+# define WIN32_LEAN_AND_MEAN
+# define NOSERVICE
+# define NOMCX
+# define NOIME
+# define NOSOUND
+# define NOCOMM
+# define NORPC
+# define NOGDI
+# define NOUSER
+# define NODRIVERS
+# define NOLOGERROR
+# define NOPROFILER
+# define NOMEMMGR
+# define NOLFILEIO
+# define NOOPENFILE
+# define NORESOURCE
+# define NOATOM
+# define NOLANGUAGE
+# define NOLSTRING
+# define NODBCS
+# define NOKEYBOARDINFO
+# define NOGDICAPMASKS
+# define NOCOLOR
+# define NOGDIOBJ
+# define NODRAWTEXT
+# define NOTEXTMETRIC
+# define NOSCALABLEFONT
+# define NOBITMAP
+# define NORASTEROPS
+# define NOMETAFILE
+# define NOSYSMETRICS
+# define NOSYSTEMPARAMSINFO
+# define NOMSG
+# define NOWINSTYLES
+# define NOWINOFFSETS
+# define NOSHOWWINDOW
+# define NODEFERWINDOWPOS
+# define NOVIRTUALKEYCODES
+# define NOKEYSTATES
+# define NOWH
+# define NOMENUS
+# define NOSCROLL
+# define NOCLIPBOARD
+# define NOICONS
+# define NOMB
+# define NOSYSCOMMANDS
+# define NOMDI
+# define NOCTLMGR
+# define NOWINMESSAGES
+# include <windows.h>
+#endif // if defined(_WIN32)
+
+namespace JsonTest {
+
+
+// class TestResult
+// //////////////////////////////////////////////////////////////////
+
+TestResult::TestResult()
+   : predicateId_( 1 )
+   , lastUsedPredicateId_( 0 )
+   , messageTarget_( 0 )
+{
+   // The root predicate has id 0
+   rootPredicateNode_.id_ = 0;
+   rootPredicateNode_.next_ = 0;
+   predicateStackTail_ = &rootPredicateNode_;
+}
+
+
+void 
+TestResult::setTestName( const std::string &name )
+{
+   name_ = name;
+}
+
+TestResult &
+TestResult::addFailure( const char *file, unsigned int line,
+                        const char *expr )
+{
+   /// Walks the PredicateContext stack adding them to failures_ if not already added.
+   unsigned int nestingLevel = 0;
+   PredicateContext *lastNode = rootPredicateNode_.next_;
+   for ( ; lastNode != 0; lastNode = lastNode->next_ )
+   {
+      if ( lastNode->id_ > lastUsedPredicateId_ ) // new PredicateContext
+      {
+         lastUsedPredicateId_ = lastNode->id_;
+         addFailureInfo( lastNode->file_, lastNode->line_, lastNode->expr_,
+                         nestingLevel );
+         // Link the PredicateContext to the failure for message target when 
+         // popping the PredicateContext.
+         lastNode->failure_ = &( failures_.back() );
+      }
+      ++nestingLevel;
+   }
+
+   // Adds the failed assertion
+   addFailureInfo( file, line, expr, nestingLevel );
+   messageTarget_ = &( failures_.back() );
+   return *this;
+}
+
+
+void 
+TestResult::addFailureInfo( const char *file, unsigned int line,
+                            const char *expr, unsigned int nestingLevel )
+{
+   Failure failure;
+   failure.file_ = file;
+   failure.line_ = line;
+   if ( expr )
+   {
+      failure.expr_ = expr;
+   }
+   failure.nestingLevel_ = nestingLevel;
+   failures_.push_back( failure );
+}
+
+
+TestResult &
+TestResult::popPredicateContext()
+{
+   PredicateContext *lastNode = &rootPredicateNode_;
+   while ( lastNode->next_ != 0  &&  lastNode->next_->next_ != 0 )
+   {
+      lastNode = lastNode->next_;
+   }
+   // Set message target to popped failure
+   PredicateContext *tail = lastNode->next_;
+   if ( tail != 0  &&  tail->failure_ != 0 )
+   {
+      messageTarget_ = tail->failure_;
+   }
+   // Remove tail from list
+   predicateStackTail_ = lastNode;
+   lastNode->next_ = 0;
+   return *this;
+}
+
+
+bool 
+TestResult::failed() const
+{
+   return !failures_.empty();
+}
+
+
+unsigned int 
+TestResult::getAssertionNestingLevel() const
+{
+   unsigned int level = 0;
+   const PredicateContext *lastNode = &rootPredicateNode_;
+   while ( lastNode->next_ != 0 )
+   {
+      lastNode = lastNode->next_;
+      ++level;
+   }
+   return level;
+}
+
+
+void 
+TestResult::printFailure( bool printTestName ) const
+{
+   if ( failures_.empty() )
+   {
+      return;
+   }
+
+   if ( printTestName )
+   {
+      printf( "* Detail of %s test failure:\n", name_.c_str() );
+   }
+
+   // Print in reverse to display the callstack in the right order
+   Failures::const_iterator itEnd = failures_.end();
+   for ( Failures::const_iterator it = failures_.begin(); it != itEnd; ++it )
+   {
+      const Failure &failure = *it;
+      std::string indent( failure.nestingLevel_ * 2, ' ' );
+      if ( failure.file_ )
+      {
+         printf( "%s%s(%d): ", indent.c_str(), failure.file_, failure.line_ );
+      }
+      if ( !failure.expr_.empty() )
+      {
+         printf( "%s\n", failure.expr_.c_str() );
+      }
+      else if ( failure.file_ )
+      {
+         printf( "\n" );
+      }
+      if ( !failure.message_.empty() )
+      {
+         std::string reindented = indentText( failure.message_, indent + "  " );
+         printf( "%s\n", reindented.c_str() );
+      }
+   }
+}
+
+
+std::string 
+TestResult::indentText( const std::string &text, 
+                        const std::string &indent )
+{
+   std::string reindented;
+   std::string::size_type lastIndex = 0;
+   while ( lastIndex < text.size() )
+   {
+      std::string::size_type nextIndex = text.find( '\n', lastIndex );
+      if ( nextIndex == std::string::npos )
+      {
+         nextIndex = text.size() - 1;
+      }
+      reindented += indent;
+      reindented += text.substr( lastIndex, nextIndex - lastIndex + 1 );
+      lastIndex = nextIndex + 1;
+   }
+   return reindented;
+}
+
+
+TestResult &
+TestResult::addToLastFailure( const std::string &message )
+{
+   if ( messageTarget_ != 0 )
+   {
+      messageTarget_->message_ += message;
+   }
+   return *this;
+}
+
+TestResult &
+TestResult::operator << ( Json::Int64 value ) {
+   return addToLastFailure( Json::valueToString(value) );
+}
+
+
+TestResult &
+TestResult::operator << ( Json::UInt64 value ) {
+   return addToLastFailure( Json::valueToString(value) );
+}
+
+
+TestResult &
+TestResult::operator << ( bool value ) {
+   return addToLastFailure(value ? "true" : "false");
+}
+
+
+// class TestCase
+// //////////////////////////////////////////////////////////////////
+
+TestCase::TestCase()
+   : result_( 0 )
+{
+}
+
+
+TestCase::~TestCase()
+{
+}
+
+
+void 
+TestCase::run( TestResult &result )
+{
+   result_ = &result;
+   runTestCase();
+}
+
+
+
+// class Runner
+// //////////////////////////////////////////////////////////////////
+
+Runner::Runner()
+{
+}
+
+
+Runner &
+Runner::add( TestCaseFactory factory )
+{
+   tests_.push_back( factory );
+   return *this;
+}
+
+
+unsigned int 
+Runner::testCount() const
+{
+   return static_cast<unsigned int>( tests_.size() );
+}
+
+
+std::string 
+Runner::testNameAt( unsigned int index ) const
+{
+   TestCase *test = tests_[index]();
+   std::string name = test->testName();
+   delete test;
+   return name;
+}
+
+
+void 
+Runner::runTestAt( unsigned int index, TestResult &result ) const
+{
+   TestCase *test = tests_[index]();
+   result.setTestName( test->testName() );
+   printf( "Testing %s: ", test->testName() );
+   fflush( stdout );
+#if JSON_USE_EXCEPTION
+   try 
+   {
+#endif // if JSON_USE_EXCEPTION
+      test->run( result );
+#if JSON_USE_EXCEPTION
+   } 
+   catch ( const std::exception &e ) 
+   {
+      result.addFailure( __FILE__, __LINE__, 
+         "Unexpected exception caught:" ) << e.what();
+   }
+#endif // if JSON_USE_EXCEPTION
+   delete test;
+   const char *status = result.failed() ? "FAILED" 
+                                        : "OK";
+   printf( "%s\n", status );
+   fflush( stdout );
+}
+
+
+bool 
+Runner::runAllTest( bool printSummary ) const
+{
+   unsigned int count = testCount();
+   std::deque<TestResult> failures;
+   for ( unsigned int index = 0; index < count; ++index )
+   {
+      TestResult result;
+      runTestAt( index, result );
+      if ( result.failed() )
+      {
+         failures.push_back( result );
+      }
+   }
+
+   if ( failures.empty() )
+   {
+      if ( printSummary )
+      {
+         printf( "All %d tests passed\n", count );
+      }
+      return true;
+   }
+   else
+   {
+      for ( unsigned int index = 0; index < failures.size(); ++index )
+      {
+         TestResult &result = failures[index];
+         result.printFailure( count > 1 );
+      }
+
+      if ( printSummary )
+      {
+         unsigned int failedCount = static_cast<unsigned int>( failures.size() );
+         unsigned int passedCount = count - failedCount;
+         printf( "%d/%d tests passed (%d failure(s))\n", passedCount, count, failedCount );
+      }
+      return false;
+   }
+}
+
+
+bool 
+Runner::testIndex( const std::string &testName, 
+                   unsigned int &indexOut ) const
+{
+   unsigned int count = testCount();
+   for ( unsigned int index = 0; index < count; ++index )
+   {
+      if ( testNameAt(index) == testName )
+      {
+         indexOut = index;
+         return true;
+      }
+   }
+   return false;
+}
+
+
+void 
+Runner::listTests() const
+{
+   unsigned int count = testCount();
+   for ( unsigned int index = 0; index < count; ++index )
+   {
+      printf( "%s\n", testNameAt( index ).c_str() );
+   }
+}
+
+
+int 
+Runner::runCommandLine( int argc, const char *argv[] ) const
+{
+   typedef std::deque<std::string> TestNames;
+   Runner subrunner;
+   for ( int index = 1; index < argc; ++index )
+   {
+      std::string opt = argv[index];
+      if ( opt == "--list-tests" )
+      {
+         listTests();
+         return 0;
+      }
+      else if ( opt == "--test-auto" )
+      {
+         preventDialogOnCrash();
+      }
+      else if ( opt == "--test" )
+      {
+         ++index;
+         if ( index < argc )
+         {
+            unsigned int testNameIndex;
+            if ( testIndex( argv[index], testNameIndex ) )
+            {
+               subrunner.add( tests_[testNameIndex] );
+            }
+            else
+            {
+               fprintf( stderr, "Test '%s' does not exist!\n", argv[index] );
+               return 2;
+            }
+         }
+         else
+         {
+            printUsage( argv[0] );
+            return 2;
+         }
+      }
+      else
+      {
+         printUsage( argv[0] );
+         return 2;
+      }
+   }
+   bool succeeded;
+   if ( subrunner.testCount() > 0 )
+   {
+      succeeded = subrunner.runAllTest( subrunner.testCount() > 1 );
+   }
+   else
+   {
+      succeeded = runAllTest( true );
+   }
+   return succeeded ? 0 
+                    : 1;
+}
+
+
+#if defined(_MSC_VER)
+// Hook MSVCRT assertions to prevent dialog from appearing
+static int 
+msvcrtSilentReportHook( int reportType, char *message, int *returnValue )
+{
+   // The default CRT handling of error and assertion is to display
+   // an error dialog to the user.
+   // Instead, when an error or an assertion occurs, we force the 
+   // application to terminate using abort() after display
+   // the message on stderr. 
+   if ( reportType == _CRT_ERROR  ||  
+        reportType == _CRT_ASSERT )
+   {
+      // calling abort() cause the ReportHook to be called
+      // The following is used to detect this case and let's the
+      // error handler fallback on its default behaviour (
+      // display a warning message)
+      static volatile bool isAborting = false;
+      if ( isAborting ) 
+      {
+         return TRUE;
+      }
+      isAborting = true;
+
+      fprintf( stderr, "CRT Error/Assert:\n%s\n", message );
+      fflush( stderr );
+      abort();
+   }
+   // Let's other reportType (_CRT_WARNING) be handled as they would by default
+   return FALSE;
+}
+#endif // if defined(_MSC_VER)
+
+
+void 
+Runner::preventDialogOnCrash()
+{
+#if defined(_MSC_VER)
+   // Install a hook to prevent MSVCRT error and assertion from
+   // popping a dialog.
+   _CrtSetReportHook( &msvcrtSilentReportHook );
+#endif // if defined(_MSC_VER)
+
+   // @todo investiguate this handler (for buffer overflow)
+   // _set_security_error_handler
+
+#if defined(_WIN32)
+   // Prevents the system from popping a dialog for debugging if the
+   // application fails due to invalid memory access.
+   SetErrorMode( SEM_FAILCRITICALERRORS 
+                 | SEM_NOGPFAULTERRORBOX 
+                 | SEM_NOOPENFILEERRORBOX );
+#endif // if defined(_WIN32)
+}
+
+void 
+Runner::printUsage( const char *appName )
+{
+   printf( 
+      "Usage: %s [options]\n"
+      "\n"
+      "If --test is not specified, then all the test cases be run.\n"
+      "\n"
+      "Valid options:\n"
+      "--list-tests: print the name of all test cases on the standard\n"
+      "              output and exit.\n"
+      "--test TESTNAME: executes the test case with the specified name.\n"
+      "                 May be repeated.\n"
+      "--test-auto: prevent dialog prompting for debugging on crash.\n"
+      , appName );
+}
+
+
+
+// Assertion functions
+// //////////////////////////////////////////////////////////////////
+
+TestResult &
+checkStringEqual( TestResult &result, 
+                  const std::string &expected, const std::string &actual,
+                  const char *file, unsigned int line, const char *expr )
+{
+   if ( expected != actual )
+   {
+      result.addFailure( file, line, expr );
+      result << "Expected: '" << expected << "'\n";
+      result << "Actual  : '" << actual << "'";
+   }
+   return result;
+}
+
+
+} // namespace JsonTest
diff --git a/jsoncpp/src/test_lib_json/jsontest.h b/jsoncpp/src/test_lib_json/jsontest.h
new file mode 100644
index 0000000..207692b
--- /dev/null
+++ b/jsoncpp/src/test_lib_json/jsontest.h
@@ -0,0 +1,273 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSONTEST_H_INCLUDED
+# define JSONTEST_H_INCLUDED
+
+# include <json/config.h>
+# include <json/value.h>
+# include <json/writer.h>
+# include <stdio.h>
+# include <deque>
+# include <sstream>
+# include <string>
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// Mini Unit Testing framework
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+
+
+/** \brief Unit testing framework.
+ * \warning: all assertions are non-aborting, test case execution will continue
+ *           even if an assertion namespace.
+ *           This constraint is for portability: the framework needs to compile
+ *           on Visual Studio 6 and must not require exception usage.
+ */
+namespace JsonTest {
+
+
+   class Failure
+   {
+   public:
+      const char *file_;
+      unsigned int line_;
+      std::string expr_;
+      std::string message_;
+      unsigned int nestingLevel_;
+   };
+
+
+   /// Context used to create the assertion callstack on failure.
+   /// Must be a POD to allow inline initialisation without stepping 
+   /// into the debugger.
+   struct PredicateContext
+   {
+      typedef unsigned int Id;
+      Id id_;
+      const char *file_;
+      unsigned int line_;
+      const char *expr_;
+      PredicateContext *next_;
+      /// Related Failure, set when the PredicateContext is converted
+      /// into a Failure.
+      Failure *failure_;
+   };
+
+   class TestResult
+   {
+   public:
+      TestResult();
+
+      /// \internal Implementation detail for assertion macros
+      /// Not encapsulated to prevent step into when debugging failed assertions
+      /// Incremented by one on assertion predicate entry, decreased by one
+      /// by addPredicateContext().
+      PredicateContext::Id predicateId_;
+
+      /// \internal Implementation detail for predicate macros
+      PredicateContext *predicateStackTail_;
+
+      void setTestName( const std::string &name );
+
+      /// Adds an assertion failure.
+      TestResult &addFailure( const char *file, unsigned int line,
+                              const char *expr = 0 );
+
+      /// Removes the last PredicateContext added to the predicate stack
+      /// chained list.
+      /// Next messages will be targed at the PredicateContext that was removed.
+      TestResult &popPredicateContext();
+
+      bool failed() const;
+
+      void printFailure( bool printTestName ) const;
+
+      // Generic operator that will work with anything ostream can deal with.
+      template <typename T>
+      TestResult &operator << ( const T& value ) {
+         std::ostringstream oss;
+         oss.precision( 16 );
+         oss.setf( std::ios_base::floatfield );
+         oss << value;
+         return addToLastFailure(oss.str());
+      }
+
+      // Specialized versions.
+      TestResult &operator << ( bool value );
+      // std:ostream does not support 64bits integers on all STL implementation
+      TestResult &operator << ( Json::Int64 value );
+      TestResult &operator << ( Json::UInt64 value );
+
+   private:
+      TestResult &addToLastFailure( const std::string &message );
+      unsigned int getAssertionNestingLevel() const;
+      /// Adds a failure or a predicate context
+      void addFailureInfo( const char *file, unsigned int line,
+                           const char *expr, unsigned int nestingLevel  );
+      static std::string indentText( const std::string &text, 
+                                     const std::string &indent );
+
+      typedef std::deque<Failure> Failures;
+      Failures failures_;
+      std::string name_;
+      PredicateContext rootPredicateNode_;
+      PredicateContext::Id lastUsedPredicateId_;
+      /// Failure which is the target of the messages added using operator <<
+      Failure *messageTarget_;
+   };
+
+
+   class TestCase
+   {
+   public:
+      TestCase();
+
+      virtual ~TestCase();
+
+      void run( TestResult &result );
+
+      virtual const char *testName() const = 0;
+
+   protected:
+      TestResult *result_;
+
+   private:
+      virtual void runTestCase() = 0;
+   };
+
+   /// Function pointer type for TestCase factory
+   typedef TestCase *(*TestCaseFactory)();
+
+   class Runner
+   {
+   public:
+      Runner();
+
+      /// Adds a test to the suite
+      Runner &add( TestCaseFactory factory );
+
+      /// Runs test as specified on the command-line
+      /// If no command-line arguments are provided, run all tests.
+      /// If --list-tests is provided, then print the list of all test cases
+      /// If --test <testname> is provided, then run test testname.
+      int runCommandLine( int argc, const char *argv[] ) const;
+
+      /// Runs all the test cases
+      bool runAllTest( bool printSummary ) const;
+
+      /// Returns the number of test case in the suite
+      unsigned int testCount() const;
+
+      /// Returns the name of the test case at the specified index
+      std::string testNameAt( unsigned int index ) const;
+
+      /// Runs the test case at the specified index using the specified TestResult
+      void runTestAt( unsigned int index, TestResult &result ) const;
+
+      static void printUsage( const char *appName );
+
+   private: // prevents copy construction and assignment
+      Runner( const Runner &other );
+      Runner &operator =( const Runner &other );
+
+   private:
+      void listTests() const;
+      bool testIndex( const std::string &testName, unsigned int &index ) const;
+      static void preventDialogOnCrash();
+
+   private:
+      typedef std::deque<TestCaseFactory> Factories;
+      Factories tests_;
+   };
+
+   template<typename T, typename U>
+   TestResult &
+   checkEqual( TestResult &result, const T &expected, const U &actual, 
+               const char *file, unsigned int line, const char *expr )
+   {
+      if ( expected != actual )
+      {
+         result.addFailure( file, line, expr );
+         result << "Expected: " << expected << "\n";
+         result << "Actual  : " << actual;
+      }
+      return result;
+   }
+
+
+   TestResult &
+   checkStringEqual( TestResult &result, 
+                     const std::string &expected, const std::string &actual,
+                     const char *file, unsigned int line, const char *expr );
+
+} // namespace JsonTest
+
+
+/// \brief Asserts that the given expression is true.
+/// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
+/// JSONTEST_ASSERT( x == y );
+#define JSONTEST_ASSERT( expr )                                               \
+   if ( expr )                                                                \
+   {                                                                          \
+   }                                                                          \
+   else                                                                       \
+      result_->addFailure( __FILE__, __LINE__, #expr )
+
+/// \brief Asserts that the given predicate is true.
+/// The predicate may do other assertions and be a member function of the fixture.
+#define JSONTEST_ASSERT_PRED( expr )                                    \
+   {                                                                    \
+      JsonTest::PredicateContext _minitest_Context = {                  \
+         result_->predicateId_, __FILE__, __LINE__, #expr };            \
+      result_->predicateStackTail_->next_ = &_minitest_Context;         \
+      result_->predicateId_ += 1;                                       \
+      result_->predicateStackTail_ = &_minitest_Context;                \
+      (expr);                                                           \
+      result_->popPredicateContext();                                   \
+   }                                                                    \
+   *result_
+
+/// \brief Asserts that two values are equals.
+#define JSONTEST_ASSERT_EQUAL( expected, actual )          \
+   JsonTest::checkEqual( *result_, expected, actual,       \
+                         __FILE__, __LINE__,               \
+                         #expected " == " #actual )
+
+/// \brief Asserts that two values are equals.
+#define JSONTEST_ASSERT_STRING_EQUAL( expected, actual ) \
+   JsonTest::checkStringEqual( *result_,                 \
+      std::string(expected), std::string(actual),        \
+      __FILE__, __LINE__,                                \
+      #expected " == " #actual )
+
+/// \brief Begin a fixture test case.
+#define JSONTEST_FIXTURE( FixtureType, name )                  \
+   class Test##FixtureType##name : public FixtureType          \
+   {                                                           \
+   public:                                                     \
+      static JsonTest::TestCase *factory()                     \
+      {                                                        \
+         return new Test##FixtureType##name();                 \
+      }                                                        \
+   public: /* overidden from TestCase */                       \
+      virtual const char *testName() const                     \
+      {                                                        \
+         return #FixtureType "/" #name;                        \
+      }                                                        \
+      virtual void runTestCase();                              \
+   };                                                          \
+                                                               \
+   void Test##FixtureType##name::runTestCase()
+
+#define JSONTEST_FIXTURE_FACTORY( FixtureType, name ) \
+   &Test##FixtureType##name::factory
+
+#define JSONTEST_REGISTER_FIXTURE( runner, FixtureType, name ) \
+   (runner).add( JSONTEST_FIXTURE_FACTORY( FixtureType, name ) )
+
+#endif // ifndef JSONTEST_H_INCLUDED
diff --git a/jsoncpp/src/test_lib_json/main.cpp b/jsoncpp/src/test_lib_json/main.cpp
new file mode 100644
index 0000000..c6ab619
--- /dev/null
+++ b/jsoncpp/src/test_lib_json/main.cpp
@@ -0,0 +1,1424 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#include <json/config.h>
+#include <json/json.h>
+#include "jsontest.h"
+
+// Make numeric limits more convenient to talk about.
+// Assumes int type in 32 bits.
+#define kint32max Json::Value::maxInt
+#define kint32min Json::Value::minInt
+#define kuint32max Json::Value::maxUInt
+#define kint64max Json::Value::maxInt64
+#define kint64min Json::Value::minInt64
+#define kuint64max Json::Value::maxUInt64
+
+static const double kdint64max = double(kint64max);
+static const float kfint64max = float(kint64max);
+static const float kfint32max = float(kint32max);
+static const float kfuint32max = float(kuint32max);
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// Json Library test cases
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double uint64ToDouble( Json::UInt64 value )
+{
+    return static_cast<double>( value );
+}
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double uint64ToDouble( Json::UInt64 value )
+{
+    return static_cast<double>( Json::Int64(value/2) ) * 2.0 + Json::Int64(value & 1);
+}
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+
+struct ValueTest : JsonTest::TestCase
+{
+   Json::Value null_;
+   Json::Value emptyArray_;
+   Json::Value emptyObject_;
+   Json::Value integer_;
+   Json::Value unsignedInteger_;
+   Json::Value smallUnsignedInteger_;
+   Json::Value real_;
+   Json::Value float_;
+   Json::Value array1_;
+   Json::Value object1_;
+   Json::Value emptyString_;
+   Json::Value string1_;
+   Json::Value string_;
+   Json::Value true_;
+   Json::Value false_;
+
+
+   ValueTest()
+      : emptyArray_( Json::arrayValue )
+      , emptyObject_( Json::objectValue )
+      , integer_( 123456789 )
+      , smallUnsignedInteger_( Json::Value::UInt( Json::Value::maxInt ) )
+      , unsignedInteger_( 34567890u )
+      , real_( 1234.56789 )
+      , float_( 0.00390625f )
+      , emptyString_( "" )
+      , string1_( "a" )
+      , string_( "sometext with space" )
+      , true_( true )
+      , false_( false )
+   {
+      array1_.append( 1234 );
+      object1_["id"] = 1234;
+   }
+
+   struct IsCheck
+   {
+      /// Initialize all checks to \c false by default.
+      IsCheck();
+
+      bool isObject_;
+      bool isArray_;
+      bool isBool_;
+      bool isString_;
+      bool isNull_;
+
+      bool isInt_;
+      bool isInt64_;
+      bool isUInt_;
+      bool isUInt64_;
+      bool isIntegral_;
+      bool isDouble_;
+      bool isNumeric_;
+   };
+
+   void checkConstMemberCount( const Json::Value &value, unsigned int expectedCount );
+
+   void checkMemberCount( Json::Value &value, unsigned int expectedCount );
+
+   void checkIs( const Json::Value &value, const IsCheck &check );
+
+   void checkIsLess( const Json::Value &x, const Json::Value &y );
+
+   void checkIsEqual( const Json::Value &x, const Json::Value &y );
+
+   /// Normalize the representation of floating-point number by stripped leading 0 in exponent.
+   static std::string normalizeFloatingPointStr( const std::string &s );
+};
+
+
+std::string 
+ValueTest::normalizeFloatingPointStr( const std::string &s )
+{
+    std::string::size_type index = s.find_last_of( "eE" );
+    if ( index != std::string::npos )
+    {
+        std::string::size_type hasSign = (s[index+1] == '+' || s[index+1] == '-') ? 1 : 0;
+        std::string::size_type exponentStartIndex = index + 1 + hasSign;
+        std::string normalized = s.substr( 0, exponentStartIndex );
+        std::string::size_type indexDigit = s.find_first_not_of( '0', exponentStartIndex );
+        std::string exponent = "0";
+        if ( indexDigit != std::string::npos ) // There is an exponent different from 0
+        {
+            exponent = s.substr( indexDigit );
+        }
+        return normalized + exponent;
+    }
+    return s;
+}
+
+
+JSONTEST_FIXTURE( ValueTest, checkNormalizeFloatingPointStr )
+{
+    JSONTEST_ASSERT_STRING_EQUAL( "0.0", normalizeFloatingPointStr("0.0") );
+    JSONTEST_ASSERT_STRING_EQUAL( "0e0", normalizeFloatingPointStr("0e0") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234.0", normalizeFloatingPointStr("1234.0") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234.0e0", normalizeFloatingPointStr("1234.0e0") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234.0e+0", normalizeFloatingPointStr("1234.0e+0") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e-1", normalizeFloatingPointStr("1234e-1") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e10") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e010") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e+10", normalizeFloatingPointStr("1234e+010") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e-10", normalizeFloatingPointStr("1234e-010") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e+100", normalizeFloatingPointStr("1234e+100") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e-100", normalizeFloatingPointStr("1234e-100") );
+    JSONTEST_ASSERT_STRING_EQUAL( "1234e+1", normalizeFloatingPointStr("1234e+001") );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, memberCount )
+{
+   JSONTEST_ASSERT_PRED( checkMemberCount(emptyArray_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(emptyObject_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(array1_, 1) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(object1_, 1) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(null_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(integer_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(unsignedInteger_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(smallUnsignedInteger_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(real_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(emptyString_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(string_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(true_, 0) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, objects )
+{
+   // Types
+   IsCheck checks;
+   checks.isObject_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) );
+
+   JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
+
+   // Empty object okay
+   JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
+
+   // Non-empty object not okay
+   JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
+
+   // Always okay
+   JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
+
+   // Never okay
+   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
+
+   // Access through const reference
+   const Json::Value &constObject = object1_;
+
+   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
+   JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
+
+   // Access through non-const reference
+   JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
+   JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
+
+   object1_["some other id"] = "foo";
+   JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
+}
+
+
+JSONTEST_FIXTURE( ValueTest, arrays )
+{
+   const unsigned int index0 = 0;
+
+   // Types
+   IsCheck checks;
+   checks.isArray_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) );
+
+   JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
+
+   // Empty array okay
+   JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
+
+   // Non-empty array not okay
+   JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
+
+   // Always okay
+   JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
+
+   // Never okay
+   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
+   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
+
+   // Access through const reference
+   const Json::Value &constArray = array1_;
+   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
+   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
+
+   // Access through non-const reference
+   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
+   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
+
+   array1_[2] = Json::Value(17);
+   JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
+   JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
+}
+
+
+JSONTEST_FIXTURE( ValueTest, null )
+{
+   JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
+
+   IsCheck checks;
+   checks.isNull_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( null_, checks ) );
+
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
+   JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
+   JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
+   JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
+}
+
+
+JSONTEST_FIXTURE( ValueTest, strings )
+{
+   JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
+
+   IsCheck checks;
+   checks.isString_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( string_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) );
+
+   // Empty string okay
+   JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
+
+   // Non-empty string not okay
+   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
+
+   // Always okay
+   JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
+
+   // Never okay
+   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
+   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
+
+   JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
+   JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
+}
+
+
+JSONTEST_FIXTURE( ValueTest, bools )
+{
+   JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
+
+   IsCheck checks;
+   checks.isBool_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( false_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( true_, checks ) );
+
+   // False okay
+   JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
+
+   // True not okay
+   JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
+
+   // Always okay
+   JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
+
+   // Never okay
+   JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT_EQUAL(true, true_.asBool());
+   JSONTEST_ASSERT_EQUAL(1, true_.asInt());
+   JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
+   JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
+   JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
+
+   JSONTEST_ASSERT_EQUAL(false, false_.asBool());
+   JSONTEST_ASSERT_EQUAL(0, false_.asInt());
+   JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
+   JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
+}
+
+
+JSONTEST_FIXTURE( ValueTest, integers )
+{
+   IsCheck checks;
+   Json::Value val;
+
+   // Conversions that don't depend on the value.
+   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
+
+   // Default int
+   val = Json::Value(Json::intValue);
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(0, val.asInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(false, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+   // Default uint
+   val = Json::Value(Json::uintValue);
+
+   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(0, val.asInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(false, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+   // Default real
+   val = Json::Value(Json::realValue);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT_EQUAL(0, val.asInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(false, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
+
+   // Zero (signed constructor arg)
+   val = Json::Value(0);
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(0, val.asInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(false, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+   // Zero (unsigned constructor arg)
+   val = Json::Value(0u);
+
+   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(0, val.asInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(false, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+   // Zero (floating-point constructor arg)
+   val = Json::Value(0.0);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(0, val.asInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(false, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
+
+   // 2^20 (signed constructor arg)
+   val = Json::Value(1 << 20);
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+
+   // 2^20 (unsigned constructor arg)
+   val = Json::Value(Json::UInt(1 << 20));
+
+   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+
+   // 2^20 (floating-point constructor arg)
+   val = Json::Value((1 << 20) / 1.0);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1048576.0", normalizeFloatingPointStr(val.asString()));
+
+   // -2^20
+   val = Json::Value(-(1 << 20));
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
+   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
+
+   // int32 max
+   val = Json::Value(kint32max);
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
+   JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
+
+   // int32 min
+   val = Json::Value(kint32min);
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt_ = true;
+   checks.isInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
+   JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
+
+   // uint32 max
+   val = Json::Value(kuint32max);
+
+   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isUInt_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+#ifndef JSON_NO_INT64
+   JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
+#endif
+   JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
+
+#ifdef JSON_NO_INT64
+   // int64 max
+   val = Json::Value(double(kint64max));
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
+
+   // int64 min
+   val = Json::Value(double(kint64min));
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
+
+   // uint64 max
+   val = Json::Value(double(kuint64max));
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
+#else  // ifdef JSON_NO_INT64
+   // 2^40 (signed constructor arg)
+   val = Json::Value(Json::Int64(1) << 40);
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+
+   // 2^40 (unsigned constructor arg)
+   val = Json::Value(Json::UInt64(1) << 40);
+
+   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+
+   // 2^40 (floating-point constructor arg)
+   val = Json::Value((Json::Int64(1) << 40) / 1.0);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1099511627776.0", normalizeFloatingPointStr(val.asString()));
+
+   // -2^40
+   val = Json::Value(-(Json::Int64(1) << 40));
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
+   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
+
+   // int64 max
+   val = Json::Value(Json::Int64(kint64max));
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
+   JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
+   JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
+
+   // int64 max (floating point constructor). Note that kint64max is not exactly
+   // representable as a double, and will be rounded up to be higher.
+   val = Json::Value(double(kint64max));
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
+   JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
+
+   // int64 min
+   val = Json::Value(Json::Int64(kint64min));
+
+   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+   JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
+
+   // int64 min (floating point constructor). Note that kint64min *is* exactly
+   // representable as a double.
+   val = Json::Value(double(kint64min));
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+   JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
+
+   // uint64 max
+   val = Json::Value(Json::UInt64(kuint64max));
+
+   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+   checks = IsCheck();
+   checks.isUInt64_ = true;
+   checks.isIntegral_ = true;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
+   JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
+
+   // uint64 max (floating point constructor). Note that kuint64max is not
+   // exactly representable as a double, and will be rounded up to be higher.
+   val = Json::Value(uint64ToDouble(kuint64max));
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+   JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19", normalizeFloatingPointStr(val.asString()));
+#endif
+}
+
+
+JSONTEST_FIXTURE( ValueTest, nonIntegers )
+{
+   IsCheck checks;
+   Json::Value val;
+
+   // Small positive number
+   val = Json::Value(1.5);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(1, val.asInt());
+   JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(1, val.asUInt());
+   JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_EQUAL("1.50", val.asString());
+
+   // Small negative number
+   val = Json::Value(-1.5);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
+   JSONTEST_ASSERT_EQUAL(-1, val.asInt());
+   JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_EQUAL("-1.50", val.asString());
+
+   // A bit over int32 max
+   val = Json::Value(kint32max + 0.5);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
+   JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
+#ifdef JSON_HAS_INT64
+   JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
+#endif
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_EQUAL("2147483647.50", normalizeFloatingPointStr(val.asString()));
+
+   // A bit under int32 min
+   val = Json::Value(kint32min - 0.5);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
+#ifdef JSON_HAS_INT64
+   JSONTEST_ASSERT_EQUAL(-Json::Int64(1)<< 31, val.asLargestInt());
+#endif
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_EQUAL("-2147483648.50", normalizeFloatingPointStr(val.asString()));
+
+   // A bit over uint32 max
+   val = Json::Value(kuint32max + 0.5);
+
+   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+   checks = IsCheck();
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+   JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
+   JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
+#ifdef JSON_HAS_INT64
+   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32)-1, val.asLargestInt());
+   JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32)-Json::UInt64(1), val.asLargestUInt());
+#endif
+   JSONTEST_ASSERT_EQUAL(true, val.asBool());
+   JSONTEST_ASSERT_EQUAL("4294967295.50", normalizeFloatingPointStr(val.asString()));
+
+   val = Json::Value(1.2345678901234);
+   JSONTEST_ASSERT_STRING_EQUAL( "1.23456789012340", normalizeFloatingPointStr(val.asString()));
+}
+
+
+void
+ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount )
+{
+   unsigned int count = 0;
+   Json::Value::const_iterator itEnd = value.end();
+   for ( Json::Value::const_iterator it = value.begin(); it != itEnd; ++it )
+   {
+      ++count;
+   }
+   JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::const_iterator";
+}
+
+void
+ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount )
+{
+   JSONTEST_ASSERT_EQUAL(expectedCount, value.size() );
+
+   unsigned int count = 0;
+   Json::Value::iterator itEnd = value.end();
+   for ( Json::Value::iterator it = value.begin(); it != itEnd; ++it )
+   {
+      ++count;
+   }
+   JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::iterator";
+
+   JSONTEST_ASSERT_PRED( checkConstMemberCount(value, expectedCount) );
+}
+
+
+ValueTest::IsCheck::IsCheck()
+   : isObject_( false )
+   , isArray_( false )
+   , isBool_( false )
+   , isString_( false )
+   , isNull_( false )
+   , isInt_( false )
+   , isInt64_( false )
+   , isUInt_( false )
+   , isUInt64_( false )
+   , isIntegral_( false )
+   , isDouble_( false )
+   , isNumeric_( false )
+{
+}
+
+
+void 
+ValueTest::checkIs( const Json::Value &value, const IsCheck &check )
+{
+   JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject() );
+   JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray() );
+   JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool() );
+   JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble() );
+   JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt() );
+   JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt() );
+   JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral() );
+   JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric() );
+   JSONTEST_ASSERT_EQUAL(check.isString_, value.isString() );
+   JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull() );
+
+#ifdef JSON_HAS_INT64
+   JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64() );
+   JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64() );
+#else
+   JSONTEST_ASSERT_EQUAL(false, value.isInt64() );
+   JSONTEST_ASSERT_EQUAL(false, value.isUInt64() );
+#endif
+}
+
+JSONTEST_FIXTURE( ValueTest, compareNull )
+{
+    JSONTEST_ASSERT_PRED( checkIsEqual( Json::Value(), Json::Value() ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareInt )
+{
+    JSONTEST_ASSERT_PRED( checkIsLess( 0, 10 ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( 10, 10 ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( -10, -10 ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( -10, 0 ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareUInt )
+{
+    JSONTEST_ASSERT_PRED( checkIsLess( 0u, 10u ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( 0u, Json::Value::maxUInt ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( 10u, 10u ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareDouble )
+{
+    JSONTEST_ASSERT_PRED( checkIsLess( 0.0, 10.0 ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( 10.0, 10.0 ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( -10.0, -10.0 ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( -10.0, 0.0 ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareString )
+{
+    JSONTEST_ASSERT_PRED( checkIsLess( "", " " ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( "", "a" ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( "abcd", "zyui" ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( "abc", "abcd" ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( "abcd", "abcd" ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( " ", " " ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( "ABCD", "abcd" ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( "ABCD", "ABCD" ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareBoolean )
+{
+    JSONTEST_ASSERT_PRED( checkIsLess( false, true ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( false, false ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( true, true ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareArray )
+{
+    // array compare size then content
+    Json::Value emptyArray(Json::arrayValue);
+    Json::Value l1aArray;
+    l1aArray.append( 0 );
+    Json::Value l1bArray;
+    l1bArray.append( 10 );
+    Json::Value l2aArray;
+    l2aArray.append( 0 );
+    l2aArray.append( 0 );
+    Json::Value l2bArray;
+    l2bArray.append( 0 );
+    l2bArray.append( 10 );
+    JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l1aArray ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l2aArray ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( l1aArray, l2aArray ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( l2aArray, l2bArray ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( emptyArray, Json::Value( emptyArray ) ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( l1aArray, Json::Value( l1aArray) ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( l2bArray, Json::Value( l2bArray) ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareObject )
+{
+    // object compare size then content
+    Json::Value emptyObject(Json::objectValue);
+    Json::Value l1aObject;
+    l1aObject["key1"] = 0;
+    Json::Value l1bObject;
+    l1aObject["key1"] = 10;
+    Json::Value l2aObject;
+    l2aObject["key1"] = 0;
+    l2aObject["key2"] = 0;
+    JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l1aObject ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l2aObject ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( l1aObject, l2aObject ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( emptyObject, Json::Value( emptyObject ) ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( l1aObject, Json::Value( l1aObject ) ) );
+    JSONTEST_ASSERT_PRED( checkIsEqual( l2aObject, Json::Value( l2aObject ) ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, compareType )
+{
+    // object of different type are ordered according to their type
+    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(), Json::Value(1) ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1), Json::Value(1u) ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1u), Json::Value(1.0) ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1.0), Json::Value("a") ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value("a"), Json::Value(true) ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(true), Json::Value(Json::arrayValue) ) );
+    JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(Json::arrayValue), Json::Value(Json::objectValue) ) );
+}
+
+
+void 
+ValueTest::checkIsLess( const Json::Value &x, const Json::Value &y )
+{
+    JSONTEST_ASSERT( x < y );
+    JSONTEST_ASSERT( y > x );
+    JSONTEST_ASSERT( x <= y );
+    JSONTEST_ASSERT( y >= x );
+    JSONTEST_ASSERT( !(x == y) );
+    JSONTEST_ASSERT( !(y == x) );
+    JSONTEST_ASSERT( !(x >= y) );
+    JSONTEST_ASSERT( !(y <= x) );
+    JSONTEST_ASSERT( !(x > y) );
+    JSONTEST_ASSERT( !(y < x) );
+    JSONTEST_ASSERT( x.compare( y ) < 0 );
+    JSONTEST_ASSERT( y.compare( x ) >= 0 );
+}
+
+
+void 
+ValueTest::checkIsEqual( const Json::Value &x, const Json::Value &y )
+{
+    JSONTEST_ASSERT( x == y );
+    JSONTEST_ASSERT( y == x );
+    JSONTEST_ASSERT( x <= y );
+    JSONTEST_ASSERT( y <= x );
+    JSONTEST_ASSERT( x >= y );
+    JSONTEST_ASSERT( y >= x );
+    JSONTEST_ASSERT( !(x < y) );
+    JSONTEST_ASSERT( !(y < x) );
+    JSONTEST_ASSERT( !(x > y) );
+    JSONTEST_ASSERT( !(y > x) );
+    JSONTEST_ASSERT( x.compare( y ) == 0 );
+    JSONTEST_ASSERT( y.compare( x ) == 0 );
+}
+
+int main( int argc, const char *argv[] )
+{
+   JsonTest::Runner runner;
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, checkNormalizeFloatingPointStr );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, memberCount );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, objects );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, arrays );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, null );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, strings );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, bools );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, integers );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, nonIntegers );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareNull );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareInt );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareUInt );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareDouble );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareString );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareBoolean );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareArray );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareObject );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareType );
+   return runner.runCommandLine( argc, argv );
+}
diff --git a/jsoncpp/src/test_lib_json/sconscript b/jsoncpp/src/test_lib_json/sconscript
new file mode 100644
index 0000000..915fd01
--- /dev/null
+++ b/jsoncpp/src/test_lib_json/sconscript
@@ -0,0 +1,10 @@
+Import( 'env_testing buildUnitTests' )
+
+buildUnitTests( env_testing, Split( """
+    main.cpp
+    jsontest.cpp
+     """ ),
+    'test_lib_json' )
+
+# For 'check' to work, 'libs' must be built first.
+env_testing.Depends('test_lib_json', '#libs')
diff --git a/jsoncpp/test/data/fail_test_array_01.json b/jsoncpp/test/data/fail_test_array_01.json
new file mode 100644
index 0000000..f72a6d0
--- /dev/null
+++ b/jsoncpp/test/data/fail_test_array_01.json
@@ -0,0 +1 @@
+[ 1 2 3]
diff --git a/jsoncpp/test/data/test_array_01.expected b/jsoncpp/test/data/test_array_01.expected
new file mode 100644
index 0000000..a341ff7
--- /dev/null
+++ b/jsoncpp/test/data/test_array_01.expected
@@ -0,0 +1 @@
+.=[]
diff --git a/jsoncpp/test/data/test_array_01.json b/jsoncpp/test/data/test_array_01.json
new file mode 100644
index 0000000..fe51488
--- /dev/null
+++ b/jsoncpp/test/data/test_array_01.json
@@ -0,0 +1 @@
+[]
diff --git a/jsoncpp/test/data/test_array_02.expected b/jsoncpp/test/data/test_array_02.expected
new file mode 100644
index 0000000..ef1f262
--- /dev/null
+++ b/jsoncpp/test/data/test_array_02.expected
@@ -0,0 +1,2 @@
+.=[]
+.[0]=1
diff --git a/jsoncpp/test/data/test_array_02.json b/jsoncpp/test/data/test_array_02.json
new file mode 100644
index 0000000..7660873
--- /dev/null
+++ b/jsoncpp/test/data/test_array_02.json
@@ -0,0 +1 @@
+[1]
diff --git a/jsoncpp/test/data/test_array_03.expected b/jsoncpp/test/data/test_array_03.expected
new file mode 100644
index 0000000..3d8dc18
--- /dev/null
+++ b/jsoncpp/test/data/test_array_03.expected
@@ -0,0 +1,6 @@
+.=[]
+.[0]=1
+.[1]=2
+.[2]=3
+.[3]=4
+.[4]=5
diff --git a/jsoncpp/test/data/test_array_03.json b/jsoncpp/test/data/test_array_03.json
new file mode 100644
index 0000000..9b3f924
--- /dev/null
+++ b/jsoncpp/test/data/test_array_03.json
@@ -0,0 +1 @@
+[ 1, 2 ,  3,4,5]
diff --git a/jsoncpp/test/data/test_array_04.expected b/jsoncpp/test/data/test_array_04.expected
new file mode 100644
index 0000000..ad4add9
--- /dev/null
+++ b/jsoncpp/test/data/test_array_04.expected
@@ -0,0 +1,5 @@
+.=[]
+.[0]=1
+.[1]="abc"
+.[2]=12.3
+.[3]=-4
diff --git a/jsoncpp/test/data/test_array_04.json b/jsoncpp/test/data/test_array_04.json
new file mode 100644
index 0000000..ecca546
--- /dev/null
+++ b/jsoncpp/test/data/test_array_04.json
@@ -0,0 +1 @@
+[1, "abc" , 12.3, -4]
diff --git a/jsoncpp/test/data/test_array_05.expected b/jsoncpp/test/data/test_array_05.expected
new file mode 100644
index 0000000..76cff87
--- /dev/null
+++ b/jsoncpp/test/data/test_array_05.expected
@@ -0,0 +1,100 @@
+.=[]
+.[0]=1
+.[1]=2
+.[2]=3
+.[3]=4
+.[4]=5
+.[5]=6
+.[6]=7
+.[7]=8
+.[8]=9
+.[9]=10
+.[10]=11
+.[11]=12
+.[12]=13
+.[13]=14
+.[14]=15
+.[15]=16
+.[16]=17
+.[17]=18
+.[18]=19
+.[19]=20
+.[20]=21
+.[21]=22
+.[22]=23
+.[23]=24
+.[24]=25
+.[25]=26
+.[26]=27
+.[27]=28
+.[28]=29
+.[29]=30
+.[30]=31
+.[31]=32
+.[32]=33
+.[33]=34
+.[34]=35
+.[35]=36
+.[36]=37
+.[37]=38
+.[38]=39
+.[39]=40
+.[40]=41
+.[41]=42
+.[42]=43
+.[43]=44
+.[44]=45
+.[45]=46
+.[46]=47
+.[47]=48
+.[48]=49
+.[49]=50
+.[50]=51
+.[51]=52
+.[52]=53
+.[53]=54
+.[54]=55
+.[55]=56
+.[56]=57
+.[57]=58
+.[58]=59
+.[59]=60
+.[60]=61
+.[61]=62
+.[62]=63
+.[63]=64
+.[64]=65
+.[65]=66
+.[66]=67
+.[67]=68
+.[68]=69
+.[69]=70
+.[70]=71
+.[71]=72
+.[72]=73
+.[73]=74
+.[74]=75
+.[75]=76
+.[76]=77
+.[77]=78
+.[78]=79
+.[79]=80
+.[80]=81
+.[81]=82
+.[82]=83
+.[83]=84
+.[84]=85
+.[85]=86
+.[86]=87
+.[87]=88
+.[88]=89
+.[89]=90
+.[90]=91
+.[91]=92
+.[92]=93
+.[93]=94
+.[94]=95
+.[95]=96
+.[96]=97
+.[97]=98
+.[98]=99
diff --git a/jsoncpp/test/data/test_array_06.expected b/jsoncpp/test/data/test_array_06.expected
new file mode 100644
index 0000000..5c9f48e
--- /dev/null
+++ b/jsoncpp/test/data/test_array_06.expected
@@ -0,0 +1,5 @@
+.=[]
+.[0]="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+.[1]="bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+.[2]="ccccccccccccccccccccccc"
+.[3]="dddddddddddddddddddddddddddddddddddddddddddddddddddd"
diff --git a/jsoncpp/test/data/test_array_06.json b/jsoncpp/test/data/test_array_06.json
new file mode 100644
index 0000000..7f6c516
--- /dev/null
+++ b/jsoncpp/test/data/test_array_06.json
@@ -0,0 +1,4 @@
+[ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 
+  "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "ccccccccccccccccccccccc",
+  "dddddddddddddddddddddddddddddddddddddddddddddddddddd" ]
\ No newline at end of file
diff --git a/jsoncpp/test/data/test_array_07.expected b/jsoncpp/test/data/test_array_07.expected
new file mode 100644
index 0000000..ee2fafc
--- /dev/null
+++ b/jsoncpp/test/data/test_array_07.expected
@@ -0,0 +1,2122 @@
+.=[]
+.[0]=[]
+.[0][0]="A"
+.[0][1]=0
+.[0][2]=1
+.[0][3]=2
+.[0][4]=3
+.[0][5]=4
+.[0][6]=5
+.[0][7]=6
+.[0][8]=7
+.[0][9]=8
+.[0][10]=9
+.[0][11]=10
+.[0][12]=11
+.[0][13]=12
+.[0][14]=13
+.[0][15]=14
+.[0][16]=15
+.[0][17]=16
+.[0][18]=17
+.[0][19]=18
+.[0][20]=19
+.[0][21]=20
+.[0][22]=21
+.[0][23]=22
+.[0][24]=23
+.[0][25]=24
+.[0][26]=25
+.[0][27]=26
+.[0][28]=27
+.[0][29]=28
+.[0][30]=29
+.[0][31]=30
+.[0][32]=31
+.[0][33]=32
+.[0][34]=33
+.[0][35]=34
+.[0][36]=35
+.[0][37]=36
+.[0][38]=37
+.[0][39]=38
+.[0][40]=39
+.[0][41]=40
+.[0][42]=41
+.[0][43]=42
+.[0][44]=43
+.[0][45]=44
+.[0][46]=45
+.[0][47]=46
+.[0][48]=47
+.[0][49]=48
+.[0][50]=49
+.[0][51]=50
+.[0][52]=51
+.[0][53]=52
+.[0][54]=53
+.[0][55]=54
+.[0][56]=55
+.[0][57]=56
+.[0][58]=57
+.[0][59]=58
+.[0][60]=59
+.[0][61]=60
+.[0][62]=61
+.[0][63]=62
+.[0][64]=63
+.[0][65]=64
+.[0][66]=65
+.[0][67]=66
+.[0][68]=67
+.[0][69]=68
+.[0][70]=69
+.[0][71]=70
+.[0][72]=71
+.[0][73]=72
+.[0][74]=73
+.[0][75]=74
+.[0][76]=75
+.[0][77]=76
+.[0][78]=77
+.[0][79]=78
+.[0][80]=79
+.[0][81]=80
+.[0][82]=81
+.[0][83]=82
+.[0][84]=83
+.[0][85]=84
+.[0][86]=85
+.[0][87]=86
+.[0][88]=87
+.[0][89]=88
+.[0][90]=89
+.[0][91]=90
+.[0][92]=91
+.[0][93]=92
+.[0][94]=93
+.[0][95]=94
+.[0][96]=95
+.[0][97]=96
+.[0][98]=97
+.[0][99]=98
+.[0][100]=99
+.[0][101]=100
+.[0][102]=101
+.[0][103]=102
+.[0][104]=103
+.[0][105]=104
+.[0][106]=105
+.[0][107]=106
+.[0][108]=107
+.[0][109]=108
+.[0][110]=109
+.[0][111]=110
+.[0][112]=111
+.[0][113]=112
+.[0][114]=113
+.[0][115]=114
+.[0][116]=115
+.[0][117]=116
+.[0][118]=117
+.[0][119]=118
+.[0][120]=119
+.[0][121]=120
+.[0][122]=121
+.[0][123]=122
+.[0][124]=123
+.[0][125]=124
+.[0][126]=125
+.[0][127]=126
+.[0][128]=127
+.[0][129]=128
+.[0][130]=129
+.[0][131]=130
+.[0][132]=131
+.[0][133]=132
+.[0][134]=133
+.[0][135]=134
+.[0][136]=135
+.[0][137]=136
+.[0][138]=137
+.[0][139]=138
+.[0][140]=139
+.[0][141]=140
+.[0][142]=141
+.[0][143]=142
+.[0][144]=143
+.[0][145]=144
+.[0][146]=145
+.[0][147]=146
+.[0][148]=147
+.[0][149]=148
+.[0][150]=149
+.[0][151]=150
+.[0][152]=151
+.[0][153]=152
+.[0][154]=153
+.[0][155]=154
+.[0][156]=155
+.[0][157]=156
+.[0][158]=157
+.[0][159]=158
+.[0][160]=159
+.[0][161]=160
+.[0][162]=161
+.[0][163]=162
+.[0][164]=163
+.[0][165]=164
+.[0][166]=165
+.[0][167]=166
+.[0][168]=167
+.[0][169]=168
+.[0][170]=169
+.[0][171]=170
+.[0][172]=171
+.[0][173]=172
+.[0][174]=173
+.[0][175]=174
+.[0][176]=175
+.[0][177]=176
+.[0][178]=177
+.[0][179]=178
+.[0][180]=179
+.[0][181]=180
+.[0][182]=181
+.[0][183]=182
+.[0][184]=183
+.[0][185]=184
+.[0][186]=185
+.[0][187]=186
+.[0][188]=187
+.[0][189]=188
+.[0][190]=189
+.[0][191]=190
+.[0][192]=191
+.[0][193]=192
+.[0][194]=193
+.[0][195]=194
+.[0][196]=195
+.[0][197]=196
+.[0][198]=197
+.[0][199]=198
+.[0][200]=199
+.[0][201]=200
+.[0][202]=201
+.[0][203]=202
+.[0][204]=203
+.[0][205]=204
+.[0][206]=205
+.[0][207]=206
+.[0][208]=207
+.[0][209]=208
+.[0][210]=209
+.[0][211]=210
+.[0][212]=211
+.[0][213]=212
+.[0][214]=213
+.[0][215]=214
+.[0][216]=215
+.[0][217]=216
+.[0][218]=217
+.[0][219]=218
+.[0][220]=219
+.[0][221]=220
+.[0][222]=221
+.[0][223]=222
+.[0][224]=223
+.[0][225]=224
+.[0][226]=225
+.[0][227]=226
+.[0][228]=227
+.[0][229]=228
+.[0][230]=229
+.[0][231]=230
+.[0][232]=231
+.[0][233]=232
+.[0][234]=233
+.[0][235]=234
+.[0][236]=235
+.[0][237]=236
+.[0][238]=237
+.[0][239]=238
+.[0][240]=239
+.[0][241]=240
+.[0][242]=241
+.[0][243]=242
+.[0][244]=243
+.[0][245]=244
+.[0][246]=245
+.[0][247]=246
+.[0][248]=247
+.[0][249]=248
+.[0][250]=249
+.[0][251]=250
+.[0][252]=251
+.[0][253]=252
+.[0][254]=253
+.[0][255]=254
+.[0][256]=255
+.[0][257]=256
+.[0][258]=257
+.[0][259]=258
+.[0][260]=259
+.[0][261]=260
+.[0][262]=261
+.[0][263]=262
+.[0][264]=263
+.[0][265]=264
+.[0][266]=265
+.[0][267]=266
+.[0][268]=267
+.[0][269]=268
+.[0][270]=269
+.[0][271]=270
+.[0][272]=271
+.[0][273]=272
+.[0][274]=273
+.[0][275]=274
+.[0][276]=275
+.[0][277]=276
+.[0][278]=277
+.[0][279]=278
+.[0][280]=279
+.[0][281]=280
+.[0][282]=281
+.[0][283]=282
+.[0][284]=283
+.[0][285]=284
+.[0][286]=285
+.[0][287]=286
+.[0][288]=287
+.[0][289]=288
+.[0][290]=289
+.[0][291]=290
+.[0][292]=291
+.[0][293]=292
+.[0][294]=293
+.[0][295]=294
+.[0][296]=295
+.[0][297]=296
+.[0][298]=297
+.[0][299]=298
+.[0][300]=299
+.[0][301]=300
+.[0][302]=301
+.[0][303]=302
+.[0][304]=303
+.[0][305]=304
+.[0][306]=305
+.[0][307]=306
+.[0][308]=307
+.[0][309]=308
+.[0][310]=309
+.[0][311]=310
+.[0][312]=311
+.[0][313]=312
+.[0][314]=313
+.[0][315]=314
+.[0][316]=315
+.[0][317]=316
+.[0][318]=317
+.[0][319]=318
+.[0][320]=319
+.[0][321]=320
+.[0][322]=321
+.[0][323]=322
+.[0][324]=323
+.[0][325]=324
+.[0][326]=325
+.[0][327]=326
+.[0][328]=327
+.[0][329]=328
+.[0][330]=329
+.[0][331]=330
+.[0][332]=331
+.[0][333]=332
+.[0][334]=333
+.[0][335]=334
+.[0][336]=335
+.[0][337]=336
+.[0][338]=337
+.[0][339]=338
+.[0][340]=339
+.[0][341]=340
+.[0][342]=341
+.[0][343]=342
+.[0][344]=343
+.[0][345]=344
+.[0][346]=345
+.[0][347]=346
+.[0][348]=347
+.[0][349]=348
+.[0][350]=349
+.[0][351]=350
+.[0][352]=351
+.[0][353]=352
+.[0][354]=353
+.[0][355]=354
+.[0][356]=355
+.[0][357]=356
+.[0][358]=357
+.[0][359]=358
+.[0][360]=359
+.[0][361]=360
+.[0][362]=361
+.[0][363]=362
+.[0][364]=363
+.[0][365]=364
+.[0][366]=365
+.[0][367]=366
+.[0][368]=367
+.[0][369]=368
+.[0][370]=369
+.[0][371]=370
+.[0][372]=371
+.[0][373]=372
+.[0][374]=373
+.[0][375]=374
+.[0][376]=375
+.[0][377]=376
+.[0][378]=377
+.[0][379]=378
+.[0][380]=379
+.[0][381]=380
+.[0][382]=381
+.[0][383]=382
+.[0][384]=383
+.[0][385]=384
+.[0][386]=385
+.[0][387]=386
+.[0][388]=387
+.[0][389]=388
+.[0][390]=389
+.[0][391]=390
+.[0][392]=391
+.[0][393]=392
+.[0][394]=393
+.[0][395]=394
+.[0][396]=395
+.[0][397]=396
+.[0][398]=397
+.[0][399]=398
+.[0][400]=399
+.[0][401]=400
+.[0][402]=401
+.[0][403]=402
+.[0][404]=403
+.[0][405]=404
+.[0][406]=405
+.[0][407]=406
+.[0][408]=407
+.[0][409]=408
+.[0][410]=409
+.[0][411]=410
+.[0][412]=411
+.[0][413]=412
+.[0][414]=413
+.[0][415]=414
+.[0][416]=415
+.[0][417]=416
+.[0][418]=417
+.[0][419]=418
+.[0][420]=419
+.[0][421]=420
+.[0][422]=421
+.[0][423]=422
+.[0][424]=423
+.[0][425]=424
+.[0][426]=425
+.[0][427]=426
+.[0][428]=427
+.[0][429]=428
+.[0][430]=429
+.[0][431]=430
+.[0][432]=431
+.[0][433]=432
+.[0][434]=433
+.[0][435]=434
+.[0][436]=435
+.[0][437]=436
+.[0][438]=437
+.[0][439]=438
+.[0][440]=439
+.[0][441]=440
+.[0][442]=441
+.[0][443]=442
+.[0][444]=443
+.[0][445]=444
+.[0][446]=445
+.[0][447]=446
+.[0][448]=447
+.[0][449]=448
+.[0][450]=449
+.[0][451]=450
+.[0][452]=451
+.[0][453]=452
+.[0][454]=453
+.[0][455]=454
+.[0][456]=455
+.[0][457]=456
+.[0][458]=457
+.[0][459]=458
+.[0][460]=459
+.[0][461]=460
+.[0][462]=461
+.[0][463]=462
+.[0][464]=463
+.[0][465]=464
+.[0][466]=465
+.[0][467]=466
+.[0][468]=467
+.[0][469]=468
+.[0][470]=469
+.[0][471]=470
+.[0][472]=471
+.[0][473]=472
+.[0][474]=473
+.[0][475]=474
+.[0][476]=475
+.[0][477]=476
+.[0][478]=477
+.[0][479]=478
+.[0][480]=479
+.[0][481]=480
+.[0][482]=481
+.[0][483]=482
+.[0][484]=483
+.[0][485]=484
+.[0][486]=485
+.[0][487]=486
+.[0][488]=487
+.[0][489]=488
+.[0][490]=489
+.[0][491]=490
+.[0][492]=491
+.[0][493]=492
+.[0][494]=493
+.[0][495]=494
+.[0][496]=495
+.[0][497]=496
+.[0][498]=497
+.[0][499]=498
+.[0][500]=499
+.[0][501]=500
+.[0][502]=501
+.[0][503]=502
+.[0][504]=503
+.[0][505]=504
+.[0][506]=505
+.[0][507]=506
+.[0][508]=507
+.[0][509]=508
+.[0][510]=509
+.[0][511]=510
+.[0][512]=511
+.[0][513]=512
+.[0][514]=513
+.[0][515]=514
+.[0][516]=515
+.[0][517]=516
+.[0][518]=517
+.[0][519]=518
+.[0][520]=519
+.[0][521]=520
+.[0][522]=521
+.[0][523]=522
+.[0][524]=523
+.[0][525]=524
+.[0][526]=525
+.[0][527]=526
+.[0][528]=527
+.[0][529]=528
+.[0][530]=529
+.[0][531]=530
+.[0][532]=531
+.[0][533]=532
+.[0][534]=533
+.[0][535]=534
+.[0][536]=535
+.[0][537]=536
+.[0][538]=537
+.[0][539]=538
+.[0][540]=539
+.[0][541]=540
+.[0][542]=541
+.[0][543]=542
+.[0][544]=543
+.[0][545]=544
+.[0][546]=545
+.[0][547]=546
+.[0][548]=547
+.[0][549]=548
+.[0][550]=549
+.[0][551]=550
+.[0][552]=551
+.[0][553]=552
+.[0][554]=553
+.[0][555]=554
+.[0][556]=555
+.[0][557]=556
+.[0][558]=557
+.[0][559]=558
+.[0][560]=559
+.[0][561]=560
+.[0][562]=561
+.[0][563]=562
+.[0][564]=563
+.[0][565]=564
+.[0][566]=565
+.[0][567]=566
+.[0][568]=567
+.[0][569]=568
+.[0][570]=569
+.[0][571]=570
+.[0][572]=571
+.[0][573]=572
+.[0][574]=573
+.[0][575]=574
+.[0][576]=575
+.[0][577]=576
+.[0][578]=577
+.[0][579]=578
+.[0][580]=579
+.[0][581]=580
+.[0][582]=581
+.[0][583]=582
+.[0][584]=583
+.[0][585]=584
+.[0][586]=585
+.[0][587]=586
+.[0][588]=587
+.[0][589]=588
+.[0][590]=589
+.[0][591]=590
+.[0][592]=591
+.[0][593]=592
+.[0][594]=593
+.[0][595]=594
+.[0][596]=595
+.[0][597]=596
+.[0][598]=597
+.[0][599]=598
+.[0][600]=599
+.[0][601]=600
+.[0][602]=601
+.[0][603]=602
+.[0][604]=603
+.[0][605]=604
+.[0][606]=605
+.[0][607]=606
+.[0][608]=607
+.[0][609]=608
+.[0][610]=609
+.[0][611]=610
+.[0][612]=611
+.[0][613]=612
+.[0][614]=613
+.[0][615]=614
+.[0][616]=615
+.[0][617]=616
+.[0][618]=617
+.[0][619]=618
+.[0][620]=619
+.[0][621]=620
+.[0][622]=621
+.[0][623]=622
+.[0][624]=623
+.[0][625]=624
+.[0][626]=625
+.[0][627]=626
+.[0][628]=627
+.[0][629]=628
+.[0][630]=629
+.[0][631]=630
+.[0][632]=631
+.[0][633]=632
+.[0][634]=633
+.[0][635]=634
+.[0][636]=635
+.[0][637]=636
+.[0][638]=637
+.[0][639]=638
+.[0][640]=639
+.[0][641]=640
+.[0][642]=641
+.[0][643]=642
+.[0][644]=643
+.[0][645]=644
+.[0][646]=645
+.[0][647]=646
+.[0][648]=647
+.[0][649]=648
+.[0][650]=649
+.[0][651]=650
+.[0][652]=651
+.[0][653]=652
+.[0][654]=653
+.[0][655]=654
+.[0][656]=655
+.[0][657]=656
+.[0][658]=657
+.[0][659]=658
+.[0][660]=659
+.[0][661]=660
+.[0][662]=661
+.[0][663]=662
+.[0][664]=663
+.[0][665]=664
+.[0][666]=665
+.[0][667]=666
+.[0][668]=667
+.[0][669]=668
+.[0][670]=669
+.[0][671]=670
+.[0][672]=671
+.[0][673]=672
+.[0][674]=673
+.[0][675]=674
+.[0][676]=675
+.[0][677]=676
+.[0][678]=677
+.[0][679]=678
+.[0][680]=679
+.[0][681]=680
+.[0][682]=681
+.[0][683]=682
+.[0][684]=683
+.[0][685]=684
+.[0][686]=685
+.[0][687]=686
+.[0][688]=687
+.[0][689]=688
+.[0][690]=689
+.[0][691]=690
+.[0][692]=691
+.[0][693]=692
+.[0][694]=693
+.[0][695]=694
+.[0][696]=695
+.[0][697]=696
+.[0][698]=697
+.[0][699]=698
+.[0][700]=699
+.[0][701]=700
+.[0][702]=701
+.[0][703]=702
+.[0][704]=703
+.[0][705]=704
+.[0][706]=705
+.[0][707]=706
+.[0][708]=707
+.[0][709]=708
+.[0][710]=709
+.[0][711]=710
+.[0][712]=711
+.[0][713]=712
+.[0][714]=713
+.[0][715]=714
+.[0][716]=715
+.[0][717]=716
+.[0][718]=717
+.[0][719]=718
+.[0][720]=719
+.[0][721]=720
+.[0][722]=721
+.[0][723]=722
+.[0][724]=723
+.[0][725]=724
+.[0][726]=725
+.[0][727]=726
+.[0][728]=727
+.[0][729]=728
+.[0][730]=729
+.[0][731]=730
+.[0][732]=731
+.[0][733]=732
+.[0][734]=733
+.[0][735]=734
+.[0][736]=735
+.[0][737]=736
+.[0][738]=737
+.[0][739]=738
+.[0][740]=739
+.[0][741]=740
+.[0][742]=741
+.[0][743]=742
+.[0][744]=743
+.[0][745]=744
+.[0][746]=745
+.[0][747]=746
+.[0][748]=747
+.[0][749]=748
+.[0][750]=749
+.[0][751]=750
+.[0][752]=751
+.[0][753]=752
+.[0][754]=753
+.[0][755]=754
+.[0][756]=755
+.[0][757]=756
+.[0][758]=757
+.[0][759]=758
+.[0][760]=759
+.[0][761]=760
+.[0][762]=761
+.[0][763]=762
+.[0][764]=763
+.[0][765]=764
+.[0][766]=765
+.[0][767]=766
+.[0][768]=767
+.[0][769]=768
+.[0][770]=769
+.[0][771]=770
+.[0][772]=771
+.[0][773]=772
+.[0][774]=773
+.[0][775]=774
+.[0][776]=775
+.[0][777]=776
+.[0][778]=777
+.[0][779]=778
+.[0][780]=779
+.[0][781]=780
+.[0][782]=781
+.[0][783]=782
+.[0][784]=783
+.[0][785]=784
+.[0][786]=785
+.[0][787]=786
+.[0][788]=787
+.[0][789]=788
+.[0][790]=789
+.[0][791]=790
+.[0][792]=791
+.[0][793]=792
+.[0][794]=793
+.[0][795]=794
+.[0][796]=795
+.[0][797]=796
+.[0][798]=797
+.[0][799]=798
+.[0][800]=799
+.[0][801]=800
+.[0][802]=801
+.[0][803]=802
+.[0][804]=803
+.[0][805]=804
+.[0][806]=805
+.[0][807]=806
+.[0][808]=807
+.[0][809]=808
+.[0][810]=809
+.[0][811]=810
+.[0][812]=811
+.[0][813]=812
+.[0][814]=813
+.[0][815]=814
+.[0][816]=815
+.[0][817]=816
+.[0][818]=817
+.[0][819]=818
+.[0][820]=819
+.[0][821]=820
+.[0][822]=821
+.[0][823]=822
+.[0][824]=823
+.[0][825]=824
+.[0][826]=825
+.[0][827]=826
+.[0][828]=827
+.[0][829]=828
+.[0][830]=829
+.[0][831]=830
+.[0][832]=831
+.[0][833]=832
+.[0][834]=833
+.[0][835]=834
+.[0][836]=835
+.[0][837]=836
+.[0][838]=837
+.[0][839]=838
+.[0][840]=839
+.[0][841]=840
+.[0][842]=841
+.[0][843]=842
+.[0][844]=843
+.[0][845]=844
+.[0][846]=845
+.[0][847]=846
+.[0][848]=847
+.[0][849]=848
+.[0][850]=849
+.[0][851]=850
+.[0][852]=851
+.[0][853]=852
+.[0][854]=853
+.[0][855]=854
+.[0][856]=855
+.[0][857]=856
+.[0][858]=857
+.[0][859]=858
+.[0][860]=859
+.[0][861]=860
+.[0][862]=861
+.[0][863]=862
+.[0][864]=863
+.[0][865]=864
+.[0][866]=865
+.[0][867]=866
+.[0][868]=867
+.[0][869]=868
+.[0][870]=869
+.[0][871]=870
+.[0][872]=871
+.[0][873]=872
+.[0][874]=873
+.[0][875]=874
+.[0][876]=875
+.[0][877]=876
+.[0][878]=877
+.[0][879]=878
+.[0][880]=879
+.[0][881]=880
+.[0][882]=881
+.[0][883]=882
+.[0][884]=883
+.[0][885]=884
+.[0][886]=885
+.[0][887]=886
+.[0][888]=887
+.[0][889]=888
+.[0][890]=889
+.[0][891]=890
+.[0][892]=891
+.[0][893]=892
+.[0][894]=893
+.[0][895]=894
+.[0][896]=895
+.[0][897]=896
+.[0][898]=897
+.[0][899]=898
+.[0][900]=899
+.[0][901]=900
+.[0][902]=901
+.[0][903]=902
+.[0][904]=903
+.[0][905]=904
+.[0][906]=905
+.[0][907]=906
+.[0][908]=907
+.[0][909]=908
+.[0][910]=909
+.[0][911]=910
+.[0][912]=911
+.[0][913]=912
+.[0][914]=913
+.[0][915]=914
+.[0][916]=915
+.[0][917]=916
+.[0][918]=917
+.[0][919]=918
+.[0][920]=919
+.[0][921]=920
+.[0][922]=921
+.[0][923]=922
+.[0][924]=923
+.[0][925]=924
+.[0][926]=925
+.[0][927]=926
+.[0][928]=927
+.[0][929]=928
+.[0][930]=929
+.[0][931]=930
+.[0][932]=931
+.[0][933]=932
+.[0][934]=933
+.[0][935]=934
+.[0][936]=935
+.[0][937]=936
+.[0][938]=937
+.[0][939]=938
+.[0][940]=939
+.[0][941]=940
+.[0][942]=941
+.[0][943]=942
+.[0][944]=943
+.[0][945]=944
+.[0][946]=945
+.[0][947]=946
+.[0][948]=947
+.[0][949]=948
+.[0][950]=949
+.[0][951]=950
+.[0][952]=951
+.[0][953]=952
+.[0][954]=953
+.[0][955]=954
+.[0][956]=955
+.[0][957]=956
+.[0][958]=957
+.[0][959]=958
+.[0][960]=959
+.[0][961]=960
+.[0][962]=961
+.[0][963]=962
+.[0][964]=963
+.[0][965]=964
+.[0][966]=965
+.[0][967]=966
+.[0][968]=967
+.[0][969]=968
+.[0][970]=969
+.[0][971]=970
+.[0][972]=971
+.[0][973]=972
+.[0][974]=973
+.[0][975]=974
+.[0][976]=975
+.[0][977]=976
+.[0][978]=977
+.[0][979]=978
+.[0][980]=979
+.[0][981]=980
+.[0][982]=981
+.[0][983]=982
+.[0][984]=983
+.[0][985]=984
+.[0][986]=985
+.[0][987]=986
+.[0][988]=987
+.[0][989]=988
+.[0][990]=989
+.[0][991]=990
+.[0][992]=991
+.[0][993]=992
+.[0][994]=993
+.[0][995]=994
+.[0][996]=995
+.[0][997]=996
+.[0][998]=997
+.[0][999]=998
+.[0][1000]=999
+.[0][1001]=1000
+.[0][1002]=1001
+.[0][1003]=1002
+.[0][1004]=1003
+.[0][1005]=1004
+.[0][1006]=1005
+.[0][1007]=1006
+.[0][1008]=1007
+.[0][1009]=1008
+.[0][1010]=1009
+.[0][1011]=1010
+.[0][1012]=1011
+.[0][1013]=1012
+.[0][1014]=1013
+.[0][1015]=1014
+.[0][1016]=1015
+.[0][1017]=1016
+.[0][1018]=1017
+.[0][1019]=1018
+.[0][1020]=1019
+.[0][1021]=1020
+.[0][1022]=1021
+.[0][1023]=1022
+.[0][1024]=1023
+.[0][1025]=1024
+.[0][1026]=1025
+.[0][1027]=1026
+.[0][1028]=1027
+.[0][1029]=1028
+.[0][1030]=1029
+.[0][1031]=1030
+.[0][1032]=1031
+.[0][1033]=1032
+.[0][1034]=1033
+.[0][1035]=1034
+.[0][1036]=1035
+.[0][1037]=1036
+.[0][1038]=1037
+.[0][1039]=1038
+.[0][1040]=1039
+.[0][1041]=1040
+.[0][1042]=1041
+.[0][1043]=1042
+.[0][1044]=1043
+.[0][1045]=1044
+.[0][1046]=1045
+.[0][1047]=1046
+.[0][1048]=1047
+.[0][1049]=1048
+.[0][1050]=1049
+.[0][1051]=1050
+.[0][1052]=1051
+.[0][1053]=1052
+.[0][1054]=1053
+.[0][1055]=1054
+.[0][1056]=1055
+.[0][1057]=1056
+.[0][1058]=1057
+.[0][1059]=1058
+.[0][1060]=1059
+.[0][1061]=1060
+.[0][1062]=1061
+.[0][1063]=1062
+.[0][1064]=1063
+.[0][1065]=1064
+.[0][1066]=1065
+.[0][1067]=1066
+.[0][1068]=1067
+.[0][1069]=1068
+.[0][1070]=1069
+.[0][1071]=1070
+.[0][1072]=1071
+.[0][1073]=1072
+.[0][1074]=1073
+.[0][1075]=1074
+.[0][1076]=1075
+.[0][1077]=1076
+.[0][1078]=1077
+.[0][1079]=1078
+.[0][1080]=1079
+.[0][1081]=1080
+.[0][1082]=1081
+.[0][1083]=1082
+.[0][1084]=1083
+.[0][1085]=1084
+.[0][1086]=1085
+.[0][1087]=1086
+.[0][1088]=1087
+.[0][1089]=1088
+.[0][1090]=1089
+.[0][1091]=1090
+.[0][1092]=1091
+.[0][1093]=1092
+.[0][1094]=1093
+.[0][1095]=1094
+.[0][1096]=1095
+.[0][1097]=1096
+.[0][1098]=1097
+.[0][1099]=1098
+.[0][1100]=1099
+.[0][1101]=1100
+.[0][1102]=1101
+.[0][1103]=1102
+.[0][1104]=1103
+.[0][1105]=1104
+.[0][1106]=1105
+.[0][1107]=1106
+.[0][1108]=1107
+.[0][1109]=1108
+.[0][1110]=1109
+.[0][1111]=1110
+.[0][1112]=1111
+.[0][1113]=1112
+.[0][1114]=1113
+.[0][1115]=1114
+.[0][1116]=1115
+.[0][1117]=1116
+.[0][1118]=1117
+.[0][1119]=1118
+.[0][1120]=1119
+.[0][1121]=1120
+.[0][1122]=1121
+.[0][1123]=1122
+.[0][1124]=1123
+.[0][1125]=1124
+.[0][1126]=1125
+.[0][1127]=1126
+.[0][1128]=1127
+.[0][1129]=1128
+.[0][1130]=1129
+.[0][1131]=1130
+.[0][1132]=1131
+.[0][1133]=1132
+.[0][1134]=1133
+.[0][1135]=1134
+.[0][1136]=1135
+.[0][1137]=1136
+.[0][1138]=1137
+.[0][1139]=1138
+.[0][1140]=1139
+.[0][1141]=1140
+.[0][1142]=1141
+.[0][1143]=1142
+.[0][1144]=1143
+.[0][1145]=1144
+.[0][1146]=1145
+.[0][1147]=1146
+.[0][1148]=1147
+.[0][1149]=1148
+.[0][1150]=1149
+.[0][1151]=1150
+.[0][1152]=1151
+.[0][1153]=1152
+.[0][1154]=1153
+.[0][1155]=1154
+.[0][1156]=1155
+.[0][1157]=1156
+.[0][1158]=1157
+.[0][1159]=1158
+.[0][1160]=1159
+.[0][1161]=1160
+.[0][1162]=1161
+.[0][1163]=1162
+.[0][1164]=1163
+.[0][1165]=1164
+.[0][1166]=1165
+.[0][1167]=1166
+.[0][1168]=1167
+.[0][1169]=1168
+.[0][1170]=1169
+.[0][1171]=1170
+.[0][1172]=1171
+.[0][1173]=1172
+.[0][1174]=1173
+.[0][1175]=1174
+.[0][1176]=1175
+.[0][1177]=1176
+.[0][1178]=1177
+.[0][1179]=1178
+.[0][1180]=1179
+.[0][1181]=1180
+.[0][1182]=1181
+.[0][1183]=1182
+.[0][1184]=1183
+.[0][1185]=1184
+.[0][1186]=1185
+.[0][1187]=1186
+.[0][1188]=1187
+.[0][1189]=1188
+.[0][1190]=1189
+.[0][1191]=1190
+.[0][1192]=1191
+.[0][1193]=1192
+.[0][1194]=1193
+.[0][1195]=1194
+.[0][1196]=1195
+.[0][1197]=1196
+.[0][1198]=1197
+.[0][1199]=1198
+.[0][1200]=1199
+.[0][1201]=1200
+.[0][1202]=1201
+.[0][1203]=1202
+.[0][1204]=1203
+.[0][1205]=1204
+.[0][1206]=1205
+.[0][1207]=1206
+.[0][1208]=1207
+.[0][1209]=1208
+.[0][1210]=1209
+.[0][1211]=1210
+.[0][1212]=1211
+.[0][1213]=1212
+.[0][1214]=1213
+.[0][1215]=1214
+.[0][1216]=1215
+.[0][1217]=1216
+.[0][1218]=1217
+.[0][1219]=1218
+.[0][1220]=1219
+.[0][1221]=1220
+.[0][1222]=1221
+.[0][1223]=1222
+.[0][1224]=1223
+.[0][1225]=1224
+.[0][1226]=1225
+.[0][1227]=1226
+.[0][1228]=1227
+.[0][1229]=1228
+.[0][1230]=1229
+.[0][1231]=1230
+.[0][1232]=1231
+.[0][1233]=1232
+.[0][1234]=1233
+.[0][1235]=1234
+.[0][1236]=1235
+.[0][1237]=1236
+.[0][1238]=1237
+.[0][1239]=1238
+.[0][1240]=1239
+.[0][1241]=1240
+.[0][1242]=1241
+.[0][1243]=1242
+.[0][1244]=1243
+.[0][1245]=1244
+.[0][1246]=1245
+.[0][1247]=1246
+.[0][1248]=1247
+.[0][1249]=1248
+.[0][1250]=1249
+.[0][1251]=1250
+.[0][1252]=1251
+.[0][1253]=1252
+.[0][1254]=1253
+.[0][1255]=1254
+.[0][1256]=1255
+.[0][1257]=1256
+.[0][1258]=1257
+.[0][1259]=1258
+.[0][1260]=1259
+.[0][1261]=1260
+.[0][1262]=1261
+.[0][1263]=1262
+.[0][1264]=1263
+.[0][1265]=1264
+.[0][1266]=1265
+.[0][1267]=1266
+.[0][1268]=1267
+.[0][1269]=1268
+.[0][1270]=1269
+.[0][1271]=1270
+.[0][1272]=1271
+.[0][1273]=1272
+.[0][1274]=1273
+.[0][1275]=1274
+.[0][1276]=1275
+.[0][1277]=1276
+.[0][1278]=1277
+.[0][1279]=1278
+.[0][1280]=1279
+.[0][1281]=1280
+.[0][1282]=1281
+.[0][1283]=1282
+.[0][1284]=1283
+.[0][1285]=1284
+.[0][1286]=1285
+.[0][1287]=1286
+.[0][1288]=1287
+.[0][1289]=1288
+.[0][1290]=1289
+.[0][1291]=1290
+.[0][1292]=1291
+.[0][1293]=1292
+.[0][1294]=1293
+.[0][1295]=1294
+.[0][1296]=1295
+.[0][1297]=1296
+.[0][1298]=1297
+.[0][1299]=1298
+.[0][1300]=1299
+.[0][1301]=1300
+.[0][1302]=1301
+.[0][1303]=1302
+.[0][1304]=1303
+.[0][1305]=1304
+.[0][1306]=1305
+.[0][1307]=1306
+.[0][1308]=1307
+.[0][1309]=1308
+.[0][1310]=1309
+.[0][1311]=1310
+.[0][1312]=1311
+.[0][1313]=1312
+.[0][1314]=1313
+.[0][1315]=1314
+.[0][1316]=1315
+.[0][1317]=1316
+.[0][1318]=1317
+.[0][1319]=1318
+.[0][1320]=1319
+.[0][1321]=1320
+.[0][1322]=1321
+.[0][1323]=1322
+.[0][1324]=1323
+.[0][1325]=1324
+.[0][1326]=1325
+.[0][1327]=1326
+.[0][1328]=1327
+.[0][1329]=1328
+.[0][1330]=1329
+.[0][1331]=1330
+.[0][1332]=1331
+.[0][1333]=1332
+.[0][1334]=1333
+.[0][1335]=1334
+.[0][1336]=1335
+.[0][1337]=1336
+.[0][1338]=1337
+.[0][1339]=1338
+.[0][1340]=1339
+.[0][1341]=1340
+.[0][1342]=1341
+.[0][1343]=1342
+.[0][1344]=1343
+.[0][1345]=1344
+.[0][1346]=1345
+.[0][1347]=1346
+.[0][1348]=1347
+.[0][1349]=1348
+.[0][1350]=1349
+.[0][1351]=1350
+.[0][1352]=1351
+.[0][1353]=1352
+.[0][1354]=1353
+.[0][1355]=1354
+.[0][1356]=1355
+.[0][1357]=1356
+.[0][1358]=1357
+.[0][1359]=1358
+.[0][1360]=1359
+.[0][1361]=1360
+.[0][1362]=1361
+.[0][1363]=1362
+.[0][1364]=1363
+.[0][1365]=1364
+.[0][1366]=1365
+.[0][1367]=1366
+.[0][1368]=1367
+.[0][1369]=1368
+.[0][1370]=1369
+.[0][1371]=1370
+.[0][1372]=1371
+.[0][1373]=1372
+.[0][1374]=1373
+.[0][1375]=1374
+.[0][1376]=1375
+.[0][1377]=1376
+.[0][1378]=1377
+.[0][1379]=1378
+.[0][1380]=1379
+.[0][1381]=1380
+.[0][1382]=1381
+.[0][1383]=1382
+.[0][1384]=1383
+.[0][1385]=1384
+.[0][1386]=1385
+.[0][1387]=1386
+.[0][1388]=1387
+.[0][1389]=1388
+.[0][1390]=1389
+.[0][1391]=1390
+.[0][1392]=1391
+.[0][1393]=1392
+.[0][1394]=1393
+.[0][1395]=1394
+.[0][1396]=1395
+.[0][1397]=1396
+.[0][1398]=1397
+.[0][1399]=1398
+.[0][1400]=1399
+.[0][1401]=1400
+.[0][1402]=1401
+.[0][1403]=1402
+.[0][1404]=1403
+.[0][1405]=1404
+.[0][1406]=1405
+.[0][1407]=1406
+.[0][1408]=1407
+.[0][1409]=1408
+.[0][1410]=1409
+.[0][1411]=1410
+.[0][1412]=1411
+.[0][1413]=1412
+.[0][1414]=1413
+.[0][1415]=1414
+.[0][1416]=1415
+.[0][1417]=1416
+.[0][1418]=1417
+.[0][1419]=1418
+.[0][1420]=1419
+.[0][1421]=1420
+.[0][1422]=1421
+.[0][1423]=1422
+.[0][1424]=1423
+.[0][1425]=1424
+.[0][1426]=1425
+.[0][1427]=1426
+.[0][1428]=1427
+.[0][1429]=1428
+.[0][1430]=1429
+.[0][1431]=1430
+.[0][1432]=1431
+.[0][1433]=1432
+.[0][1434]=1433
+.[0][1435]=1434
+.[0][1436]=1435
+.[0][1437]=1436
+.[0][1438]=1437
+.[0][1439]=1438
+.[0][1440]=1439
+.[0][1441]=1440
+.[0][1442]=1441
+.[0][1443]=1442
+.[0][1444]=1443
+.[0][1445]=1444
+.[0][1446]=1445
+.[0][1447]=1446
+.[0][1448]=1447
+.[0][1449]=1448
+.[0][1450]=1449
+.[0][1451]=1450
+.[0][1452]=1451
+.[0][1453]=1452
+.[0][1454]=1453
+.[0][1455]=1454
+.[0][1456]=1455
+.[0][1457]=1456
+.[0][1458]=1457
+.[0][1459]=1458
+.[0][1460]=1459
+.[0][1461]=1460
+.[0][1462]=1461
+.[0][1463]=1462
+.[0][1464]=1463
+.[0][1465]=1464
+.[0][1466]=1465
+.[0][1467]=1466
+.[0][1468]=1467
+.[0][1469]=1468
+.[0][1470]=1469
+.[0][1471]=1470
+.[0][1472]=1471
+.[0][1473]=1472
+.[0][1474]=1473
+.[0][1475]=1474
+.[0][1476]=1475
+.[0][1477]=1476
+.[0][1478]=1477
+.[0][1479]=1478
+.[0][1480]=1479
+.[0][1481]=1480
+.[0][1482]=1481
+.[0][1483]=1482
+.[0][1484]=1483
+.[0][1485]=1484
+.[0][1486]=1485
+.[0][1487]=1486
+.[0][1488]=1487
+.[0][1489]=1488
+.[0][1490]=1489
+.[0][1491]=1490
+.[0][1492]=1491
+.[0][1493]=1492
+.[0][1494]=1493
+.[0][1495]=1494
+.[0][1496]=1495
+.[0][1497]=1496
+.[0][1498]=1497
+.[0][1499]=1498
+.[0][1500]=1499
+.[0][1501]=1500
+.[0][1502]=1501
+.[0][1503]=1502
+.[0][1504]=1503
+.[0][1505]=1504
+.[0][1506]=1505
+.[0][1507]=1506
+.[0][1508]=1507
+.[0][1509]=1508
+.[0][1510]=1509
+.[0][1511]=1510
+.[0][1512]=1511
+.[0][1513]=1512
+.[0][1514]=1513
+.[0][1515]=1514
+.[0][1516]=1515
+.[0][1517]=1516
+.[0][1518]=1517
+.[0][1519]=1518
+.[0][1520]=1519
+.[0][1521]=1520
+.[0][1522]=1521
+.[0][1523]=1522
+.[0][1524]=1523
+.[0][1525]=1524
+.[0][1526]=1525
+.[0][1527]=1526
+.[0][1528]=1527
+.[0][1529]=1528
+.[0][1530]=1529
+.[0][1531]=1530
+.[0][1532]=1531
+.[0][1533]=1532
+.[0][1534]=1533
+.[0][1535]=1534
+.[0][1536]=1535
+.[0][1537]=1536
+.[0][1538]=1537
+.[0][1539]=1538
+.[0][1540]=1539
+.[0][1541]=1540
+.[0][1542]=1541
+.[0][1543]=1542
+.[0][1544]=1543
+.[0][1545]=1544
+.[0][1546]=1545
+.[0][1547]=1546
+.[0][1548]=1547
+.[0][1549]=1548
+.[0][1550]=1549
+.[0][1551]=1550
+.[0][1552]=1551
+.[0][1553]=1552
+.[0][1554]=1553
+.[0][1555]=1554
+.[0][1556]=1555
+.[0][1557]=1556
+.[0][1558]=1557
+.[0][1559]=1558
+.[0][1560]=1559
+.[0][1561]=1560
+.[0][1562]=1561
+.[0][1563]=1562
+.[0][1564]=1563
+.[0][1565]=1564
+.[0][1566]=1565
+.[0][1567]=1566
+.[0][1568]=1567
+.[0][1569]=1568
+.[0][1570]=1569
+.[0][1571]=1570
+.[0][1572]=1571
+.[0][1573]=1572
+.[0][1574]=1573
+.[0][1575]=1574
+.[0][1576]=1575
+.[0][1577]=1576
+.[0][1578]=1577
+.[0][1579]=1578
+.[0][1580]=1579
+.[0][1581]=1580
+.[0][1582]=1581
+.[0][1583]=1582
+.[0][1584]=1583
+.[0][1585]=1584
+.[0][1586]=1585
+.[0][1587]=1586
+.[0][1588]=1587
+.[0][1589]=1588
+.[0][1590]=1589
+.[0][1591]=1590
+.[0][1592]=1591
+.[0][1593]=1592
+.[0][1594]=1593
+.[0][1595]=1594
+.[0][1596]=1595
+.[0][1597]=1596
+.[0][1598]=1597
+.[0][1599]=1598
+.[0][1600]=1599
+.[0][1601]=1600
+.[0][1602]=1601
+.[0][1603]=1602
+.[0][1604]=1603
+.[0][1605]=1604
+.[0][1606]=1605
+.[0][1607]=1606
+.[0][1608]=1607
+.[0][1609]=1608
+.[0][1610]=1609
+.[0][1611]=1610
+.[0][1612]=1611
+.[0][1613]=1612
+.[0][1614]=1613
+.[0][1615]=1614
+.[0][1616]=1615
+.[0][1617]=1616
+.[0][1618]=1617
+.[0][1619]=1618
+.[0][1620]=1619
+.[0][1621]=1620
+.[0][1622]=1621
+.[0][1623]=1622
+.[0][1624]=1623
+.[0][1625]=1624
+.[0][1626]=1625
+.[0][1627]=1626
+.[0][1628]=1627
+.[0][1629]=1628
+.[0][1630]=1629
+.[0][1631]=1630
+.[0][1632]=1631
+.[0][1633]=1632
+.[0][1634]=1633
+.[0][1635]=1634
+.[0][1636]=1635
+.[0][1637]=1636
+.[0][1638]=1637
+.[0][1639]=1638
+.[0][1640]=1639
+.[0][1641]=1640
+.[0][1642]=1641
+.[0][1643]=1642
+.[0][1644]=1643
+.[0][1645]=1644
+.[0][1646]=1645
+.[0][1647]=1646
+.[0][1648]=1647
+.[0][1649]=1648
+.[0][1650]=1649
+.[0][1651]=1650
+.[0][1652]=1651
+.[0][1653]=1652
+.[0][1654]=1653
+.[0][1655]=1654
+.[0][1656]=1655
+.[0][1657]=1656
+.[0][1658]=1657
+.[0][1659]=1658
+.[0][1660]=1659
+.[0][1661]=1660
+.[0][1662]=1661
+.[0][1663]=1662
+.[0][1664]=1663
+.[0][1665]=1664
+.[0][1666]=1665
+.[0][1667]=1666
+.[0][1668]=1667
+.[0][1669]=1668
+.[0][1670]=1669
+.[0][1671]=1670
+.[0][1672]=1671
+.[0][1673]=1672
+.[0][1674]=1673
+.[0][1675]=1674
+.[0][1676]=1675
+.[0][1677]=1676
+.[0][1678]=1677
+.[0][1679]=1678
+.[0][1680]=1679
+.[0][1681]=1680
+.[0][1682]=1681
+.[0][1683]=1682
+.[0][1684]=1683
+.[0][1685]=1684
+.[0][1686]=1685
+.[0][1687]=1686
+.[0][1688]=1687
+.[0][1689]=1688
+.[0][1690]=1689
+.[0][1691]=1690
+.[0][1692]=1691
+.[0][1693]=1692
+.[0][1694]=1693
+.[0][1695]=1694
+.[0][1696]=1695
+.[0][1697]=1696
+.[0][1698]=1697
+.[0][1699]=1698
+.[0][1700]=1699
+.[0][1701]=1700
+.[0][1702]=1701
+.[0][1703]=1702
+.[0][1704]=1703
+.[0][1705]=1704
+.[0][1706]=1705
+.[0][1707]=1706
+.[0][1708]=1707
+.[0][1709]=1708
+.[0][1710]=1709
+.[0][1711]=1710
+.[0][1712]=1711
+.[0][1713]=1712
+.[0][1714]=1713
+.[0][1715]=1714
+.[0][1716]=1715
+.[0][1717]=1716
+.[0][1718]=1717
+.[0][1719]=1718
+.[0][1720]=1719
+.[0][1721]=1720
+.[0][1722]=1721
+.[0][1723]=1722
+.[0][1724]=1723
+.[0][1725]=1724
+.[0][1726]=1725
+.[0][1727]=1726
+.[0][1728]=1727
+.[0][1729]=1728
+.[0][1730]=1729
+.[0][1731]=1730
+.[0][1732]=1731
+.[0][1733]=1732
+.[0][1734]=1733
+.[0][1735]=1734
+.[0][1736]=1735
+.[0][1737]=1736
+.[0][1738]=1737