diff --git a/3d-bin-packing/3d-bin-packing-tests.ts b/3d-bin-packing/3d-bin-packing-tests.ts
index 319624d597..8e394e46bb 100644
--- a/3d-bin-packing/3d-bin-packing-tests.ts
+++ b/3d-bin-packing/3d-bin-packing-tests.ts
@@ -1,5 +1,5 @@
 import packer = require("3d-bin-packing");
-import samchon = require("samchon-framework");
+import samchon = require("samchon");
 
 function main(): void
 {
diff --git a/3d-bin-packing/index.d.ts b/3d-bin-packing/index.d.ts
index 14228f3141..8165ea513e 100644
--- a/3d-bin-packing/index.d.ts
+++ b/3d-bin-packing/index.d.ts
@@ -1,20 +1,22 @@
-// Type definitions for 3d-bin-packing
+// Type definitions for 3d-bin-packing v1.1.2
 // Project: https://github.com/betterwaysystems/packer
 // Definitions by: Jeongho Nam <http://samchon.org>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
 
-/// <reference types="typescript-stl" />
-/// <reference types="samchon-framework" />
-/// <reference types="react" />
-/// <reference types="react-data-grid" />
-/// <reference types="three" />
+/// <reference types="samchon" />
 
 declare module "3d-bin-packing"
 {
-        export = bws.packer;
+	export = bws.packer;
+}
+
+/// <reference types="samchon" />
+/// <reference types="tstl" />
+declare namespace bws.packer {
+    export import library = samchon.library;
+    export import protocol = samchon.protocol;
+    function _Test(): void;
 }
-declare var ReactDataGrid: typeof AdazzleReactDataGrid.ReactDataGrid;
 declare namespace boxologic {
     /**
      * <p> An abstract instance of boxologic. </p>
@@ -62,122 +64,6 @@ declare namespace boxologic {
         constructor(width: number, height: number, length: number);
     }
 }
-declare namespace bws.packer {
-    /**
-     * @brief Packer, a solver of 3d bin packing with multiple wrappers.
-     *
-     * @details
-     * <p> Packer is a facade class supporting packing operations in user side. You can solve a packing problem
-     * by constructing Packer class with {@link WrapperArray wrappers} and {@link InstanceArray instances} to
-     * pack and executing {@link optimize Packer.optimize()} method. </p>
-     *
-     * <p> In background side, deducting packing solution, those algorithms are used. </p>
-     * <ul>
-     *	<li> <a href="http://betterwaysystems.github.io/packer/reference/AirForceBinPacking.pdf" target="_blank">
-     *		Airforce Bin Packing; 3D pallet packing problem: A human intelligence-based heuristic approach </a>
-     *	</li>
-     *	<li> Genetic Algorithm </li>
-     *	<li> Greedy and Back-tracking algorithm </li>
-     * </ul>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Packer extends samchon.protocol.Entity {
-        /**
-         * Candidate wrappers who can contain instances.
-         */
-        protected wrapperArray: WrapperArray;
-        /**
-         * Instances trying to pack into the wrapper.
-         */
-        protected instanceArray: InstanceArray;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from members.
-         *
-         * @param wrapperArray Candidate wrappers who can contain instances.
-         * @param instanceArray Instances to be packed into some wrappers.
-         */
-        constructor(wrapperArray: WrapperArray, instanceArray: InstanceArray);
-        /**
-         * @inheritdoc
-         */
-        construct(xml: samchon.library.XML): void;
-        /**
-         * Get wrapperArray.
-         */
-        getWrapperArray(): WrapperArray;
-        /**
-         * Get instanceArray.
-         */
-        getInstanceArray(): InstanceArray;
-        /**
-         * <p> Deduct
-         *
-         */
-        optimize(): WrapperArray;
-        /**
-         * @brief Initialize sequence list (gene_array).
-         *
-         * @details
-         * <p> Deducts initial sequence list by such assumption: </p>
-         *
-         * <ul>
-         *	<li> Cost of larger wrapper is less than smaller one, within framework of price per volume unit. </li>
-         *	<ul>
-         *		<li> Wrapper Larger: (price: $1,000, volume: 100cm^3 -> price per volume unit: $10 / cm^3) </li>
-         *		<li> Wrapper Smaller: (price: $700, volume: 50cm^3 -> price per volume unit: $14 / cm^3) </li>
-         *		<li> Larger's <u>cost</u> is less than Smaller, within framework of price per volume unit </li>
-         *	</ul>
-         * </ul>
-         *
-         * <p> Method {@link initGenes initGenes()} constructs {@link WrapperGroup WrapperGroups} corresponding
-         * with the {@link wrapperArray} and allocates {@link instanceArray instances} to a {@link WrapperGroup},
-         * has the smallest <u>cost</u> between containbles. </p>
-         *
-         * <p> After executing packing solution by {@link WrapperGroup.optimize WrapperGroup.optimize()}, trying to
-         * {@link repack re-pack} each {@link WrapperGroup} to another type of {@link Wrapper}, deducts the best
-         * solution between them. It's the initial sequence list of genetic algorithm. </p>
-         *
-         * @return Initial sequence list.
-         */
-        protected initGenes(): GAWrapperArray;
-        /**
-         * Try to repack each wrappers to another type.
-         *
-         * @param $wrappers Wrappers to repack.
-         * @return Re-packed wrappers.
-         */
-        protected repack($wrappers: WrapperArray): WrapperArray;
-        /**
-         * @inheritdoc
-         */
-        TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): samchon.library.XML;
-    }
-}
-declare namespace flex {
-    class TabNavigator extends React.Component<TabNavigatorProps, TabNavigatorProps> {
-        render(): JSX.Element;
-        private handle_change(index, event);
-    }
-    class NavigatorContent extends React.Component<NavigatorContentProps, NavigatorContentProps> {
-        render(): JSX.Element;
-    }
-    interface TabNavigatorProps extends React.Props<TabNavigator> {
-        selectedIndex?: number;
-        style?: React.CSSProperties;
-    }
-    interface NavigatorContentProps extends React.Props<NavigatorContent> {
-        label: string;
-    }
-}
 declare namespace boxologic {
     /**
      * A box, trying to pack into a {@link Pallet}.
@@ -589,7 +475,7 @@ declare namespace bws.packer {
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    class PackerForm extends samchon.protocol.Entity {
+    class PackerForm extends protocol.Entity {
         /**
          * Form of Instances to pack.
          */
@@ -609,12 +495,12 @@ declare namespace bws.packer {
          * @param wrapperArray Type of Wrappers to be used.
          */
         constructor(instanceFormArray: InstanceFormArray, wrapperArray: WrapperArray);
-        construct(xml: samchon.library.XML): void;
+        construct(xml: library.XML): void;
         optimize(): WrapperArray;
         getInstanceFormArray(): InstanceFormArray;
         getWrapperArray(): WrapperArray;
         TAG(): string;
-        toXML(): samchon.library.XML;
+        toXML(): library.XML;
         toPacker(): Packer;
     }
     /**
@@ -622,12 +508,12 @@ declare namespace bws.packer {
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    class InstanceFormArray extends samchon.protocol.EntityArrayCollection<InstanceForm> {
+    class InstanceFormArray extends protocol.EntityArrayCollection<InstanceForm> {
         /**
          * Default Constructor.
          */
         constructor();
-        createChild(xml: samchon.library.XML): InstanceForm;
+        createChild(xml: library.XML): InstanceForm;
         TAG(): string;
         CHILD_TAG(): string;
         /**
@@ -645,7 +531,7 @@ declare namespace bws.packer {
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    class InstanceForm extends samchon.protocol.Entity {
+    class InstanceForm extends protocol.Entity {
         /**
          * A duplicated Instance.
          */
@@ -661,7 +547,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        construct(xml: samchon.library.XML): void;
+        construct(xml: library.XML): void;
         private createInstance(xml);
         key(): any;
         getInstance(): Instance;
@@ -679,7 +565,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        toXML(): samchon.library.XML;
+        toXML(): library.XML;
         /**
          * <p> Repeated {@link instance} to {@link InstanceArray}.
          *
@@ -694,7 +580,7 @@ declare namespace bws.packer {
     }
 }
 declare namespace bws.packer {
-    class WrapperArray extends samchon.protocol.EntityArrayCollection<Wrapper> {
+    class WrapperArray extends protocol.EntityArrayCollection<Wrapper> {
         /**
          * Default Constructor.
          */
@@ -702,7 +588,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        createChild(xml: samchon.library.XML): Wrapper;
+        createChild(xml: library.XML): Wrapper;
         /**
          * Get (calculate) price.
          */
@@ -756,7 +642,7 @@ declare namespace bws.packer {
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    interface Instance extends samchon.protocol.IEntity {
+    interface Instance extends protocol.IEntity {
         /**
          * Get name.
          */
@@ -813,7 +699,7 @@ declare namespace bws.packer {
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    class InstanceArray extends samchon.protocol.EntityArray<Instance> {
+    class InstanceArray extends protocol.EntityArray<Instance> {
         /**
          * Default Constructor.
          */
@@ -821,7 +707,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        createChild(xml: samchon.library.XML): Instance;
+        createChild(xml: library.XML): Instance;
         /**
          * @inheritdoc
          */
@@ -832,13 +718,113 @@ declare namespace bws.packer {
         CHILD_TAG(): string;
     }
 }
+declare namespace bws.packer {
+    /**
+     * @brief Packer, a solver of 3d bin packing with multiple wrappers.
+     *
+     * @details
+     * <p> Packer is a facade class supporting packing operations in user side. You can solve a packing problem
+     * by constructing Packer class with {@link WrapperArray wrappers} and {@link InstanceArray instances} to
+     * pack and executing {@link optimize Packer.optimize()} method. </p>
+     *
+     * <p> In background side, deducting packing solution, those algorithms are used. </p>
+     * <ul>
+     *	<li> <a href="http://betterwaysystems.github.io/packer/reference/AirForceBinPacking.pdf" target="_blank">
+     *		Airforce Bin Packing; 3D pallet packing problem: A human intelligence-based heuristic approach </a>
+     *	</li>
+     *	<li> Genetic Algorithm </li>
+     *	<li> Greedy and Back-tracking algorithm </li>
+     * </ul>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Packer extends protocol.Entity {
+        /**
+         * Candidate wrappers who can contain instances.
+         */
+        protected wrapperArray: WrapperArray;
+        /**
+         * Instances trying to pack into the wrapper.
+         */
+        protected instanceArray: InstanceArray;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from members.
+         *
+         * @param wrapperArray Candidate wrappers who can contain instances.
+         * @param instanceArray Instances to be packed into some wrappers.
+         */
+        constructor(wrapperArray: WrapperArray, instanceArray: InstanceArray);
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Get wrapperArray.
+         */
+        getWrapperArray(): WrapperArray;
+        /**
+         * Get instanceArray.
+         */
+        getInstanceArray(): InstanceArray;
+        /**
+         * <p> Deduct
+         *
+         */
+        optimize(): WrapperArray;
+        /**
+         * @brief Initialize sequence list (gene_array).
+         *
+         * @details
+         * <p> Deducts initial sequence list by such assumption: </p>
+         *
+         * <ul>
+         *	<li> Cost of larger wrapper is less than smaller one, within framework of price per volume unit. </li>
+         *	<ul>
+         *		<li> Wrapper Larger: (price: $1,000, volume: 100cm^3 -> price per volume unit: $10 / cm^3) </li>
+         *		<li> Wrapper Smaller: (price: $700, volume: 50cm^3 -> price per volume unit: $14 / cm^3) </li>
+         *		<li> Larger's <u>cost</u> is less than Smaller, within framework of price per volume unit </li>
+         *	</ul>
+         * </ul>
+         *
+         * <p> Method {@link initGenes initGenes()} constructs {@link WrapperGroup WrapperGroups} corresponding
+         * with the {@link wrapperArray} and allocates {@link instanceArray instances} to a {@link WrapperGroup},
+         * has the smallest <u>cost</u> between containbles. </p>
+         *
+         * <p> After executing packing solution by {@link WrapperGroup.optimize WrapperGroup.optimize()}, trying to
+         * {@link repack re-pack} each {@link WrapperGroup} to another type of {@link Wrapper}, deducts the best
+         * solution between them. It's the initial sequence list of genetic algorithm. </p>
+         *
+         * @return Initial sequence list.
+         */
+        protected initGenes(): GAWrapperArray;
+        /**
+         * Try to repack each wrappers to another type.
+         *
+         * @param $wrappers Wrappers to repack.
+         * @return Re-packed wrappers.
+         */
+        protected repack($wrappers: WrapperArray): WrapperArray;
+        /**
+         * @inheritdoc
+         */
+        TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
 declare namespace bws.packer {
     /**
      * A product.
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    class Product extends samchon.protocol.Entity implements Instance {
+    class Product extends protocol.Entity implements Instance {
         /**
          * <p> Name, key of the Product. </p>
          *
@@ -921,7 +907,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        toXML(): samchon.library.XML;
+        toXML(): library.XML;
     }
 }
 declare namespace bws.packer {
@@ -937,7 +923,7 @@ declare namespace bws.packer {
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    class Wrap extends samchon.protocol.Entity {
+    class Wrap extends protocol.Entity {
         /**
          * A wrapper wrapping the {@link instance}.
          */
@@ -962,10 +948,6 @@ declare namespace bws.packer {
          * Placement orientation of wrapped {@link instance}.
          */
         protected orientation: number;
-        /**
-         *
-         */
-        protected color: number;
         /**
          * Construct from a Wrapper.
          *
@@ -996,7 +978,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        construct(xml: samchon.library.XML): void;
+        construct(xml: library.XML): void;
         /**
          * Factory method of wrapped Instance.
          *
@@ -1058,11 +1040,11 @@ declare namespace bws.packer {
         /**
          * Get width.
          */
-        getWidth(): number;
+        getLayoutWidth(): number;
         /**
          * Get height.
          */
-        getHeight(): number;
+        getLayoutHeight(): number;
         /**
          * Get length.
          */
@@ -1071,9 +1053,9 @@ declare namespace bws.packer {
          * Get volume.
          */
         getVolume(): number;
-        $instanceName: string;
-        $layoutScale: string;
-        $position: string;
+        readonly $instanceName: string;
+        readonly $layoutScale: string;
+        readonly $position: string;
         /**
          * @inheritdoc
          */
@@ -1081,19 +1063,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        toXML(): samchon.library.XML;
-        /**
-         * Thickness of boundary lines of a shape represents the {@link instance}.
-         */
-        private static BOUNDARY_THICKNESS;
-        /**
-         *
-         *
-         * @param geometry
-         *
-         * @return A shape and its boundary lines as 3D-objects.
-         */
-        toDisplayObjects(geometry: THREE.Geometry): std.Vector<THREE.Object3D>;
+        toXML(): library.XML;
     }
 }
 declare namespace bws.packer {
@@ -1102,7 +1072,7 @@ declare namespace bws.packer {
      *
      * @author Jeongho Nam <http://samchon.org>
      */
-    class Wrapper extends samchon.protocol.EntityDeque<Wrap> implements Instance {
+    class Wrapper extends protocol.EntityDeque<Wrap> implements Instance {
         /**
          * <p> Name, key of the Wrapper. </p>
          *
@@ -1151,11 +1121,10 @@ declare namespace bws.packer {
          * @param thickness A thickness causes shrinkness on containable volume.
          */
         constructor(name: string, price: number, width: number, height: number, length: number, thickness: number);
-        construct(xml: samchon.library.XML): void;
         /**
          * @inheritdoc
          */
-        createChild(xml: samchon.library.XML): Wrap;
+        createChild(xml: library.XML): Wrap;
         /**
          * Key of a Wrapper is its name.
          */
@@ -1232,7 +1201,7 @@ declare namespace bws.packer {
          * @return utilization ratio.
          */
         getUtilization(): number;
-        equal_to(obj: Wrapper): boolean;
+        equals(obj: Wrapper): boolean;
         /**
          * <p> Wrapper is enough greater? </p>
          *
@@ -1272,8 +1241,8 @@ declare namespace bws.packer {
         $height: string;
         $length: string;
         $thickness: string;
-        $scale: string;
-        $spaceUtilization: string;
+        readonly $scale: string;
+        readonly $spaceUtilization: string;
         /**
          * @inheritdoc
          */
@@ -1289,25 +1258,7 @@ declare namespace bws.packer {
         /**
          * @inheritdoc
          */
-        toXML(): samchon.library.XML;
-        private static scene;
-        private static renderer;
-        private static camera;
-        private static trackball;
-        private static mouse;
-        private static BOUNDARY_THICKNESS;
-        /**
-         * <p> Convert to a canvas containing 3D elements. </p>
-         *
-         * @param endIndex
-         *
-         * @return A 3D-canvans printing the Wrapper and its children {@link Wrap wrapped}
-         *						{@link Instance instances} with those boundary lines.
-         */
-        toCanvas(endIndex?: number): HTMLCanvasElement;
-        private static handleMouseMove(event);
-        private static animate();
-        private static render();
+        toXML(): library.XML;
     }
 }
 declare namespace bws.packer {
@@ -1430,72 +1381,3 @@ declare namespace bws.packer {
         TAG(): string;
     }
 }
-declare namespace bws.packer {
-    abstract class Editor<T extends samchon.protocol.IEntity> extends React.Component<{
-        dataProvider: samchon.protocol.EntityArrayCollection<T>;
-    }, {}> {
-        private columns;
-        private selected_index;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        protected abstract createColumns(): AdazzleReactDataGrid.Column[];
-        private get_row(index);
-        private insert_instance(event);
-        private erase_instances(event);
-        private handle_data_change(event);
-        private handle_row_change(event);
-        private handle_select(event);
-        render(): JSX.Element;
-    }
-}
-declare namespace bws.packer {
-    interface ItemEditorProps extends React.Props<ItemEditor> {
-        application: PackerApplication;
-        instances: InstanceFormArray;
-        wrappers: WrapperArray;
-    }
-    class ItemEditor extends React.Component<ItemEditorProps, {}> {
-        private clear(event);
-        private open(event);
-        private save(event);
-        private pack(event);
-        render(): JSX.Element;
-    }
-    class InstanceEditor extends Editor<InstanceForm> {
-        protected createColumns(): AdazzleReactDataGrid.Column[];
-    }
-    class WrapperEditor extends Editor<Wrapper> {
-        protected createColumns(): AdazzleReactDataGrid.Column[];
-    }
-}
-declare namespace bws.packer {
-    class PackerApplication extends React.Component<{}, {}> {
-        private instances;
-        private wrappers;
-        private result;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        pack(): void;
-        drawWrapper(wrapper: Wrapper, index?: number): void;
-        render(): JSX.Element;
-        static main(): void;
-    }
-}
-declare namespace bws.packer {
-    class ResultViewer extends React.Component<WrapperViewerProps, {}> {
-        drawWrapper(wrapper: Wrapper, index?: number): void;
-        private clear(event);
-        private open(event);
-        private save(event);
-        refresh(): void;
-        render(): JSX.Element;
-    }
-    interface WrapperViewerProps extends React.Props<ResultViewer> {
-        application: PackerApplication;
-        wrappers: WrapperArray;
-    }
-}
diff --git a/samchon-framework/index.d.ts b/samchon-framework/index.d.ts
index 558efd674a..fa540e033d 100644
--- a/samchon-framework/index.d.ts
+++ b/samchon-framework/index.d.ts
@@ -1,10811 +1,13 @@
-// Type definitions for Samchon Framework 2.0
+// Type definitions for Samchon Framework v2.0.x
 // Project: https://github.com/samchon/framework
 // Definitions by: Jeongho Nam <http://samchon.org>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="typescript-stl" />
+/// <reference types="samchon" />
+// Samchon-Framework is renamed to Samchon
 
 declare module "samchon-framework"
 {
+	import samchon = require("samchon");
 	export = samchon;
-}
-
-/**
- * # Samchon-Framework
- *
- * <a href="https://nodei.co/npm/samchon-framework">
- *	<img src="https://nodei.co/npm/samchon-framework.png?downloads=true&downloadRank=true&stars=true"> </a>
- *
- * Samchon, a OON (Object-Oriented Network) framework.
- *
- * With Samchon Framework, you can implement distributed processing system within framework of OOD like handling S/W
- * objects (classes). You can realize cloud and distributed system very easily with provided system templates and even
- * integration with C++ is possible.
- *
- * The goal, ultimate utilization model of Samchon Framework is, building cloud system with NodeJS and taking heavy works
- * to C++ distributed systems with provided modules (those are system templates).
- *
- * @git https://github.com/samchon/framework
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace samchon {
-    /**
-     * Running on Node.
-     *
-     * Test whether the JavaScript is running on Node.
-     *
-     * @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
-     */
-    function is_node(): boolean;
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link Vector} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link CollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   -  {@link insert}
-     *   -  {@link push}
-     *   -  {@link push_back}
-     *   -  {@link unshift}
-     * - *erase* typed events:
-     *   -  {@link assign}
-     *   -  {@link clear}
-     *   -  {@link erase}
-     *   - {@link pop_back}
-     *   - {@link shift}
-     *   - {@link pop}
-     *   - {@link splice}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link Vector}
-     * {@link Vector Vectors}s are sequence containers representing arrays that can change in size.
-     *
-     * Just like arrays, {@link Vector}s use contiguous storage locations for their elements, which means that their
-     * elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently as in
-     * arrays. But unlike arrays, their size can change dynamically, with their storage being handled automatically
-     * by the container.
-     *
-     * Internally, {@link Vector}s use a dynamically allocated array to store their elements. This array may need to
-     * be reallocated in order to grow in size when new elements are inserted, which implies allocating a new array
-     * and moving all elements to it. This is a relatively expensive task in terms of processing time, and thus,
-     * {@link Vector}s do not reallocate each time an element is added to the container.
-     *
-     * Instead, {@link Vector} containers may allocate some extra storage to accommodate for possible growth, and
-     * thus the container may have an actual {@link capacity} greater than the storage strictly needed to contain its
-     * elements (i.e., its {@link size}). Libraries can implement different strategies for growth to balance between
-     * memory usage and reallocations, but in any case, reallocations should only happen at logarithmically growing
-     * intervals of {@link size} so that the insertion of individual elements at the end of the {@link Vector} can be
-     * provided with amortized constant time complexity (see {@link push_back push_back()}).
-     *
-     * Therefore, compared to arrays, {@link Vector}s consume more memory in exchange for the ability to manage
-     * storage and grow dynamically in an efficient way.
-     *
-     * Compared to the other dynamic sequence containers ({@link Deque}s, {@link List}s), {@link Vector Vectors} are
-     * very efficient accessing its elements (just like arrays) and relatively efficient adding or removing elements
-     * from its end. For operations that involve inserting or removing elements at positions other than the end, they
-     * perform worse than the others, and have less consistent iterators and references than {@link List}s.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Sequence </dt>
-     *	<dd>
-     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
-     *		accessed by their position in this sequence.
-     *	</dd>
-     *
-     *	<dt> Dynamic array </dt>
-     *	<dd>
-     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
-     *		relatively fast addition/removal of elements at the end of the sequence.
-     *	</dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/vector/vector
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ArrayCollection<T> extends std.Vector<T> implements ICollection<T> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        push(...items: T[]): number;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: std.VectorIterator<T>, n: number, val: T): std.VectorIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.VectorIterator<T>, begin: InputIterator, end: InputIterator): std.VectorIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: std.VectorIterator<T>, last: std.VectorIterator<T>): std.VectorIterator<T>;
-        /**
-         * @hidden
-         */
-        private notify_insert(first, last);
-        /**
-         * @hidden
-         */
-        private notify_erase(first, last);
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.VectorIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.VectorIterator<T>, last: std.VectorIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        unshift<U extends T>(...items: U[]): number;
-        /**
-         * @inheritdoc
-         */
-        pop(): T;
-        /**
-         * @inheritdoc
-         */
-        splice(start: number): T[];
-        /**
-         * @inheritdoc
-         */
-        splice(start: number, deleteCount: number, ...items: T[]): T[];
-    }
-}
-declare namespace samchon.library {
-    /**
-     * A basic event class of Samchon Framework.
-     *
-     * @reference https://developer.mozilla.org/en-US/docs/Web/API/Event
-     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-EventDispatcher
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class BasicEvent {
-        protected type_: string;
-        protected target_: IEventDispatcher;
-        private currentTarget_;
-        protected trusted_: boolean;
-        protected bubbles_: boolean;
-        protected cancelable_: boolean;
-        protected defaultPrevented_: boolean;
-        protected cancelBubble_: boolean;
-        private timeStamp_;
-        constructor(type: string, bubbles?: boolean, cancelable?: boolean);
-        /**
-         * @inheritdoc
-         */
-        initEvent(type: string, bubbles: boolean, cancelable: boolean): void;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * @inheritdoc
-         */
-        stopImmediatePropagation(): void;
-        /**
-         * @inheritdoc
-         */
-        stopPropagation(): void;
-        /**
-         * @inheritdoc
-         */
-        readonly type: string;
-        /**
-         * @inheritdoc
-         */
-        target: IEventDispatcher;
-        /**
-         * @inheritdoc
-         */
-        readonly currentTarget: IEventDispatcher;
-        /**
-         * @inheritdoc
-         */
-        readonly isTrusted: boolean;
-        /**
-         * @inheritdoc
-         */
-        readonly bubbles: boolean;
-        /**
-         * @inheritdoc
-         */
-        readonly cancelable: boolean;
-        /**
-         * @inheritdoc
-         */
-        readonly eventPhase: number;
-        /**
-         * @inheritdoc
-         */
-        readonly defaultPrevented: boolean;
-        /**
-         * @inheritdoc
-         */
-        readonly srcElement: Element;
-        /**
-         * @inheritdoc
-         */
-        readonly cancelBubble: boolean;
-        /**
-         * @inheritdoc
-         */
-        readonly timeStamp: number;
-        /**
-         * Don't know what it is.
-         */
-        readonly returnValue: boolean;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * Type of function pointer for listener of {@link CollectionEvent CollectionEvents}.
-     */
-    type CollectionEventListener<T> = (event: CollectionEvent<T>) => void;
-}
-declare namespace samchon.collections {
-    /**
-     * An event occured in a {@link ICollection collection} object.
-     *
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class CollectionEvent<T> extends library.BasicEvent {
-        /**
-         * @hidden
-         */
-        private first_;
-        /**
-         * @hidden
-         */
-        private last_;
-        /**
-         * @hidden
-         */
-        private temporary_container_;
-        /**
-         * @hidden
-         */
-        private origin_first_;
-        /**
-         * Initialization Constructor.
-         *
-         * @param type Type of collection event.
-         * @param first An {@link Iterator} to the initial position in this {@link CollectionEvent}.
-         * @param last An {@link Iterator} to the final position in this {@link CollectionEvent}.
-         */
-        constructor(type: string, first: std.Iterator<T>, last: std.Iterator<T>);
-        constructor(type: "insert", first: std.Iterator<T>, last: std.Iterator<T>);
-        constructor(type: "erase", first: std.Iterator<T>, last: std.Iterator<T>);
-        constructor(type: "refresh", first: std.Iterator<T>, last: std.Iterator<T>);
-        /**
-         * Associative target, the {@link ICollection collection}.
-         */
-        readonly target: ICollection<T>;
-        /**
-         * An {@link Iterator} to the initial position in this {@link CollectionEvent}.
-         */
-        readonly first: std.Iterator<T>;
-        /**
-         * An {@link Iterator} to the final position in this {@link CollectionEvent}.
-         */
-        readonly last: std.Iterator<T>;
-        /**
-         * @inheritdoc
-         */
-        preventDefault(): void;
-    }
-}
-declare namespace samchon.collections.CollectionEvent {
-    const INSERT: "insert";
-    const ERASE: "erase";
-    const REFRESH: "refresh";
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link Deque} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link CollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link push}
-     *   - {@link push_front}
-     *   - {@link push_back}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     *   - {@link pop_front}
-     *   - {@link pop_back}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link Deque}
-     * {@link Deque} (usually pronounced like "*deck*") is an irregular acronym of **d**ouble-**e**nded **q**ueue.
-     * Double-ended queues are sequence containers with dynamic sizes that can be expanded or contracted on both ends
-     * (either its front or its back).
-     *
-     * Specific libraries may implement deques in different ways, generally as some form of dynamic array. But in any
-     * case, they allow for the individual elements to be accessed directly through random access iterators, with
-     * storage handled automatically by expanding and contracting the container as needed.
-     *
-     * Therefore, they provide a functionality similar to vectors, but with efficient insertion and deletion of
-     * elements also at the beginning of the sequence, and not only at its end. But, unlike {@link Vector Vectors},
-     * {@link Deque Deques} are not guaranteed to store all its elements in contiguous storage locations: accessing
-     * elements in a <u>deque</u> by offsetting a pointer to another element causes undefined behavior.
-     *
-     * Both {@link Vector}s and {@link Deque}s provide a very similar interface and can be used for similar purposes,
-     * but internally both work in quite different ways: While {@link Vector}s use a single array that needs to be
-     * occasionally reallocated for growth, the elements of a {@link Deque} can be scattered in different chunks of
-     * storage, with the container keeping the necessary information internally to provide direct access to any of its
-     * elements in constant time and with a uniform sequential interface (through iterators). Therefore,
-     * {@link Deque Deques} are a little more complex internally than {@link Vector}s, but this allows them to grow
-     * more efficiently under certain circumstances, especially with very long sequences, where reallocations become
-     * more expensive.
-     *
-     * For operations that involve frequent insertion or removals of elements at positions other than the beginning or
-     * the end, {@link Deque Deques} perform worse and have less consistent iterators and references than
-     * {@link List Lists}.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Sequence </dt>
-     *	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements
-     *		 are accessed by their position in this sequence. </dd>
-     *
-     *	<dt> Dynamic array </dt>
-     *	<dd> Generally implemented as a dynamic array, it allows direct access to any element in the
-     *		 sequence and provides relatively fast addition/removal of elements at the beginning or the end
-     *		 of the sequence. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/deque/deque/
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DequeCollection<T> extends std.Deque<T> implements ICollection<T> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        push(...items: T[]): number;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: std.DequeIterator<T>, n: number, val: T): std.DequeIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.DequeIterator<T>, begin: InputIterator, end: InputIterator): std.DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: std.DequeIterator<T>, last: std.DequeIterator<T>): std.DequeIterator<T>;
-        /**
-         * @hidden
-         */
-        private notify_insert(first, last);
-        /**
-         * @hidden
-         */
-        private notify_erase(first, last);
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.DequeIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.DequeIterator<T>, last: std.DequeIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link HashMap} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link insert_or_assign}
-     *   - {@link emplace}
-     *   - {@link set}
-     *   - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     *   - {@link extract}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link HashMap}
-     * {@link HashMap HashMaps} are associative containers that store elements formed by the combination of a
-     * *key value* and a *mapped value*, and which allows for fast retrieval of individual elements based on their
-     * *keys*.
-     *
-     * In an {@link HashMap}, the *key value* is generally used to uniquely identify the element, while the
-     * *mapped value* is an object with the content associated to this *key*. Types of *key* and *mapped value* may
-     * differ.
-     *
-     * Internally, the elements in the {@link HashMap} are not sorted in any particular order with respect to either
-     * their *key* or *mapped values*, but organized into *buckets* depending on their hash values to allow for fast
-     * access to individual elements directly by their *key values* (with a constant average time complexity on
-     * average).
-     *
-     * {@link HashMap} containers are faster than {@link TreeMap} containers to access individual elements by their
-     * *key*, although they are generally less efficient for range iteration through a subset of their elements.
-     *
-     *  <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Associative </dt>
-     * 	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
-     *		 position in the container. </dd>
-     *
-     * 	<dt> Hashed </dt>
-     * 	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their *key*. </dd>
-     *
-     * 	<dt> Map </dt>
-     * 	<dd> Each element associates a *key* to a *mapped value*:
-     *		 *Keys* are meant to identify the elements whose main content is the *mapped value*. </dd>
-     *
-     * 	<dt> Unique keys </dt>
-     * 	<dd> No two elements in the container can have equivalent keys. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the key values.
-     *				Each element in an {@link HashMap} is uniquely identified by its key value.
-     * @param <T> Type of the mapped value.
-     *			  Each element in an {@link HashMap} is used to store some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_map
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMapCollection<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Pair<Key, T>> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link HashMultiMap} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link emplace}
-     *   - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link HashMultiMap}
-     * {@link HashMultiMap HashMultiMap}s are associative containers that store elements formed by the combination of
-     * a *key value* and a *mapped value*, much like {@link HashMultiMap} containers, but allowing different elements
-     * to have equivalent *keys*.
-     *
-     * In an {@link HashMultiMap}, the *key value* is generally used to uniquely identify the element, while the
-     * *mapped value* is an object with the content associated to this *key*. Types of *key* and *mapped value* may
-     * differ.
-     *
-     * Internally, the elements in the {@link HashMultiMap} are not sorted in any particular order with respect to
-     * either their *key* or *mapped values*, but organized into *buckets* depending on their hash values to allow for
-     * fast access to individual elements directly by their *key values* (with a constant average time complexity on
-     * average).
-     *
-     * Elements with equivalent *keys* are grouped together in the same bucket and in such a way that an iterator can
-     * iterate through all of them. Iterators in the container are doubly linked iterators.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their *key*. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a *key* to a *mapped value*:
-     *		 *Keys* are meant to identify the elements whose main content is the *mapped value*. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> The container can hold multiple elements with equivalent *keys*. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the key values.
-     *				Each element in an {@link HashMultiMap} is identified by a key value.
-     * @param <T> Type of the mapped value.
-     *			  Each element in an {@link HashMultiMap} is used to store some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_multimap
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMultiMapCollection<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Pair<Key, T>> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link HashMultiSet} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link CollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link HashMultiSet}
-     * {@link HashMultiSet HashMultiSets} are containers that store elements in no particular order, allowing fast
-     * retrieval of individual elements based on their value, much like {@link HashMultiSet} containers, but allowing
-     * different elements to have equivalent values.
-     *
-     * In an {@link HashMultiSet}, the value of an element is at the same time its *key*, used to identify it. *Keys*
-     * are immutable, therefore, the elements in an {@link HashMultiSet} cannot be modified once in the container -
-     * they can be inserted and removed, though.
-     *
-     * Internally, the elements in the {@link HashMultiSet} are not sorted in any particular, but organized into
-     * *buckets* depending on their hash values to allow for fast access to individual elements directly by their
-     * *values* (with a constant average time complexity on average).
-     *
-     * Elements with equivalent values are grouped together in the same bucket and in such a way that an iterator can
-     * iterate through all of them. Iterators in the container are doubly linked iterators.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their *key*. </dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the *key* used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> The container can hold multiple elements with equivalent *keys*. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *		   Each element in an {@link UnorderedMultiSet} is also identified by this value..
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_multiset
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMultiSetCollection<T> extends std.HashMultiSet<T> implements ICollection<T> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link HashSet} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link CollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link push}
-     *   - {@link insert_or_assign}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     *   - {@link extract}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link HashSet}
-     * {@link HashSet HashSets} are containers that store unique elements in no particular order, and which allow for
-     * fast retrieval of individual elements based on their value.
-     *
-     * In an {@link HashSet}, the value of an element is at the same time its *key*, that identifies it uniquely.
-     * Keys are immutable, therefore, the elements in an {@link HashSet} cannot be modified once in the container -
-     * they can be inserted and removed, though.
-     *
-     * Internally, the elements in the {@link HashSet} are not sorted in any particular order, but organized into
-     * buckets depending on their hash values to allow for fast access to individual elements directly by their
-     * *values* (with a constant average time complexity on average).
-     *
-     * {@link HashSet} containers are faster than {@link TreeSet} containers to access individual elements by their
-     * *key*, although they are generally less efficient for range iteration through a subset of their elements.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their *key*. </dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the *key* used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent *keys*. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *			  Each element in an {@link HashSet} is also uniquely identified by this value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashSetCollection<T> extends std.HashSet<T> implements ICollection<T> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-    }
-}
-/**
- * Collections, elements I/O detectable STL containers.
- *
- * STL Containers       | Collections
- * ---------------------|-------------------
- * {@link Vector}       | {@link ArrayCollection}
- * {@link List}         | {@link ListCollection}
- * {@link Deque}        | {@link DequeCollection}
- *                      |
- * {@link TreeSet}      | {@link TreeSetCollection}
- * {@link HashSet}      | {@link HashSetCollection}
- * {@link TreeMultiSet} | {@link TreeMultiSetCollection}
- * {@link HashMultiSet} | {@link HashMultiSetCollection}
- *                      |
- * {@link TreeMap}      | {@link TreeMapCollection}
- * {@link HashMap}      | {@link HashMapCollection}
- * {@link TreeMultiMap} | {@link TreeMultiMapCollection}
- * {@link HashMultiMap} | {@link HashMultiMapCollection}
- *
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace samchon.collections {
-    /**
-     * An interface for {@link IContainer containers} who can detect element I/O events.
-     *
-     * Below are list of methods who are dispatching {@link CollectionEvent}:
-     * - *insert* typed events:
-     *	 - {@link assign}
-     *   - {@link insert}
-     *	 - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface ICollection<T> extends std.base.IContainer<T>, library.IEventDispatcher {
-        /**
-         * Dispatch a {@link CollectionEvent} with *refresh* typed.
-         *
-         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
-         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
-         * There's no way to detect those events automatically by {@link IContainer}.
-         *
-         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
-         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
-         * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
-         * *refresh* typed will be dispatched.
-         *
-         * If you don't specify any iterator, then the range of the *refresh* event will be all elements in this
-         * {@link ICollection collection}; {@link begin begin()} to {@link end end()}.
-         */
-        refresh(): void;
-        /**
-         * Dispatch a {@link CollectionEvent} with *refresh* typed.
-         *
-         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
-         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
-         * There's no way to detect those events automatically by {@link IContainer}.
-         *
-         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
-         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
-         * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
-         * *refresh* typed will be dispatched.
-         *
-         * @param it An iterator targeting the content changed element.
-         */
-        refresh(it: std.Iterator<T>): void;
-        /**
-         * Dispatch a {@link CollectionEvent} with *refresh* typed.
-         *
-         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
-         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
-         * There's no way to detect those events automatically by {@link IContainer}.
-         *
-         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
-         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
-         * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
-         * *refresh* typed will be dispatched.
-         *
-         * @param first An Iterator to the initial position in a sequence of the content changed elmeents.
-         * @param last An {@link Iterator} to the final position in a sequence of the content changed elements. The range
-         *			   used is [*first*, *last*), which contains all the elements between *first* and
-         *			   *last*, including the element pointed by *first* but not the element pointed by
-         *			   *last*.
-         */
-        refresh(first: std.Iterator<T>, last: std.Iterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-    }
-    /**
-     * @hidden
-     */
-    namespace ICollection {
-        /**
-         * @hidden
-         */
-        function _Dispatch_CollectionEvent<T>(collection: ICollection<T>, type: string, first: std.Iterator<T>, last: std.Iterator<T>): void;
-        /**
-         * @hidden
-         */
-        function _Dispatch_MapCollectionEvent<Key, T>(collection: ICollection<std.Pair<Key, T>>, type: string, first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link List} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link CollectionEvent}:
-     *	- *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link push}
-     *   - {@link push_front}
-     *   - {@link push_back}
-     *   - {@link merge}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     *   - {@link pop_front}
-     *   - {@link pop_back}
-     *   - {@link unique}
-     *   - {@link remove}
-     *   - {@link remove_if}
-     *   - {@link splice}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *   - {@link sort}
-     *
-     * #### [Inherited] {@link List}
-     * {@link List Lists} are sequence containers that allow constant time insert and erase operations anywhere within
-     * the sequence, and iteration in both directions.
-     *
-     * List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they
-     * contain in different and unrelated storage locations. The ordering is kept internally by the association to
-     * each element of a link to the element preceding it and a link to the element following it.
-     *
-     * They are very similar to forward_list: The main difference being that forward_list objects are single-linked
-     * lists, and thus they can only be iterated forwards, in exchange for being somewhat smaller and more efficient.
-     *
-     * Compared to other base standard sequence containers (array, vector and deque), lists perform generally better
-     * in inserting, extracting and moving elements in any position within the container for which an iterator has
-     * already been obtained, and therefore also in algorithms that make intensive use of these, like sorting
-     * algorithms.
-     *
-     * The main drawback of lists and forward_lists compared to these other sequence containers is that they lack
-     * direct access to the elements by their position; For example, to access the sixth element in a list, one has to
-     * iterate from a known position (like the beginning or the end) to that position, which takes linear time in the
-     * distance between these. They also consume some extra memory to keep the linking information associated to each
-     * element (which may be an important factor for large lists of small-sized elements).
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Sequence </dt>
-     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
-     *		 their position in this sequence. </dd>
-     *
-     * 	<dt> Doubly-linked list </dt>
-     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing constant time
-     *		 insert and erase operations before or after a specific element (even of entire ranges), but no direct random
-     *		 access. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/list/list/
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ListCollection<T> extends std.List<T> implements ICollection<T> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        push(...items: T[]): number;
-        /**
-         * @inheritdoc
-         */
-        push_front(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: std.ListIterator<T>, n: number, val: T): std.ListIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.ListIterator<T>, begin: InputIterator, end: InputIterator): std.ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        pop_front(): void;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: std.ListIterator<T>, last: std.ListIterator<T>): std.ListIterator<T>;
-        /**
-         * @hidden
-         */
-        private notify_insert(first, last);
-        /**
-         * @hidden
-         */
-        private notify_erase(first, last);
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.ListIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.ListIterator<T>, last: std.ListIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    type MapCollectionEventListener<Key, T> = (event: MapCollectionEvent<Key, T>) => void;
-    /**
-     * An event occured in a {@link MapContainer map container} object.
-     *
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MapCollectionEvent<Key, T> extends CollectionEvent<std.Pair<Key, T>> {
-        /**
-         * @inheritdoc
-         */
-        readonly first: std.MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        readonly last: std.MapIterator<Key, T>;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link TreeMap} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link insert_or_assign}
-     *   - {@link emplace}
-     *   - {@link set}
-     *   - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     *   - {@link extract}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link TreeMap}
-     * {@link TreeMap TreeMaps} are associative containers that store elements formed by a combination of a
-     * *key value* (*Key*) and a *mapped value* (*T*), following order.
-     *
-     * In a {@link TreeMap}, the *key values* are generally used to sort and uniquely identify the elements, while the
-     * *mapped values* store the content associated to this key. The types of *key* and *mapped value* may differ, and
-     * are grouped together in member type *value_type*, which is a {@link Pair} type combining both:
-     *
-     * ```typedef Pair<Key, T> value_type;```
-     *
-     * Internally, the elements in a {@link TreeMap} are always sorted by its *key* following a *strict weak ordering*
-     * criterion indicated by its internal comparison method {@link less}.
-     *
-     * {@link TreeMap} containers are generally slower than {@link HashMap HashMap} containers to access individual
-     * elements by their *key*, but they allow the direct iteration on subsets based on their order.
-     *
-     * {@link TreeMap}s are typically implemented as binary search trees.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
-     *		 given a position in this order. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a *key* to a *mapped value*:
-     *		 *Keys* are meant to identify the elements whose main content is the *mapped value*. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent *keys*. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/map/map
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMapCollection<Key, T> extends std.TreeMap<Key, T> implements ICollection<std.Pair<Key, T>> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link TreeMultiMap} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link emplace}
-     *   - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link TreeMultiMap}
-     * {@link TreeMultiMap TreeMultiMaps} are associative containers that store elements formed by a combination of a
-     * *key value* and a *mapped value*, following a specific order, and where multiple elements can have equivalent
-     * keys.
-     *
-     * In a {@link TreeMultiMap}, the *key values* are generally used to sort and uniquely identify the elements,
-     * while the *mapped values* store the content associated to this *key*. The types of *key* and *mapped value* may
-     * differ, and are grouped together in member type ```value_type```, which is a {@link Pair} type combining both:
-     *
-     * ```typedef Pair<const Key, T> value_type;```
-     *
-     * Internally, the elements in a {@link TreeMultiMap}are always sorted by its key following a strict weak ordering
-     * criterion indicated by its internal comparison method (of {@link less}).
-     *
-     * {@link TreeMultiMap}containers are generally slower than {@link HashMap} containers to access individual
-     * elements by their *key*, but they allow the direct iteration on subsets based on their order.
-     *
-     * {@link TreeMultiMap TreeMultiMaps} are typically implemented as binary search trees.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank"> <
-     * img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their *key* and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a *key* to a *mapped value*:
-     *		*Keys* are meant to identify the elements whose main content is the *mapped value*.
-     *	</dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent *keys*. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/map/multimap
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMultiMapCollection<Key, T> extends std.TreeMultiMap<Key, T> implements ICollection<std.Pair<Key, T>> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link TreeMultiSet} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link CollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link TreeMultiSet}
-     * {@link TreeMultiSet TreeMultiSets} are containers that store elements following a specific order, and where
-     * multiple elements can have equivalent values.
-     *
-     * In a {@link TreeMultiSet}, the value of an element also identifies it (the value is itself the *key*, of type
-     * *T*). The value of the elements in a {@link TreeMultiSet} cannot be modified once in the container (the
-     * elements are always const), but they can be inserted or removed from the container.
-     *
-     * Internally, the elements in a {@link TreeMultiSet TreeMultiSets} are always sorted following a strict weak
-     * ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}).
-     *
-     * {@link TreeMultiSet} containers are generally slower than {@link HashMultiSet} containers to access individual
-     * elements by their *key*, but they allow the direct iteration on subsets based on their order.
-     *
-     * <p> {@link TreeMultiSet TreeMultiSets} are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their *key* and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the *key* used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent *keys*. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link TreeMultiSet} container is also identified
-     *			  by this value (each value is itself also the element's *key*).
-     *
-     * @reference http://www.cplusplus.com/reference/set/multiset
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMultiSetCollection<T> extends std.TreeMultiSet<T> implements ICollection<T> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.collections {
-    /**
-     * A {@link TreeMap} who can detect element I/O events.
-     *
-     * Below is the list of methods who are dispatching {@link CollectionEvent}:
-     * - *insert* typed events:
-     *   - {@link assign}
-     *   - {@link insert}
-     *   - {@link insert_or_assign}
-     *   - {@link push}
-     * - *erase* typed events:
-     *   - {@link assign}
-     *   - {@link clear}
-     *   - {@link erase}
-     *   - {@link extract}
-     * - *refresh* typed events:
-     *   - {@link refresh}
-     *
-     * #### [Inherited] {@link TreeSet}
-     * {@link TreeSet TreeSets} are containers that store unique elements following a specific order.
-     *
-     * In a {@link TreeSet}, the value of an element also identifies it (the value is itself the *key*, of type *T*),
-     * and each value must be unique. The value of the elements in a {@link TreeSet} cannot be modified once in the
-     * container (the elements are always const), but they can be inserted or removed from the container.
-     *
-     * Internally, the elements in a {@link TreeSet} are always sorted following a specific strict weak ordering
-     * criterion indicated by its internal comparison method (of {@link less}).
-     *
-     * {@link TreeSet} containers are generally slower than {@link HashSet} containers to access individual elements
-     * by their *key*, but they allow the direct iteration on subsets based on their order.
-     *
-     * {@link TreeSet}s are typically implemented as binary search trees.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their *key* and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the *key* used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent *keys*. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *			  Each element in an {@link TreeSet} is also uniquely identified by this value.
-     *
-     * @reference http://www.cplusplus.com/reference/set/set
-     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeSetCollection<T> extends std.TreeSet<T> implements ICollection<T> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.library {
-    /**
-     * Case generator.
-     *
-     * {@link CaseGenerator} is an abstract case generator being used like a matrix.
-     * <ul>
-     *  <li> n��r(n^r) -> {@link CombinedPermutationGenerator} </li>
-     *  <li> nPr -> {@link PermutationGenerator} </li>
-     *  <li> n! -> {@link FactorialGenerator} </li>
-     * </ul>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class CaseGenerator {
-        /**
-         * Size, the number of all cases.
-         */
-        protected size_: number;
-        /**
-         * N, size of the candidates.
-         */
-        protected n_: number;
-        /**
-         * R, size of elements of each case.
-         */
-        protected r_: number;
-        /**
-         * Construct from size of N and R.
-         *
-         * @param n Size of candidates.
-         * @param r Size of elements of each case.
-         */
-        constructor(n: number, r: number);
-        /**
-         * Get size of all cases.
-         *
-         * @return Get a number of the all cases.
-         */
-        size(): number;
-        /**
-         * Get size of the N.
-         */
-        n(): number;
-        /**
-         * Get size of the R.
-         */
-        r(): number;
-        /**
-         * Get index'th case.
-         *
-         * @param index Index number
-         * @return The row of the index'th in combined permuation case
-         */
-        abstract at(index: number): number[];
-    }
-    /**
-     * A combined-permutation case generator.
-     *
-     * <sub>n</sub>��<sub>r</sub>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class CombinedPermutationGenerator extends CaseGenerator {
-        /**
-         * An array using for dividing each element index.
-         */
-        private divider_array;
-        /**
-         * Construct from size of N and R.
-         *
-         * @param n Size of candidates.
-         * @param r Size of elements of each case.
-         */
-        constructor(n: number, r: number);
-        at(index: number): number[];
-    }
-    /**
-     * A permutation case generator.
-     *
-     * <sub>n</sub>P<sub>r</sub>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class PermuationGenerator extends CaseGenerator {
-        /**
-         * Construct from size of N and R.
-         *
-         * @param n Size of candidates.
-         * @param r Size of elements of each case.
-         */
-        constructor(n: number, r: number);
-        /**
-         * @inheritdoc
-         */
-        at(index: number): number[];
-    }
-    /**
-     * Factorial case generator.
-     *
-     * n! = <sub>n</sub>P<sub>n</sub>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class FactorialGenerator extends PermuationGenerator {
-        /**
-         * Construct from factorial size N.
-         *
-         * @param n Factoria size N.
-         */
-        constructor(n: number);
-    }
-}
-declare namespace samchon.library {
-    type BasicEventListener = (event: BasicEvent) => void;
-    /**
-     * The IEventDispatcher interface defines methods for adding or removing event listeners, checks whether specific
-     * types of event listeners are registered, and dispatches events.
-     *
-     * The event target serves as the local point for how events flow through the display list hierarchy. When an
-     * event such as a mouse click or a key press occurs, an event object is dispatched into the event flow from the
-     * root of the display list. The event object makes a round-trip journey to the event target, which is
-     * conceptually divided into three phases: the capture phase includes the journey from the root to the last node
-     * before the event target's node; the target phase includes only the event target node; and the bubbling phase
-     * includes any subsequent nodes encountered on the return trip to the root of the display list.
-     *
-     * In general, the easiest way for a user-defined class to gain event dispatching capabilities is to extend
-     * {@link EventDispatcher}. If this is impossible (that is, if the class is already extending another class), you
-     * can instead implement the {@link IEventDispatcher} interface, create an {@link EventDispatcher} member, and
-     * write simple hooks to route calls into the aggregated {@link EventDispatcher}.
-     *
-     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/IEventDispatcher.html
-     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-EventDispatcher
-     * @author Migrated by Jeongho Nam <http://samchon.org>
-     */
-    interface IEventDispatcher {
-        /**
-         * Checks whether the {@link EventDispatcher} object has any listeners registered for a specific type of event.
-         * This allows you to determine where an {@link EventDispatcher} object has altered handling of an event type
-         * in the event flow hierarchy. To determine whether a specific event type actually triggers an event listener,
-         * use {@link willTrigger willTrigger()}.
-         *
-         * The difference between {@link hasEventListener hasEventListener()} and {@link willTrigger willTrigger()} is
-         * that {@link hasEventListener} examines only the object to which it belongs, whereas {@link willTrigger}
-         * examines the entire event flow for the event specified by the type parameter.
-         *
-         * @param type The type of event.
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * Dispatches an event into the event flow.
-         *
-         * The event target is the {@link EventDispatcher} object upon which the {@link dispatchEvent dispatchEvent()}
-         * method is called.
-         *
-         * @param event The {@link BasicEvent} object that is dispatched into the event flow. If the event is being
-         *				redispatched, a clone of the event is created automatically. After an event is dispatched, its
-         *				target property cannot be changed, so you must create a new copy
-         *				of the event for redispatching to work.
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * Registers an event listener object with an {@link EventDispatcher} object so that the listener receives
-         * notification of an event. You can register event listeners on all nodes in the display list for a specific
-         * type of event, phase, and priority.
-         *
-         * After you successfully register an event listener, you cannot change its priority through additional calls
-         * to {@link addEventListener addEventListener()|} To change a listener's priority, you must first call
-         * {@link removeEventListener removeEventListener()}. Then you can register the listener again with the new
-         * priority level.
-         *
-         * Keep in mind that after the listener is registered, subsequent calls to {@link addEventListener} with a
-         * different type or useCapture value result in the creation of a separate listener registration. For example,
-         * if you first register a listener with useCapture set to true, it listens only during the capture phase. If
-         * you call {@link addEventListener} again using the same listener object, but with useCapture set to false,
-         * you have two separate listeners: one that listens during the capture phase and another that listens during
-         * the target and bubbling phases.
-         *
-         * You cannot register an event listener for only the target phase or the bubbling phase. Those phases are
-         * coupled during registration because bubbling applies only to the ancestors of the target node.
-         *
-         * If you no longer need an event listener, remove it by calling {@link removeEventListener}, or memory
-         * problems could result. Event listeners are not automatically removed from memory because the garbage
-         * collector does not remove the listener as long as the dispatching object exists (unless the
-         * useWeakReference parameter is set to true).
-         *
-         * Copying an {@link EventDispatcher} instance does not copy the event listeners attached to it. (If your n
-         * ewly created node needs an event listener, you must attach the listener after creating the node.) However,
-         * if you move an {@link EventDispatcher} instance, the event listeners attached to it move along with it.
-         *
-         * If the event listener is being registered on a node while an event is also being processed on this node,
-         * the event listener is not triggered during the current phase but may be triggered during a later phase in
-         * the event flow, such as the bubbling phase.
-         *
-         * If an event listener is removed from a node while an event is being processed on the node, it is still
-         * triggered by the current actions. After it is removed, the event listener is never invoked again (unless it
-         * is registered again for future processing).
-         *
-         * @param event The type of event.
-         * @param listener The listener function that processes the event.
-         *				 This function must accept an Event object as its only parameter and must return
-         *				 nothing.
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        /**
-         * Registers an event listener object with an {@link EventDispatcher} object so that the listener receives
-         * notification of an event. You can register event listeners on all nodes in the display list for a specific
-         * type of event, phase, and priority.
-         *
-         * After you successfully register an event listener, you cannot change its priority through additional calls
-         * to {@link addEventListener addEventListener()|} To change a listener's priority, you must first call
-         * {@link removeEventListener removeEventListener()}. Then you can register the listener again with the new
-         * priority level.
-         *
-         * Keep in mind that after the listener is registered, subsequent calls to {@link addEventListener} with a
-         * different type or useCapture value result in the creation of a separate listener registration. For example,
-         * if you first register a listener with useCapture set to true, it listens only during the capture phase. If
-         * you call {@link addEventListener} again using the same listener object, but with useCapture set to false,
-         * you have two separate listeners: one that listens during the capture phase and another that listens during
-         * the target and bubbling phases.
-         *
-         * You cannot register an event listener for only the target phase or the bubbling phase. Those phases are
-         * coupled during registration because bubbling applies only to the ancestors of the target node.
-         *
-         * If you no longer need an event listener, remove it by calling {@link removeEventListener}, or memory
-         * problems could result. Event listeners are not automatically removed from memory because the garbage
-         * collector does not remove the listener as long as the dispatching object exists (unless the
-         * useWeakReference parameter is set to true).
-         *
-         * Copying an {@link EventDispatcher} instance does not copy the event listeners attached to it. (If your n
-         * ewly created node needs an event listener, you must attach the listener after creating the node.) However,
-         * if you move an {@link EventDispatcher} instance, the event listeners attached to it move along with it.
-         *
-         * If the event listener is being registered on a node while an event is also being processed on this node,
-         * the event listener is not triggered during the current phase but may be triggered during a later phase in
-         * the event flow, such as the bubbling phase.
-         *
-         * If an event listener is removed from a node while an event is being processed on the node, it is still
-         * triggered by the current actions. After it is removed, the event listener is never invoked again (unless it
-         * is registered again for future processing).
-         *
-         * @param event The type of event.
-         * @param listener The listener function that processes the event.
-         *				 This function must accept an Event object as its only parameter and must return
-         *				 nothing.
-         * @param thisArg The object to be used as the **this** object.
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        /**
-         * Removes a listener from the {@link EventDispatcher} object. If there is no matching listener registered
-         * with the {@link EventDispatcher} object, a call to this method has no effect.
-         *
-         * @param type The type of event.
-         * @param listener The listener object to remove.
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        /**
-         * Removes a listener from the {@link EventDispatcher} object. If there is no matching listener registered
-         * with the {@link EventDispatcher} object, a call to this method has no effect.
-         *
-         * @param type The type of event.
-         * @param listener The listener object to remove.
-         * @param thisArg The object to be used as the **this** object.
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-    }
-    /**
-     * The {@link EventDispatcher} class is the base class for all classes that dispatch events. The
-     * {@link EventDispatcher} class implements the {@link IEventDispatcher} interface and is the base class for the
-     * {@link DisplayObject} class. The {@link EventDispatcher} class allows any object on the display list to be an
-     * event target and as such, to use the methods of the {@link IEventDispatcher} interface.
-     *
-     * The event target serves as the local point for how events flow through the display list hierarchy. When an
-     * event such as a mouse click or a key press occurs, an event object is dispatched into the event flow from the
-     * root of the display list. The event object makes a round-trip journey to the event target, which is
-     * conceptually divided into three phases: the capture phase includes the journey from the root to the last node
-     * before the event target's node; the target phase includes only the event target node; and the bubbling phase
-     * includes any subsequent nodes encountered on the return trip to the root of the display list.
-     *
-     * In general, the easiest way for a user-defined class to gain event dispatching capabilities is to extend
-     * {@link EventDispatcher}. If this is impossible (that is, if the class is already extending another class), you
-     * can instead implement the {@link IEventDispatcher} interface, create an {@link EventDispatcher} member, and
-     * write simple hooks to route calls into the aggregated {@link EventDispatcher}.
-     *
-     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/EventDispatcher.html
-     * @author Migrated by Jeongho Nam <http://samchon.org>
-     */
-    class EventDispatcher implements IEventDispatcher {
-        /**
-         * @hidden
-         */
-        private event_dispatcher_;
-        /**
-         * @hidden
-         */
-        private event_listeners_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from the origin event dispatcher.
-         *
-         * @param dispatcher The origin object who issuing events.
-         */
-        constructor(dispatcher: IEventDispatcher);
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-    }
-}
-declare namespace samchon.library {
-    /**
-     * The {@link FileReference} class provides a means to load and save files in browser level.
-     *
-     * The {@link FileReference} class provides a means to {@link load} and {@link save} files in browser level. A
-     * browser-system dialog box prompts the user to select a file to {@link load} or a location for {@link svae}. Each
-     * {@link FileReference} object refers to a single file on the user's disk and has properties that contain
-     * information about the file's size, type, name, creation date, modification date, and creator type (Macintosh only).
-     *
-     *
-     * FileReference instances are created in the following ways:
-     * <ul>
-     *	<li>
-     *		When you use the new operator with the {@link FileReference} constructor:
-     *		<code>let myFileReference: FileReference = new FileReference();</code>
-     *	</li>
-     *	<li>
-     *		When you call the {@link FileReferenceList.browse} method, which creates an array of {@link FileReference}
-     *		objects.
-     *	</li>
-     * </ul>
-     *
-     * During a load operation, all the properties of a {@link FileReference} object are populated by calls to the
-     * {@link FileReference.browse} or {@link FileReferenceList.browse} methods. During a save operation, the name
-     * property is populated when the select event is dispatched; all other properties are populated when the complete
-     * event is dispatched.
-     *
-     * The {@link browse browse()} method opens an browser-system dialog box that prompts the user to select a file
-     * for {@link load}. The {@link FileReference.browse} method lets the user select a single file; the
-     * {@link FileReferenceList.browse} method lets the user select multiple files. After a successful call to the
-     * {@link browse browse()} method, call the {@link FileReference.load} method to load one file at a time. The
-     * {@link FileReference.save} method prompts the user for a location to save the file and initiates downloading from
-     * a binary or string data.
-     *
-     * The {@link FileReference} and {@link FileReferenceList} classes do not let you set the default file location
-     * for the dialog box that the {@link browse} or {@link save} methods generate. The default location shown in the
-     * dialog box is the most recently browsed folder, if that location can be determined, or the desktop. The classes do
-     * not allow you to read from or write to the transferred file. They do not allow the browser that initiated the
-     * {@link load} or {@link save} to access the loaded or saved file or the file's location on the user's disk.
-     *
-     * @references http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReference.html
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class FileReference extends EventDispatcher {
-        /**
-         * @hidden
-         */
-        private file_;
-        /**
-         * @hidden
-         */
-        private data_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * The data from the loaded file after a successful call to the {@link load load()} method.
-         *
-         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
-         *
-         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         *
-         */
-        readonly data: any;
-        /**
-         * The name of the file on the local disk.
-         *
-         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
-         *
-         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         *
-         */
-        readonly name: string;
-        /**
-         * The filename extension.
-         *
-         * A file's extension is the part of the name following (and not including) the final dot (&quot;.&quot;). If
-         * there is no dot in the filename, the extension is <code>null</code>.
-         *
-         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
-         *
-         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         *
-         */
-        readonly extension: string;
-        /**
-         * The file type, metadata of the {@link extension}.
-         *
-         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
-         *
-         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         *
-         */
-        readonly type: string;
-        /**
-         * The size of the file on the local disk in bytes.
-         *
-         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
-         *
-         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         *
-         */
-        readonly size: number;
-        /**
-         * The date that the file on the local disk was last modified.
-         *
-         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
-         *
-         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         *
-         */
-        readonly modificationDate: Date;
-        /**
-         * Displays a file-browsing dialog box that lets the user select a file to upload. The dialog box is native
-         * to the user's browser system. The user can select a file on the local computer or from other systems, for
-         * example, through a UNC path on Windows.
-         *
-         * When you call this method and the user successfully selects a file, the properties of this
-         * {@link FileReference} object are populated with the properties of that file. Each subsequent time that the
-         * {@link FileReference.browse} method is called, the {@link FileReference} object's properties are reset to
-         * the file that the user selects in the dialog box. Only one {@link browse browse()} can be performed at a time
-         * (because only one dialog box can be invoked at a time).
-         *
-         * Using the *typeFilter parameter*, you can determine which files the dialog box displays.
-         *
-         * @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
-         *					 If you omit this parameter, all files are displayed.
-         */
-        browse(...typeFilter: string[]): void;
-        /**
-         * Starts the load of a local file selected by a user.
-         *
-         * You must call the {@link FileReference.browse} or {@link FileReferenceList.browse} method before you call
-         * the {@link load load()} method.
-         *
-         * Listeners receive events to indicate the progress, success, or failure of the load. Although you can use
-         * the {@link FileReferenceList} object to let users select multiple files to load, you must {@link load} the
-         * {@link FileReferenceList files} one by one. To {@link load} the files one by one, iterate through the
-         * {@link FileReferenceList.fileList} array of {@link FileReference} objects.
-         *
-         * If the file finishes loading successfully, its contents are stored in the {@link data} property.
-         */
-        load(): void;
-        /**
-         * Save a file to local filesystem.
-         *
-         * {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
-         * However, the plan, future's {@link FileReference} will follow such rule:
-         *
-         * Opens a dialog box that lets the user save a file to the local filesystem.
-         *
-         * The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
-         * filename and select a location on the local computer to save the file. When the user selects a location and
-         * confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
-         * to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
-         * and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
-         * open, progress, and complete.
-         *
-         * When the file is saved successfully, the properties of the {@link FileReference} object are populated with
-         * the properties of the local file. The complete event is dispatched if the save is successful.
-         *
-         * Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
-         * dialog box can be invoked at a time).
-         *
-         * @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
-         * @param fileName File name to be saved.
-         */
-        save(data: string, fileName: string): void;
-        /**
-         * Save a file to local filesystem.
-         *
-         * {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
-         * However, the plan, future's {@link FileReference} will follow such rule:
-         *
-         * Opens a dialog box that lets the user save a file to the local filesystem.
-         *
-         * The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
-         * filename and select a location on the local computer to save the file. When the user selects a location and
-         * confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
-         * to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
-         * and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
-         * open, progress, and complete.
-         *
-         * When the file is saved successfully, the properties of the {@link FileReference} object are populated with
-         * the properties of the local file. The complete event is dispatched if the save is successful.
-         *
-         * Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
-         * dialog box can be invoked at a time).
-         *
-         * @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
-         * @param fileName File name to be saved.
-         */
-        static save(data: string, fileName: string): void;
-    }
-    /**
-     * The {@link FileReferenceList} class provides a means to let users select one or more files for
-     * {@link FileReference.load loading}. A {@link FileReferenceList} object represents a group of one or more local
-     * files on the user's disk as an array of {@link FileReference} objects. For detailed information and important
-     * considerations about {@link FileReference} objects and the FileReference class, which you use with
-     * {@link FileReferenceList}, see the {@link FileReference} class.
-     *
-     * To work with the {@link FileReferenceList} class:
-     * <ul>
-     *	<li> Instantiate the class: <code>var myFileRef = new FileReferenceList();</code> </li>
-     *	<li>
-     *		Call the {@link FileReferenceList.browse} method, which opens a dialog box that lets the user select one or
-     *		more files for upload: <code>myFileRef.browse();</code>
-     *	</li>
-     *	<li>
-     *		After the {@link browse browse()} method is called successfully, the {@link fileList} property of the
-     *		{@link FileReferenceList} object is populated with an array of {@link FileReference} objects.
-     *	</li>
-     *	<li> Call {@link FileReference.load} on each element in the {@link fileList} array. </li>
-     * </ul>
-     *
-     * The {@link FileReferenceList} class includes a {@link browse browse()} method and a {@link fileList} property
-     * for working with multiple files.
-     *
-     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReferenceList.html
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class FileReferenceList extends EventDispatcher {
-        /**
-         * @hidden
-         */
-        file_list: std.Vector<FileReference>;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * An array of {@link FileReference} objects.
-         *
-         * When the {@link FileReferenceList.browse} method is called and the user has selected one or more files
-         * from the dialog box that the {@link browse browse()} method opens, this property is populated with an array of
-         * {@link FileReference} objects, each of which represents the files the user selected.
-         *
-         * The {@link fileList} property is populated anew each time {@link browse browse()} is called on that
-         * {@link FileReferenceList} object.
-         */
-        readonly fileList: std.Vector<FileReference>;
-        /**
-         * Displays a file-browsing dialog box that lets the user select one or more local files to upload. The
-         * dialog box is native to the user's browser system.
-         *
-         * When you call this method and the user successfully selects files, the {@link fileList} property of this
-         * {@link FileReferenceList} object is populated with an array of {@link FileReference} objects, one for each
-         * file that the user selects. Each subsequent time that the {@link FileReferenceList.browse} method is called,
-         * the {@link FileReferenceList.fileList} property is reset to the file(s) that the user selects in the dialog
-         * box.
-         *
-         * Using the *typeFilter* parameter, you can determine which files the dialog box displays.
-         *
-         * Only one {@link FileReference.browse}, {@link FileReference.load}, or {@link FileReferenceList.browse}
-         * session can be performed at a time on a {@link FileReferenceList} object (because only one dialog box can be
-         * opened at a time).
-         *
-         * @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
-         *					 If you omit this parameter, all files are displayed.
-         */
-        browse(...typeFilter: string[]): void;
-    }
-}
-declare namespace samchon.library {
-    /**
-     * A genetic algorithm class.
-     *
-     * In the field of artificial intelligence, a genetic algorithm (GA) is a search heuristic that mimics the
-     * process of natural selection. This heuristic (also sometimes called a metaheuristic) is routinely used to generate
-     * useful solutions to optimization and search problems.
-     *
-     * Genetic algorithms belong to the larger class of evolutionary algorithms (EA), which generate solutions to
-     * optimization problems using techniques inspired by natural evolution, such as inheritance, {@link mutate mutation},
-     * {@link selection}, and {@link crossover}.
-     *
-     * @reference https://en.wikipedia.org/wiki/Genetic_algorithm
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class GeneticAlgorithm {
-        /**
-         * Whether each element (Gene) is unique in their GeneArray.
-         */
-        private unique_;
-        /**
-         * Rate of mutation.
-         *
-         * The {@link mutation_rate} determines the percentage of occurence of mutation in GeneArray.
-         *
-         * <ul>
-         *	<li> When {@link mutation_rate} is too high, it is hard to ancitipate studying on genetic algorithm. </li>
-         *	<li>
-         *		When {@link mutation_rate} is too low and initial set of genes (GeneArray) is far away from optimal, the
-         *		evolution tends to wandering outside of he optimal.
-         *	</li>
-         * </ul>
-         */
-        private mutation_rate_;
-        /**
-         * Number of tournaments in selection.
-         */
-        private tournament_;
-        /**
-         * Initialization Constructor.
-         *
-         * @param unique Whether each Gene is unique in their GeneArray.
-         * @param mutation_rate Rate of mutation.
-         * @param tournament Number of tournaments in selection.
-         */
-        constructor(unique?: boolean, mutation_rate?: number, tournament?: number);
-        /**
-         * Evolove *GeneArray*.
-         *
-         * Convenient method accessing to {@link evolvePopulation evolvePopulation()}.
-         *
-         * @param individual An initial set of genes; sequence listing.
-         * @param population Size of population in a generation.
-         * @param generation Size of generation in evolution.
-         * @param compare A comparison function returns whether left gene is more optimal.
-         *
-         * @return An evolved *GeneArray*, optimally.
-         *
-         * @see {@link GAPopulation.compare}
-         */
-        evolveGeneArray<T, GeneArray extends std.base.IArrayContainer<T>>(individual: GeneArray, population: number, generation: number, compare?: (left: T, right: T) => boolean): GeneArray;
-        /**
-         * Evolve *population*, a mass of *GeneArraies*.
-         *
-         * @param population An initial population.
-         * @param compare A comparison function returns whether left gene is more optimal.
-         *
-         * @return An evolved population.
-         *
-         * @see {@link GAPopulation.compare}
-         */
-        evolvePopulation<T, GeneArray extends std.base.IArrayContainer<T>>(population: GAPopulation<T, GeneArray>, compare?: (left: T, right: T) => boolean): GAPopulation<T, GeneArray>;
-        /**
-         * Select the best GeneArray in *population* from tournament.
-         *
-         * {@link selection Selection} is the stage of a genetic algorithm in which individual genomes are chosen
-         * from a population for later breeding (using {@linlk crossover} operator). A generic {@link selection}
-         * procedure may be implemented as follows:
-         *
-         * <ol>
-         *	<li>
-         *		The fitness function is evaluated for each individual, providing fitness values, which are then
-         *		normalized. ization means dividing the fitness value of each individual by the sum of all fitness
-         *		values, so that the sum of all resulting fitness values equals 1.
-         *	</li>
-         *	<li> The population is sorted by descending fitness values. </li>
-         *	<li>
-         *		Accumulated normalized fitness values are computed (the accumulated fitness value of an individual is the
-         *		sum of its own fitness value plus the fitness values of all the previous individuals). The accumulated
-         *		fitness of the last individual should be 1 (otherwise something went wrong in the normalization step).
-         *	</li>
-         *	<li> A random number R between 0 and 1 is chosen. </li>
-         *	<li> The selected individual is the first one whose accumulated normalized value is greater than R. </li>
-         * </ol>
-         *
-         * @param population The target of tournament.
-         * @return The best genes derived by the tournament.
-         *
-         * @reference https://en.wikipedia.org/wiki/Selection_(genetic_algorithm)
-         */
-        private selection<T, GeneArray>(population);
-        /**
-         * Create a new GeneArray by crossing over two *GeneArray*(s).
-         *
-         * {@link crossover} is a genetic operator used to vary the programming of a chromosome or chromosomes from
-         * one generation to the next. It is analogous to reproduction and biological crossover, upon which genetic
-         * algorithms are based.
-         *
-         * {@link crossover Cross over} is a process of taking more than one parent solutions and producing a child
-         * solution from them. There are methods for selection of the chromosomes.
-         *
-         * @param parent1 A parent sequence listing
-         * @param parent2 A parent sequence listing
-         *
-         * @reference https://en.wikipedia.org/wiki/Crossover_(genetic_algorithm)
-         */
-        private crossover<T, GeneArray>(parent1, parent2);
-        /**
-         * Cause a mutation on the *GeneArray*.
-         *
-         * {@link mutate Mutation} is a genetic operator used to maintain genetic diversity from one generation of a
-         * population of genetic algorithm chromosomes to the next. It is analogous to biological mutation.
-         *
-         * {@link mutate Mutation} alters one or more gene values in a chromosome from its initial state. In
-         * {@link mutate mutation}, the solution may change entirely from the previous solution. Hence GA can come to
-         * better solution by using {@link mutate mutation}.
-         *
-         * {@link mutate Mutation} occurs during evolution according to a user-definable mutation probability. This
-         * probability should be set low. If it is set too high, the search will turn into a primitive random search.
-         *
-         * <h4> Note </h4>
-         * Muttion is pursuing diversity. Mutation is useful for avoiding the following problem.
-         *
-         * When initial set of genes(GeneArray) is far away from optimail, without mutation (only with selection and
-         * crossover), the genetic algorithm has a tend to wandering outside of the optimal.
-         *
-         * Genes in the GeneArray will be swapped following percentage of the {@link mutation_rate}.
-         *
-         * @param individual A container of genes to mutate
-         *
-         * @reference https://en.wikipedia.org/wiki/Mutation_(genetic_algorithm)
-         * @see {@link mutation_rate}
-         */
-        private mutate<T, GeneArray>(individual);
-    }
-    /**
-     * A population in a generation.
-     *
-     * {@link GAPopulation} is a class representing population of candidate genes (sequence listing) having an array
-     * of GeneArray as a member. {@link GAPopulation} also manages initial set of genes and handles fitting test direclty
-     * by the method {@link fitTest fitTest()}.
-     *
-     * The success of evolution of genetic algorithm is depend on the {@link GAPopulation}'s initial set and fitting
-     * test. (*GeneArray* and {@link compare}.)
-     *
-     * <h4> Warning </h4>
-     * Be careful for the mistakes of direction or position of the {@link compare}.
-     * Most of logical errors failed to access optimal solution are occured from those mistakes.
-     *
-     * @param <T> Type of gene elements.
-     * @param <GeneArray> An array containing genes as elments; sequnce listing.
-     *
-     * @author Jeongho Nam <http://samcho.org>
-     */
-    class GAPopulation<T, GeneArray extends std.base.IArrayContainer<T>> {
-        /**
-         * Genes representing the population.
-         */
-        private children_;
-        /**
-         * A comparison function returns whether left gene is more optimal, greater.
-         *
-         * Default value of this {@link compare} is {@link std.greater}. It means to compare two array
-         * (GeneArray must be a type of {@link std.base.IArrayContainer}). Thus, you've to keep follwing rule.
-         *
-         * <ul>
-         *	<li> GeneArray is implemented from {@link std.base.IArrayContainer}. </li>
-         *	<ul>
-         *		<li> {@link std.Vector} </li>
-         *		<li> {@link std.Deque} </li>
-         *	</ul>
-         *	<li> GeneArray has custom <code>public less(obj: T): boolean;</code> function. </li>
-         * </ul>
-         *
-         * If you don't want to follow the rule or want a custom comparison function, you have to realize a
-         * comparison function.
-         */
-        private compare_;
-        /**
-         * Private constructor with population.
-         *
-         * Private constructor of GAPopulation does not create {@link children}. (candidate genes) but only assigns
-         * *null* repeatedly following the *population size*.
-         *
-         * This private constructor is designed only for {@link GeneticAlgorithm}. Don't create {@link GAPopulation}
-         * with this constructor, by yourself.
-         *
-         * @param size Size of the population.
-         */
-        constructor(size: number);
-        /**
-         * Construct from a {@link GeneArray} and *size of the population*.
-         *
-         * This public constructor creates *GeneArray(s)* as population (size) having shuffled genes which are
-         * came from the initial set of genes (*geneArray*). It uses {@link std.greater} as default comparison function.
-         *
-         *
-         * @param geneArray An initial sequence listing.
-         * @param size The size of population to have as children.
-         */
-        constructor(geneArray: GeneArray, size: number);
-        /**
-         * Constructor from a GeneArray, size of the poluation and custom comparison function.
-         *
-         * This public constructor creates *GeneArray(s)* as population (size) having shuffled genes which are
-         * came from the initial set of genes (*geneArray*). The *compare* is used for comparison function.
-         *
-         *
-         * @param geneArray An initial sequence listing.
-         * @param size The size of population to have as children.
-         * @param compare A comparison function returns whether left gene is more optimal.
-         */
-        constructor(geneArray: GeneArray, size: number, compare: (left: GeneArray, right: GeneArray) => boolean);
-        children(): std.Vector<GeneArray>;
-        /**
-         * Test fitness of each *GeneArray* in the {@link population}.
-         *
-         * @return The best *GeneArray* in the {@link population}.
-         */
-        fitTest(): GeneArray;
-        /**
-         * @hidden
-         */
-        private clone(obj);
-    }
-}
-declare namespace samchon.library {
-    /**
-     * A utility class supporting static methods of string.
-     *
-     * The {@link StringUtil} utility class is an all-static class with methods for working with string objects.
-     * You do not create instances of {@link StringUtil}; instead you call methods such as the
-     * ```StringUtil.substitute()``` method.
-     *
-     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/mx/utils/StringUtil.html
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class StringUtil {
-        /**
-         * Generate a substring.
-         *
-         * Extracts a substring consisting of the characters from specified start to end.
-         * It's same with str.substring( ? = (str.find(start) + start.size()), str.find(end, ?) )
-         *
-         * ```typescript
-         * let str: string = StringUtil.between("ABCD(EFGH)IJK", "(", ")");
-         * console.log(str); // PRINTS "EFGH"
-         * ```
-         *
-         * - If start is not specified, extracts from begin of the string to end. </li>
-         * - If end is not specified, extracts from start to end of the string. </li>
-         * - If start and end are all omitted, returns str, itself. </li>
-         *
-         * @param str Target string to be applied between.
-         * @param start A string for separating substring at the front.
-         * @param end A string for separating substring at the end.
-         *
-         * @return substring by specified terms.
-         */
-        static between(str: string, start?: string, end?: string): string;
-        /**
-         * Fetch substrings.
-         *
-         * Splits a string into an array of substrings dividing by specified delimeters of start and end.
-         * It's the array of substrings adjusted the between.
-         *
-         * <ul>
-         *	<li> If startStr is omitted, it's same with the split by endStr not having last item. </li>
-         *	<li> If endStr is omitted, it's same with the split by startStr not having first item. </li>
-         *	<li> If startStr and endStar are all omitted, returns *str*. </li>
-         * </ul>
-         *
-         * @param str Target string to split by between.
-         * @param start A string for separating substring at the front.
-         *				If omitted, it's same with split(end) not having last item.
-         * @param end A string for separating substring at the end.
-         *			  If omitted, it's same with split(start) not having first item.
-         * @return An array of substrings.
-         */
-        static betweens(str: string, start?: string, end?: string): Array<string>;
-        /**
-         * An array containing whitespaces.
-         */
-        private static SPACE_ARRAY;
-        /**
-         * Remove all designated characters from the beginning and end of the specified string.
-         *
-         * @param str The string whose designated characters should be trimmed.
-         * @param args Designated character(s).
-         *
-         * @return Updated string where designated characters was removed from the beginning and end.
-         */
-        static trim(str: string, ...args: string[]): string;
-        /**
-         * Remove all designated characters from the beginning of the specified string.
-         *
-         * @param str The string should be trimmed.
-         * @param delims Designated character(s).
-         *
-         * @return Updated string where designated characters was removed from the beginning
-         */
-        static ltrim(str: string, ...args: string[]): string;
-        /**
-         * Remove all designated characters from the end of the specified string.
-         *
-         * @param str The string should be trimmed.
-         * @param delims Designated character(s).
-         *
-         * @return Updated string where designated characters was removed from the end.
-         */
-        static rtrim(str: string, ...args: string[]): string;
-        /**
-         * Substitute <code>{n}</code> tokens within the specified string.
-         *
-         * @param format The string to make substitutions in. This string can contain special tokens of the form
-         *				 <code>{n}</code>, where <code>n</code> is a zero based index, that will be replaced with the
-         *				 additional parameters found at that index if specified.
-         * @param args Additional parameters that can be substituted in the *format* parameter at each
-         *			   <code>{n}</code> location, where <code>n</code> is an integer (zero based) index value into
-         *			   the array of values specified.
-         *
-         * @return New string with all of the <code>{n}</code> tokens replaced with the respective arguments specified.
-         */
-        static substitute(format: string, ...args: any[]): string;
-        /**
-         * Returns a string specified word is replaced.
-         *
-         * @param str Target string to replace
-         * @param before Specific word you want to be replaced
-         * @param after Specific word you want to replace
-         *
-         * @return A string specified word is replaced
-         */
-        static replaceAll(str: string, before: string, after: string): string;
-        /**
-         * Returns a string specified words are replaced.
-         *
-         * @param str Target string to replace
-         * @param pairs A specific word's pairs you want to replace and to be replaced
-         *
-         * @return A string specified words are replaced
-         */
-        static replaceAll(str: string, ...pairs: std.Pair<string, string>[]): string;
-        /**
-         * Replace all HTML spaces to a literal space.
-         *
-         * @param str Target string to replace.
-         */
-        static removeHTMLSpaces(str: string): string;
-        /**
-         * Repeat a string.
-         *
-         * Returns a string consisting of a specified string concatenated with itself a specified number of times.
-         *
-         * @param str The string to be repeated.
-         * @param n The repeat count.
-         *
-         * @return The repeated string.
-         */
-        static repeat(str: string, n: number): string;
-        /**
-         * Number to formatted string with &quot;,&quot; sign.
-         *
-         * Returns a string converted from the number rounded off from specified precision with &quot;,&quot; symbols.
-         *
-         * @param val A number wants to convert to string.
-         * @param precision Target precision of round off.
-         *
-         * @return A string who represents the number with roundoff and &quot;,&quot; symbols.
-         */
-        static numberFormat(val: number, precision?: number): string;
-        static percentFormat(val: number, precision?: number): string;
-    }
-}
-declare namespace samchon.library {
-    /**
-     * URLVariables class is for representing variables of HTTP.
-     *
-     * {@link URLVariables} class allows you to transfer variables between an application and server.
-     *
-     * When transfering, {@link URLVariables} will be converted to a *URI* string.
-     * - URI: Uniform Resource Identifier
-     *
-     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/URLVariables.html
-     * @author Migrated by Jeongho Nam <http://samchon.org>
-     */
-    class URLVariables extends std.HashMap<string, string> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from a URL-encoded string.
-         *
-         * The {@link decode decode()} method is automatically called to convert the string to properties of the {@link URLVariables} object.
-         *
-         * @param str A URL-encoded string containing name/value pairs.
-         */
-        constructor(str: string);
-        /**
-         * Converts the variable string to properties of the specified URLVariables object.
-         *
-         * @param str A URL-encoded query string containing name/value pairs.
-         */
-        decode(str: string): void;
-        /**
-         * Returns a string containing all enumerable variables, in the MIME content encoding application/x-www-form-urlencoded.
-         */
-        toString(): string;
-    }
-}
-declare namespace samchon.library {
-    /**
-     * A tree-structured XML object.
-     *
-     * The {@link XML| class contains methods and properties for working with XML objects. The {@link XML} class (along
-     * with the {@link XMLList}) implements the powerful XML-handling standards defined in ECMAScript for XML (E4X)
-     * specification (ECMA-357 edition 2).
-     *
-     * An XML object, it is composed with three members; {@link getTag tag}, {@link getProperty properties} and
-     * {@link getValue value}. As you know, XML is a tree structured data expression method. The tree-stucture;
-     * {@link XML} class realizes it by extending ```std.HashMap<string, XMLList>```. Child {@link XML} objects are
-     * contained in the matched {@link XMLList} object being grouped by their {@link getTag tag name}. The
-     * {@link XMLList} objects, they're stored in the {@link std.HashMap} ({@link XML} itself) with its **key**; common
-     * {@link getTag tag name} of children {@link XML} objects.
-     *
-     * ```typescript
-     * class XML extends std.HashMap<string, XMLList>
-     * {
-     *	private tag_: string;
-     *	private properties_: std.HashMap<string, string>;
-     *	private value_: string;
-     * }
-     * ```
-     *
-     * ```xml
-     * <?xml version="1.0" ?>
-     * <TAG property_name={property_value}>
-     *	<!--
-     *		The cchild XML objects with "CHILD_TAG", They're contained in an XMLList object.
-     *		The XMLList object, it is stored in std.HashMap (XML class itself) with its key "CHILD_TAG"
-     *	-->
-     *	<CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
-     *  <CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
-     *	<CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
-     *
-     *	<!--
-     *		The child XML object named "ANOTHER_TAG", it also belonged to an XMLList ojbect.
-     *		And the XMLList is also being contained in the std.HashMap with its key "ANOTHER_TAG"
-     *	-->
-     *	<ANOTHER_TAG />
-     * </TAG>
-     * ```
-     *
-     * Use the {@link toString toString()} method to return a string representation of the {@link XML} object regardless
-     * of whether the {@link XML} object has simple content or complex content.
-     *
-     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/XML.html
-     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-XML
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class XML extends std.HashMap<string, XMLList> {
-        /**
-         * @hidden
-         */
-        private tag_;
-        /**
-         * @hidden
-         */
-        private value_;
-        /**
-         * @hidden
-         */
-        private property_map_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from string.
-         *
-         * Creates {@link XML} object by parsing a string who represents xml structure.
-         *
-         * @param str A string represents XML structure.
-         */
-        constructor(str: string);
-        /**
-         * @hidden
-         */
-        private parse(str);
-        /**
-         * @hidden
-         */
-        private parse_tag(str);
-        /**
-         * @hidden
-         */
-        private parse_properties(str);
-        /**
-         * @hidden
-         */
-        private parse_value(str);
-        /**
-         * @hidden
-         */
-        private parse_children(str);
-        /**
-         * Get tag.
-         *
-         * ```xml
-         * <TAG property_key={property_value}>{value}</TAG>
-         * ```
-         *
-         * @return tag.
-         */
-        getTag(): string;
-        /**
-         * Get value.
-         *
-         * ```xml
-         * <tag property_key={property_value}>{VALUE}</tag>
-         * ```
-         *
-         * @return value.
-         */
-        getValue(): string;
-        /**
-         * Get iterator to property element.
-         *
-         * Searches the {@link getPropertyMap properties} for an element with a identifier equivalent to <i>key</i>
-         * and returns an iterator to it if found, otherwise it returns an iterator to {@link HashMap.end end()}.
-         *
-         * <p> Two keys are considered equivalent if the properties' comparison object returns false reflexively
-         * (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * Another member function, {@link hasProperty hasProperty()} can be used to just check whether a particular
-         * <i>key</i> exists.
-         *
-         * ```xml
-         * <tag PROPERTY_KEY={property_value}>{value}</tag>
-         * ```
-         *
-         * @param key Key to be searched for
-         * @return An iterator to the element, if an element with specified <i>key</i> is found, or
-         *		   {@link end HashMap.end()} otherwise.
-         */
-        findProperty(key: string): std.MapIterator<string, string>;
-        /**
-         * Test whether a property exists.
-         *
-         * ```xml
-         * <tag PROPERTY_KEY={property_value}>{value}</tag>
-         * ```
-         *
-         * @return Whether a property has the *key* exists or not.
-         */
-        hasProperty(key: string): boolean;
-        /**
-         * Get property.
-         *
-         * Get property by its *key*, property name. If the matched *key* does not exist, then exception
-         * {@link std.OutOfRange} is thrown. Thus, it would better to test whether the *key* exits or not by calling the
-         * {@link hasProperty hasProperty()} method before calling this {@link getProperty getProperty()}.
-         *
-         * This method can be substituted by {@link getPropertyMap getPropertyMap()} such below:
-         * - ```getPropertyMap().get(key, value);```
-         * - ```getPropertyMap().find(key).second;```
-         *
-         * ```xml
-         * <tag PROPERTY_KEY={PROPERTY_VALUE}>{value}</tag>
-         * ```
-         *
-         * @return Value of the matched property.
-         */
-        getProperty(key: string): string;
-        /**
-         * Get property map.
-         *
-         * ```xml
-         * <tag PROPERTY_KEY1={PROPERTY_VALUE1}
-         *		PROPERTY_KEY2={PROPERTY_VALUE2}
-         *		PROPERTY_KEY3={PROPERTY_VALUE3}>{value}</tag>
-         * ```
-         *
-         * @return {@link HashMap} containing properties' keys and values.
-         */
-        getPropertyMap(): std.HashMap<string, string>;
-        /**
-         * Set tag.
-         *
-         * Set tag name, identifier of this {@link XML} object.
-         *
-         * If this {@link XML} object is belonged to, a child of, an {@link XMLList} and its related {@link XML} objects,
-         * then calling this {@link setTag setTag()} method direclty is not recommended. Erase this {@link XML} object
-         * from parent objects and insert this object again.
-         *
-         * ```xml
-         * <TAG property_key={property_value}>{value}</TAG>
-         * ```
-         *
-         * @param val To be new {@link getTag tag}.
-         */
-        setTag(val: string): void;
-        /**
-         * Set value.
-         *
-         * ```xml
-         * <tag property_key={property_value}>{VALUE}</tag>
-         * ```
-         *
-         * @param val To be new {@link getValue value}.
-         */
-        setValue(val: string): void;
-        /**
-         * Set property.
-         *
-         * Set a property *value* with its *key*. If the *key* already exists, then the *value* will be overwritten to
-         * the property. Otherwise the *key* is not exist yet, then insert the *key* and *value* {@link Pair pair} to
-         * {@link getPropertyMao property map}.
-         *
-         * This method can be substituted by {@link getPropertyMap getPropertyMap()} such below:
-         * - ```getPropertyMap().set(key, value);```
-         * - ```getPropertyMap().emplace(key, value);```
-         * - ```getPropertyMap().insert([key, value]);```
-         * - ```getPropertyMap().insert(std.make_pair(key, value));```
-         *
-         * ```xml
-         * <tag PROPERTY_KEY={PROPERTY_VALUE}>{value}</tag>
-         * ```
-         *
-         * @param key Key, identifier of property to be newly inserted.
-         * @param value Value of new property to be newly inserted.
-         */
-        setProperty(key: string, value: string): void;
-        /**
-         * Erase property.
-         *
-         * Erases a property by its *key*, property name. If the matched *key* does not exist, then exception
-         * {@link std.OutOfRange} is thrown. Thus, it would better to test whether the *key* exits or not by calling the
-         * {@link hasProperty hasProperty()} method before calling this {@link eraseProperty eraseProperty()}.
-         *
-         * This method can be substituted by ``getPropertyMap().erase(key)````.
-         *
-         * ```xml
-         * <tag PROPERTY_KEY={property_value}>{value}</tag>
-         * ```
-         *
-         * @param key Key of the property to erase
-         * @throw {@link std.OutOfRange}
-         */
-        eraseProperty(key: string): void;
-        /**
-         * @hidden
-         */
-        push(...args: std.Pair<string, XMLList>[]): number;
-        /**
-         * @hidden
-         */
-        push(...args: [string, XMLList][]): number;
-        push(...xmls: XML[]): number;
-        push(...xmlLists: XMLList[]): number;
-        /**
-         * Add all properties from other {@link XML} object.
-         *
-         * All the properties in the *obj* are copied to this {@link XML} object. If this {@link XML} object has same
-         * property key in the *obj*, then value of the property will be replaced to *obj*'s own. If you don't want to
-         * overwrite properties with same key, then use {@link getPropertyMap getPropertyMap()} method.
-         *
-         * ```typescript
-         * let x: library.XML;
-         * let y: library.XML;
-         *
-         * x.addAllProperties(y); // duplicated key exists, then overwrites
-         * x.getPropertyMap().insert(y.getPropertyMap().begin(), y.getPropertyMap().end());
-         *	// ducpliated key, then ignores. only non-duplicateds are copied.
-         * ```
-         *
-         * ```xml
-         * <tag PROPERTY_KEY1={property_value1}
-         *		PROPERTY_KEY2={property_value2}
-         *		PROPERTY_KEY3={property_value3}>{value}</tag>
-         * ```
-         *
-         * @param obj Target {@link XML} object to copy properties.
-         */
-        insertAllProperties(obj: XML): void;
-        /**
-         * Clear properties.
-         *
-         * Remove all properties. It's same with calling ```getPropertyMap().clear()```.
-         *
-         * ```xml
-         * <tag PROPERTY_KEY1={property_value1}
-         *		PROPERTY_KEY2={property_value2}
-         *		PROPERTY_KEY3={property_value3}>{value}</tag>
-         * ```
-         */
-        clearProperties(): void;
-        /**
-         * @hidden
-         */
-        private compute_min_index(...args);
-        /**
-         * @hidden
-         */
-        private decode_value(str);
-        /**
-         * @hidden
-         */
-        private encode_value(str);
-        /**
-         * @hidden
-         */
-        private decode_property(str);
-        /**
-         * @hidden
-         */
-        private encode_property(str);
-        /**
-         * {@link XML} object to xml string.
-         *
-         * Returns a string representation of the {@link XML} object.
-         *
-         * @param tab Number of tabs to spacing.
-         * @return The string representation of the {@link XML} object.
-         */
-        toString(tab?: number): string;
-    }
-}
-declare namespace samchon.library {
-    /**
-     * List of {@link XML} objects with same tag.
-     *
-     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/XMLList.html
-     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-XML
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class XMLList extends std.Deque<XML> {
-        /**
-         * Get tag.
-         */
-        getTag(): string;
-        /**
-         * {@link XMLList XML objects} to string.
-         *
-         * Returns a string representation of the {@link XMLList XML objects}.
-         *
-         * @param tab Number of tabs to spacing.
-         * @return The string representation of the {@link XMLList XML objects}.
-         */
-        toString(level?: number): string;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An interface of entity.
-     *
-     * Entity is a class for standardization of expression method using on network I/O by XML. If
-     * Invoke is a standard message protocol of Samchon Framework which must be kept, Entity is a
-     * recommended semi-protocol of message for expressing a data class. Following the semi-protocol
-     * Entity is not imposed but encouraged.
-     *
-     * As we could get advantages from standardization of message for network I/O with Invoke,
-     * we can get additional advantage from standardizing expression method of data class with Entity.
-     * We do not need to know a part of network communication. Thus, with the Entity, we can only
-     * concentrate on entity's own logics and relationships between another entities. Entity does not
-     * need to how network communications are being done.
-     *
-     * I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
-     * protocol for network I/O but not a essential protocol must be kept. The expression method of
-     * Entity, using on network I/O, is expressed by XML string.
-     *
-     * If your own network system has a critical performance issue on communication data class,
-     * it would be better to using binary communication (with ByteArray).
-     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray).
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IEntity {
-        /**
-         * Construct data of the Entity from a XML object.
-         *
-         * Overrides the construct() method and fetch data of member variables from the XML.
-         *
-         * By recommended guidance, data representing member variables are contained in properties
-         * of the put XML object.
-         *
-         * @param xml An xml used to contruct data of entity.
-         */
-        construct(xml: library.XML): void;
-        /**
-         * Get a key that can identify the Entity uniquely.
-         *
-         * If identifier of the Entity is not atomic value, returns a paired or tuple object
-         * that can represents the composite identifier.
-         *
-         * <code>
-         * class Point extends Entity
-         * {
-         *     private x: number;
-         *     private y: number;
-         *
-         *     public key(): std.Pair<number, number>
-         *     {
-         *         return std.make_pair(this.x, this.y);
-         *     }
-         * }
-         * </code>
-         */
-        key(): any;
-        /**
-         * A tag name when represented by XML.
-         *
-         * <code> <TAG {...properties} /> </code>
-         */
-        TAG(): string;
-        /**
-         * Get a XML object represents the Entity.
-         *
-         * A member variable (not object, but atomic value like number, string or date) is categorized
-         * as a property within the framework of entity side. Thus, when overriding a toXML() method and
-         * archiving member variables to an XML object to return, puts each variable to be a property
-         * belongs to only a XML object.
-         *
-         * Don't archive the member variable of atomic value to XML::value causing enormouse creation
-         * of XML objects to number of member variables. An Entity must be represented by only a XML
-         * instance (tag).
-         *
-         * <h4> Standard Usage. </h4>
-         * <code>
-         * <memberList>
-         *	<member id='jhnam88' name='Jeongho Nam' birthdate='1988-03-11' />
-         *	<member id='master' name='Administartor' birthdate='2011-07-28' />
-         * </memberList>
-         * </code>
-         *
-         * <h4> Non-standard usage abusing value. </h4>
-         * <code>
-         * <member>
-         *	<id>jhnam88</id>
-         *	<name>Jeongho Nam</name>
-         *	<birthdate>1988-03-11</birthdate>
-         * </member>
-         * <member>
-         *	<id>master</id>
-         *	<name>Administartor</name>
-         *	<birthdate>2011-07-28</birthdate>
-         * </member>
-         * </code>
-         *
-         * @return An XML object representing the Entity.
-         */
-        toXML(): library.XML;
-    }
-    /**
-     * @hidden
-     */
-    namespace IEntity {
-        function construct(entity: IEntity, xml: library.XML, ...prohibited_names: string[]): void;
-        function toXML(entity: IEntity, ...prohibited_names: string[]): library.XML;
-    }
-    /**
-     * An entity, a standard data class.
-     *
-     * Entity is a class for standardization of expression method using on network I/O by XML. If
-     * Invoke is a standard message protocol of Samchon Framework which must be kept, Entity is a
-     * recommended semi-protocol of message for expressing a data class. Following the semi-protocol
-     * Entity is not imposed but encouraged.
-     *
-     * As we could get advantages from standardization of message for network I/O with Invoke,
-     * we can get additional advantage from standardizing expression method of data class with Entity.
-     * We do not need to know a part of network communication. Thus, with the Entity, we can only
-     * concentrate on entity's own logics and relationships between another entities. Entity does not
-     * need to how network communications are being done.
-     *
-     * I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
-     * protocol for network I/O but not a essential protocol must be kept. The expression method of
-     * Entity, using on network I/O, is expressed by XML string.
-     *
-     * If your own network system has a critical performance issue on communication data class,
-     * it would be better to using binary communication (with ByteArray).
-     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray).
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Entity implements IEntity {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    interface IEntityCollection<T extends IEntity> extends IEntityGroup<T>, collections.ICollection<T> {
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityArrayCollection<T extends IEntity> extends collections.ArrayCollection<T> implements IEntityCollection<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityListCollection<T extends IEntity> extends collections.ListCollection<T> implements IEntityCollection<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityDequeCollection<T extends IEntity> extends collections.DequeCollection<T> implements IEntityCollection<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-/**
- * A template for External Systems Manager.
- *
- * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace samchon.templates.external {
-    /**
-     * An array and manager of {@link ExternalSystem external system drivers}.
-     *
-     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
-     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
-     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
-     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
-     *
-     * You can specify this {@link ExternalSystemArray} class to be *a server accepting external clients* or
-     * *a client connecting to external servers*. Even both of them is also possible.
-     *
-     * - {@link ExternalClientArray}: A server accepting {@link ExternalSystem external clients}.
-     * - {@link ExternalServerArray}: A client connecting to {@link ExternalServer external servers}.
-     * - {@link ExternalServerClientArray}: Both of them. Accepts {@link ExternalSystem external clients} and connects to
-     *   {@link ExternalServer external servers} at the same time.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalSystemArray<System extends ExternalSystem> extends protocol.EntityDequeCollection<System> implements protocol.IProtocol {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @hidden
-         */
-        private handle_system_erase(event);
-        /**
-         * Test whether the role exists.
-         *
-         * @param name Name, identifier of target {@link ExternalSystemRole role}.
-         *
-         * @return Whether the role has or not.
-         */
-        hasRole(name: string): boolean;
-        /**
-         * Get a role.
-         *
-         * @param name Name, identifier of target {@link ExternalSystemRole role}.
-         *
-         * @return The specified role.
-         */
-        getRole(name: string): ExternalSystemRole;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * @param invoke An {@link Invoke} message to send.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * Handle an {@Invoke} message have received.
-         *
-         * @param invoke An {@link Invoke} message have received.
-         */
-        replyData(invoke: protocol.Invoke): void;
-        /**
-         * Tag name of the {@link ExternalSytemArray} in {@link XML}.
-         *
-         * @return *systemArray*.
-         */
-        TAG(): string;
-        /**
-         * Tag name of {@link ExternalSystem children elements} belonged to the {@link ExternalSytemArray} in {@link XML}.
-         *
-         * @return *system*.
-         */
-        CHILD_TAG(): string;
-    }
-}
-/**
- * A template for Parallel Processing System.
- *
- * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace samchon.templates.parallel {
-    /**
-     * Master of Parallel Processing System.
-     *
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to **slave** systems and the
-     * children {@link ParallelSystem} objects represent the remote **slave** systems, who is being requested the
-     * *parallel processes*.
-     *
-     * You can specify this {@link ParallelSystemArray} class to be *a server accepting parallel clients* or
-     * *a client connecting to parallel servers*. Even both of them is possible. Extends one of them below and overrides
-     * abstract factory method(s) creating the child {@link ParallelSystem} object.
-     *
-     * - {@link ParallelClientArray}: A server accepting {@link ParallelSystem parallel clients}.
-     * - {@link ParallelServerArray}: A client connecting to {@link ParallelServer parallel servers}.
-     * - {@link ParallelServerClientArray}: Both of them. Accepts {@link ParallelSystem parallel clients} and connects to
-     *   {@link ParallelServer parallel servers} at the same time.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelSystemArray<System extends ParallelSystem> extends external.ExternalSystemArray<System> {
-        /**
-         * @hidden
-         */
-        private history_sequence_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Send an {@link Invoke} message with segment size.
-         *
-         * Sends an {@link Invoke} message requesting a **parallel process** with its *segment size*. The {@link Invoke}
-         * message will be delivered to children {@link ParallelSystem} objects with the *piece size*, which is divided
-         * from the *segment size*, basis on their {@link ParallelSystem.getPerformance performance indices}.
-         *
-         * - If segment size is 100,
-         * - The segment will be allocated such below:
-         *
-         * Name    | Performance index | Number of pieces to be allocated | Formula
-         * --------|-------------------|----------------------------------|--------------
-         * Snail   |                 1 |                               10 | 100 / 10 * 1
-         * Cheetah |                 4 |                               40 | 100 / 10 * 4
-         * Rabbit  |                 3 |                               30 | 100 / 10 * 3
-         * Turtle  |                 2 |                               20 | 100 / 10 * 2
-         *
-         * When the **parallel process** has completed, then this {@link ParallelSystemArraY} will estimate
-         * {@link ParallelSystem.getPerformance performance indices} of {@link ParallelSystem} objects basis on their
-         * execution time.
-         *
-         * @param invoke An {@link Invoke} message requesting parallel process.
-         * @param size Number of pieces to segment.
-         *
-         * @return Number of {@link ParallelSystem slave systems} participating in the *Parallel Process*.
-         *
-         * @see {@link sendPieceData}, {@link ParallelSystem.getPerformacen}
-         */
-        sendSegmentData(invoke: protocol.Invoke, size: number): number;
-        /**
-         * Send an {@link Invoke} message with range of pieces.
-         *
-         * Sends an {@link Invoke} message requesting a **parallel process** with its *range of pieces [first, last)*.
-         * The {@link Invoke} will be delivered to children {@link ParallelSystem} objects with the newly computed
-         * *range of sub-pieces*, which is divided from the *range of pieces (first to last)*, basis on their
-         * {@link ParallelSystem.getPerformance performance indices}.
-         *
-         * - If indices of pieces are 0 to 50,
-         * - The sub-pieces will be allocated such below:
-         *
-         * Name    | Performance index | Range of sub-pieces to be allocated | Formula
-         * --------|-------------------|-------------------------------------|------------------------
-         * Snail   |                 1 |                            ( 0,  5] | (50 - 0) / 10 * 1
-         * Cheetah |                 4 |                            ( 5, 25] | (50 - 0) / 10 * 4 + 5
-         * Rabbit  |                 3 |                            (25, 40] | (50 - 0) / 10 * 3 + 25
-         * Turtle  |                 2 |                            (40, 50] | (50 - 0) / 10 * 2 + 40
-         *
-         * When the **parallel process** has completed, then this {@link ParallelSystemArraY} will estimate
-         * {@link ParallelSystem.getPerformance performance indices} of {@link ParallelSystem} objects basis on their
-         * execution time.
-         *
-         * @param invoke An {@link Invoke} message requesting parallel process.
-         * @param first Initial piece's index in a section.
-         * @param last Final piece's index in a section. The range used is [*first*, *last*), which contains
-         *			   all the pieces' indices between *first* and *last*, including the piece pointed by index
-         *			   *first*, but not the piece pointed by the index *last*.
-         *
-         * @return Number of {@link ParallelSystem slave systems} participating in the *Parallel Process*.
-         *
-         * @see {@link sendSegmentData}, {@link ParallelSystem.getPerformacen}
-         */
-        sendPieceData(invoke: protocol.Invoke, first: number, last: number): number;
-        /**
-         * @hidden
-         */
-        protected _Complete_history(history: protocol.InvokeHistory): boolean;
-        /**
-         * @hidden
-         */
-        protected _Normalize_performance(): void;
-    }
-}
-/**
- * A template for Distributed Processing System.
- *
- * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace samchon.templates.distributed {
-    /**
-     * Master of Distributed Processing System.
-     *
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * You can specify this {@link DistributedSystemArray} class to be *a server accepting distributed clients* or
-     * *a client connecting to distributed servers*. Even both of them is possible. Extends one of them below and overrides
-     * abstract factory method(s) creating the child {@link DistributedSystem} object.
-     *
-     * - {@link DistributedClientArray}: A server accepting {@link DistributedSystem distributed clients}.
-     * - {@link DistributedServerArray}: A client connecting to {@link DistributedServer distributed servers}.
-     * - {@link DistributedServerClientArray}: Both of them. Accepts {@link DistributedSystem distributed clients} and
-     *   connects to {@link DistributedServer distributed servers} at the same time.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedSystemArray<System extends DistributedSystem> extends parallel.ParallelSystemArray<System> {
-        /**
-         * @hidden
-         */
-        private process_map_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * Factory method creating a child {@link DistributedProcess process} object.
-         *
-         * @param xml {@link XML} represents the {@link DistributedProcess child} object.
-         * @return A new {@link DistributedProcess} object.
-         */
-        protected abstract createProcess(xml: library.XML): DistributedProcess;
-        /**
-         * Get process map.
-         *
-         * Gets an {@link HashMap} containing {@link DistributedProcess} objects with their *key*.
-         *
-         * @return An {@link HasmMap> containing pairs of string and {@link DistributedProcess} object.
-         */
-        getProcessMap(): std.HashMap<string, DistributedProcess>;
-        /**
-         * Test whether the process exists.
-         *
-         * @param name Name, identifier of target {@link DistributedProcess process}.
-         *
-         * @return Whether the process has or not.
-         */
-        hasProcess(name: string): boolean;
-        /**
-         * Get a process.
-         *
-         * @param name Name, identifier of target {@link DistributedProcess process}.
-         *
-         * @return The specified process.
-         */
-        getProcess(name: string): DistributedProcess;
-        /**
-         * Insert a process.
-         *
-         * @param process A process to be inserted.
-         * @return Success flag.
-         */
-        insertProcess(process: DistributedProcess): boolean;
-        /**
-         * Erase a process.
-         *
-         * @param name Name, identifier of target {@link DistributedProcess process}.
-         */
-        eraseProcess(name: string): boolean;
-        /**
-         * @hidden
-         */
-        protected _Complete_history(history: protocol.InvokeHistory): boolean;
-        /**
-         * @hidden
-         */
-        private estimate_process_resource(history);
-        /**
-         * @hidden
-         */
-        private estimate_system_performance(history);
-        /**
-         * @hidden
-         */
-        protected _Normalize_performance(): void;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * Mediator of Distributed Processing System.
-     *
-     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
-     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
-     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
-     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a master, you can specify this {@link DistributedSystemArrayMediator} class to be <i>a master server accepting
-     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
-     * of them below and overrides abstract factory method(s) creating the child {@link DistributedSystem} object.
-     *
-     * - {@link DistributedClientArrayMediator}: A server accepting {@link DistributedSystem distributed clients}.
-     * - {@link DistributedServerArrayMediator}: A client connecting to {@link DistributedServer distributed servers}.
-     * - {@link DistributedServerClientArrayMediator}: Both of them. Accepts {@link DistributedSystem distributed clients} and
-     *   connects to {@link DistributedServer distributed servers} at the same time.
-     *
-     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
-     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link DistributedSystemArray}
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedSystemArrayMediator<System extends DistributedSystem> extends DistributedSystemArray<System> {
-        /**
-         * @hidden
-         */
-        private mediator_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating a {@link MediatorSystem} object.
-         *
-         * The {@link createMediator createMediator()} is an abstract method creating the {@link MediatorSystem} object.
-         *
-         * You know what? this {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a
-         * slave to its master system at the same time. The {@link MediatorSystem} object makes it possible; be a slave
-         * system. This {@link createMediator} determines specific type of the {@link MediatorSystem}.
-         *
-         * Overrides the {@link createMediator createMediator()} method to create and return one of them following which
-         * protocol and which type of remote connection (server or client) will be used:
-         *
-         * - A client slave connecting to master server:
-         *   - {@link MediatorClient}
-         *   - {@link MediatorWebClient}
-         *   - {@link MediatorSharedWorkerClient}
-         * - A server slave accepting master client:
-         *   - {@link MediatorServer}
-         *   - {@link MediatorWebServer}
-         *   - {@link MediatorDedicatedWorkerServer}
-         *   - {@link MediatorSharedWorkerServer}
-         *
-         * @return A newly created {@link MediatorSystem} object.
-         */
-        protected abstract createMediator(): parallel.MediatorSystem;
-        /**
-         * Start mediator.
-         *
-         * If the {@link getMediator mediator} is a type of server, then opens the server accepting master client.
-         * Otherwise, the {@link getMediator mediator} is a type of client, then connects the master server.
-         */
-        protected startMediator(): void;
-        /**
-         * Get {@link MediatorSystem} object.
-         *
-         * When you need to send an {@link Invoke} message to the master system of this
-         * {@link DistributedSystemArrayMediator}, then send to the {@link MediatorSystem} through this
-         * {@link getMediator}.
-         *
-         * ```typescript
-         * this.getMediator().sendData(...);
-         * ```
-         *
-         * @return The {@link MediatorSystem} object.
-         */
-        getMediator(): parallel.MediatorSystem;
-        /**
-         * @hidden
-         */
-        protected _Complete_history(history: parallel.PRInvokeHistory): boolean;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An interface taking full charge of network communication.
-     *
-     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
-     * remote system, without reference to whether the remote system is a server or a client. Type of the
-     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
-     * is a server (that I've to connect) or a client (a client connected to my server).
-     *
-     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
-     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
-     * {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link IClientDriver}, {@link IServerConnector}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface ICommunicator extends IProtocol {
-        /**
-         * Callback function for connection closed.
-         */
-        onClose: Function;
-        /**
-         * Close connection.
-         */
-        close(): void;
-        /**
-         * Test connection.
-         *
-         * Test whether this {@link ICommunicator communicator} object is connected with the remote system. If the
-         * connection is alive, then returns ```true```. Otherwise, the connection is not alive or this
-         * {@link ICommunicator communicator has not connected with the remote system yet, then returns ```false```.
-         *
-         * @return true if connected, otherwise false.
-         */
-        isConnected(): boolean;
-        /**
-         * Send message.
-         *
-         * Send {@link Invoke} message to remote system.
-         *
-         * @param invoke An {@link Invoke} message to send.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * Handle replied message.
-         *
-         * Handles replied {@link Invoke} message recived from remove system. The {@link Invoke} message will be shifted
-         * to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} by this method.
-         *
-         * @param invoke An {@link Invoke} message received from remote system.
-         */
-        replyData(invoke: protocol.Invoke): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An abstract, basic class for communicators.
-     *
-     * {@link CommunicatorBase} is an abstract class implemented from the {@link ICommunicator}. Mechanism of converting
-     * raw data to {@link Invoke} messag has realized in this abstract class. Type of this {@link CommunicatorBase} class
-     * is specified to as below following which protocol is used.
-     *
-     * - {@link Communicator}: Samchon Framework's own protocool.
-     * - {@link WebCommunicator}: Web-socket protocol
-     * - {@link SharedWorkerCommunicator}: SharedWorker's message protocol.
-     *
-     * #### [Inherited] {@link ICommunicator}
-     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
-     * remote system, without reference to whether the remote system is a server or a client. Type of the
-     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
-     * is a server (that I've to connect) or a client (a client connected to my server).
-     *
-     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
-     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
-     * {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link IClientDriver}, {@link IServerConnector}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class CommunicatorBase implements ICommunicator {
-        /**
-         * @hidden
-         */
-        protected listener_: IProtocol;
-        /**
-         * @inheritdoc
-         */
-        onClose: Function;
-        /**
-         * @hidden
-         */
-        protected connected_: boolean;
-        /**
-         * @hidden
-         */
-        private binary_invoke_;
-        /**
-         * @hidden
-         */
-        private binary_parameters_;
-        /**
-         * @hidden
-         */
-        private unhandled_invokes;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from *listener*.
-         *
-         * @param listener An {@link IProtocol} object to listen {@link Invoke} messages.
-         */
-        constructor(listener: IProtocol);
-        /**
-         * @inheritdoc
-         */
-        abstract close(): void;
-        /**
-         * @inheritdoc
-         */
-        isConnected(): boolean;
-        /**
-         * @hidden
-         */
-        protected is_binary_invoke(): boolean;
-        /**
-         * @inheritdoc
-         */
-        abstract sendData(invoke: Invoke): void;
-        /**
-         * @inheritdoc
-         */
-        replyData(invoke: Invoke): void;
-        /**
-         * @hidden
-         */
-        protected handle_string(str: string): void;
-        /**
-         * @hidden
-         */
-        protected handle_binary(binary: Uint8Array): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A communicator following Samchon Framework's own protocol.
-     *
-     * {@link Communicator} is an abstract class following Samchon Framework's own protocol. This {@link Communicator}
-     * class is specified to {@link ServerConnector} and {@link ClientDriver} whether the remote system is a server (that
-     * my system is connecting to) or a client (a client conneting to to my server).
-     *
-     * Note that, if one of this or remote system is web-browser based, then you don't have to use this
-     * {@link Communicator} class who follows Samchon Framework's own protocol. Web-browser supports only Web-socket
-     * protocol. Thus in that case, you have to use {@link WebCommunicator} instead.
-     *
-     * #### [Inherited] {@link ICommunicator}
-     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
-     * remote system, without reference to whether the remote system is a server or a client. Type of the
-     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
-     * is a server (that I've to connect) or a client (a client connected to my server).
-     *
-     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
-     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
-     * {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link ClientDriver}, {@link ServerConnector}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Communicator extends CommunicatorBase {
-        /**
-         * @hidden
-         */
-        protected socket_: socket.socket;
-        /**
-         * @hidden
-         */
-        private header_bytes_;
-        /**
-         * @hidden
-         */
-        private data_;
-        /**
-         * @hidden
-         */
-        private data_index_;
-        /**
-         * @hidden
-         */
-        private listening_;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @hidden
-         */
-        protected start_listen(): void;
-        /**
-         * @hidden
-         */
-        private handle_error();
-        /**
-         * @hidden
-         */
-        private handle_close();
-        /**
-         * @inheritdoc
-         */
-        sendData(invoke: Invoke): void;
-        /**
-         * @hidden
-         */
-        private listen_piece(piece);
-        /**
-         * @hidden
-         */
-        private listen_header(piece, piece_index);
-        /**
-         * @hidden
-         */
-        private listen_data(piece, piece_index);
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A communicator following Web-socket protocol.
-     *
-     * {@link WebCommunicator} is an abstract class following Web-socket protocol. This {@link WebCommunicator} class is
-     * specified to {@link WebServerConnector} and {@link WebClientDriver} whether the remote system is a server (that my
-     * system is connecting to) or a client (a client conneting to to my server).
-     *
-     * Note that, one of this or remote system is web-browser based, then there's not any alternative choice. Web browser
-     * supports only Web-socket protocol. In that case, you've use this {@link WebCommunicator} class.
-     *
-     * #### [Inherited] {@link ICommunicator}
-     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
-     * remote system, without reference to whether the remote system is a server or a client. Type of the
-     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
-     * is a server (that I've to connect) or a client (a client connected to my server).
-     *
-     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
-     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
-     * {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link WebClientDriver}, {@link WebServerConnector}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class WebCommunicator extends CommunicatorBase {
-        /**
-         * @hidden
-         */
-        protected connection_: websocket.connection;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @inheritdoc
-         */
-        sendData(invoke: Invoke): void;
-        /**
-         * @hidden
-         */
-        protected handle_message(message: websocket.IMessage): void;
-        /**
-         * @hidden
-         */
-        protected handle_close(): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A communicator for shared worker.
-     *
-     * {@link DedicatedWorkerCommunicator} is an abstract class for communication between DedicatedWorker and Web-browser.
-     * This {@link DedicatedWorkerCommunicator} is specified to {@link DedicatedWorkerServerConnector} and
-     * {@link DedicatedWorkerClientDriver} whether the remote system is a server (that my system is connecting to) or a
-     * client (a client conneting to to my server).
-     *
-     * #### Why DedicatedWorker be a server?
-     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
-     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
-     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
-     * communication? Furthermore, there's not any difference between the worker communication and network communication.
-     * It's the reason why Samchon Framework considers the **Worker** as a network node.
-     *
-     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
-     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
-     * server and clients with this {@link DedicatedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link ICommunicator}
-     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
-     * remote system, without reference to whether the remote system is a server or a client. Type of the
-     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
-     * is a server (that I've to connect) or a client (a client connected to my server).
-     *
-     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
-     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
-     * {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link DedicatedWorkerClientDriver}, {@link DedicatedWorkerServerConnector}, {@link IProtocol}
-     * @reference https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorker
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DedicatedWorkerCommunicator extends CommunicatorBase {
-        /**
-         * @hidden
-         */
-        protected handle_message(event: MessageEvent): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A communicator for shared worker.
-     *
-     * {@link SharedWorkerCommunicator} is an abstract class for communication between SharedWorker and Web-browser. This
-     * {@link SharedWorkerCommunicator} is specified to {@link SharedWorkerServerConnector} and
-     * {@link SharedWorkerClientDriver} whether the remote system is a server (that my system is connecting to) or a client
-     * (a client conneting to to my server).
-     *
-     * Note that, SharedWorker is a conception only existed in web-browser. This {@link SharedWorkerCommunicator} is not
-     * supported in NodeJS. Only web-browser environment can utilize this {@link SharedWorkerCommunicator}.
-     *
-     * #### Why SharedWorker be a server?
-     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
-     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
-     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
-     * clients.
-     *
-     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
-     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
-     * server and clients with this {@link SharedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link ICommunicator}
-     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
-     * remote system, without reference to whether the remote system is a server or a client. Type of the
-     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
-     * is a server (that I've to connect) or a client (a client connected to my server).
-     *
-     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
-     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
-     * {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link SharedWorkerClientDriver}, {@link SharedWorkerServerConnector}, {@link IProtocol}
-     * @reference https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class SharedWorkerCommunicator extends CommunicatorBase {
-        /**
-         * @hidden
-         */
-        protected port_: MessagePort;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @inheritdoc
-         */
-        sendData(invoke: Invoke): void;
-        /**
-         * @hidden
-         */
-        protected handle_message(event: MessageEvent): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An interface for communicator with remote client.
-     *
-     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
-     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
-     *
-     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
-     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
-     * created by the matched {@link IServer} object.
-     *
-     * Protocol                | Derived Type                        | Created By
-     * ------------------------|-------------------------------------|----------------------------
-     * Samchon Framework's own | {@link ClientDriver}                | {@link Server}
-     * Web-socket protocol     | {@link WebClientDriver}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerClinetDriver} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerClientDriver}    | {@link SharedWorkerServer}
-     *
-     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
-     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
-     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
-     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
-     *
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link IServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IClientDriver extends ICommunicator {
-        /**
-         * Listen message from the newly connected client.
-         *
-         * Starts listening message from the newly connected client. Replied message from the connected client will be
-         * converted to {@link Invoke} classes and shifted to the *listener*'s {@link IProtocol.replyData replyData()}
-         * method.
-         *
-         * @param listener A listener object to listen replied message from newly connected client in
-         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
-         */
-        listen(listener: IProtocol): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * Communicator with remote client.
-     *
-     * {@link ClientDriver} is a class taking full charge of network communication with remote client who follows Samchon
-     * Framework's own protocol. This {@link ClientDriver} object is always created by {@link Server} class. When you got
-     * this {@link ClientDriver} object from the {@link Server.addClient Server.addClient()}, then specify
-     * {@link IProtocol listener} with the {@link ClientDriver.listen ClientDriver.listen()} method.
-     *
-     * #### [Inherited] {@link IClientDriver}
-     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
-     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
-     *
-     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
-     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
-     * created by the matched {@link IServer} object.
-     *
-     * Protocol                | Derived Type                        | Created By
-     * ------------------------|-------------------------------------|----------------------------
-     * Samchon Framework's own | {@link ClientDriver}                | {@link Server}
-     * Web-socket protocol     | {@link WebClientDriver}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerClinetDriver} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerClientDriver}    | {@link SharedWorkerServer}
-     *
-     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
-     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
-     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
-     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
-     *
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link Server}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ClientDriver extends Communicator implements IClientDriver {
-        /**
-         * Construct from a socket.
-         */
-        constructor(socket: socket.socket);
-        /**
-         * @inheritdoc
-         */
-        listen(listener: IProtocol): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * Communicator with remote web-client.
-     *
-     * {@link WebClientDriver} is a class taking full charge of network communication with remote client who follows
-     * Web-socket protocol. This {@link WebClientDriver} object is always created by {@link WebServer} class. When you
-     * got this {@link WebClientDriver} object from the {@link WebServer.addClient WebServer.addClient()}, then specify
-     * {@link IProtocol listener} with the {@link WebClientDriver.listen WebClientDriver.listen()} method.
-     *
-     * Unlike other protocol, Web-socket protocol's clients notify two parameters on their connection;
-     * {@link getSessionID session-id} and {@link getPath path}. The {@link getSessionID session-id} can be used to
-     * identify *user* of each client, and the {@link getPath path} can be used which type of *service* that client wants.
-     * In {@link service} module, you can see the best utilization case of them.
-     * - {@link service.User}: utlization of the {@link getSessionID session-id}.
-     * - {@link service.Service}: utilization of the {@link getPath path}.
-     *
-     * #### [Inherited] {@link IClientDriver}
-     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
-     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
-     *
-     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
-     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
-     * created by the matched {@link IServer} object.
-     *
-     * Protocol                | Derived Type                        | Created By
-     * ------------------------|-------------------------------------|----------------------------
-     * Samchon Framework's own | {@link ClientDriver}                | {@link Server}
-     * Web-socket protocol     | {@link WebClientDriver}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerClinetDriver} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerClientDriver}    | {@link SharedWorkerServer}
-     *
-     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
-     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
-     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
-     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
-     *
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link WebServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class WebClientDriver extends WebCommunicator implements IClientDriver {
-        /**
-         * @hidden
-         */
-        private path_;
-        /**
-         * @hidden
-         */
-        private session_id_;
-        /**
-         * @hidden
-         */
-        private listening_;
-        /**
-         * Initialization Constructor.
-         *
-         * @param connection Connection driver, a socket for web-socket.
-         * @param path Requested path.
-         * @param session_id Session ID, an identifier of the remote client.
-         */
-        constructor(connection: websocket.connection, path: string, session_id: string);
-        /**
-         * @inheritdoc
-         */
-        listen(listener: IProtocol): void;
-        /**
-         * Get requested path.
-         */
-        getPath(): string;
-        /**
-         * Get session ID, an identifier of the remote client.
-         */
-        getSessionID(): string;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * Communicator with master web-browser.
-     *
-     * {@link DedicatedWorkerClientDriver} is a class taking full charge of network communication with web browsers. This
-     * {@link DedicatedWorkerClientDriver} object is always created by {@link DedicatedWorkerServer} class. When you got
-     * this {@link DedicatedWorkerClientDriver} object from
-     * {@link DedicatedWorkerServer.addClient DedicatedWorkerServer.addClient()}, then specify {@link IProtocol listener}
-     * with the {@link DedicatedWorkerClientDriver.listen DedicatedWorkerClientDriver.listen()} method.
-     *
-     * #### Why DedicatedWorker be a server?
-     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
-     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
-     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
-     * communication? Furthermore, there's not any difference between the worker communication and network communication.
-     * It's the reason why Samchon Framework considers the **Worker** as a network node.
-     *
-     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
-     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
-     * server and clients with this {@link DedicatedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link IClientDriver}
-     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
-     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
-     *
-     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
-     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
-     * created by the matched {@link IServer} object.
-     *
-     * Protocol                | Derived Type                        | Created By
-     * ------------------------|-------------------------------------|----------------------------
-     * Samchon Framework's own | {@link ClientDriver}                | {@link Server}
-     * Web-socket protocol     | {@link WebClientDriver}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerClinetDriver} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerClientDriver}    | {@link SharedWorkerServer}
-     *
-     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
-     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
-     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
-     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
-     *
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link DedicatedWorkerServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DedicatedWorkerClientDriver extends DedicatedWorkerCommunicator implements IClientDriver {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        listen(listener: IProtocol): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @inheritdoc
-         */
-        sendData(invoke: Invoke): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * Communicator with remote web-browser.
-     *
-     * {@link SharedWorkerClientDriver} is a class taking full charge of network communication with web browsers. This
-     * {@link SharedWorkerClientDriver} object is always created by {@link SharedWorkerServer} class. When you got this
-     * {@link SharedWorkerClientDriver} object from {@link SharedWorkerServer.addClient SharedWorkerServer.addClient()},
-     * then specify {@link IProtocol listener} with the
-     * {@link SharedWorkerClientDriver.listen SharedWorkerClientDriver.listen()} method.
-     *
-     * #### Why SharedWorker be a server?
-     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
-     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
-     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
-     * clients.
-     *
-     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
-     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
-     * server and clients with this {@link SharedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link IClientDriver}
-     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
-     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
-     *
-     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
-     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
-     * created by the matched {@link IServer} object.
-     *
-     * Protocol                | Derived Type                        | Created By
-     * ------------------------|-------------------------------------|----------------------------
-     * Samchon Framework's own | {@link ClientDriver}                | {@link Server}
-     * Web-socket protocol     | {@link WebClientDriver}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerClinetDriver} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerClientDriver}    | {@link SharedWorkerServer}
-     *
-     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
-     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
-     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
-     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
-     *
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link SharedWorkerServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SharedWorkerClientDriver extends SharedWorkerCommunicator implements IClientDriver {
-        private listening_;
-        /**
-         * Construct from a MessagePort object.
-         */
-        constructor(port: MessagePort);
-        /**
-         * @inheritdoc
-         */
-        listen(listener: IProtocol): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A container of entity, and it's a type of entity, too.
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
-     *
-     * @handbook  [Protocol - Standard Message](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Standard_Message)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IEntityGroup<T extends IEntity> extends IEntity, std.base.IContainer<T> {
-        /**
-         * Construct data of the Entity from an XML object.
-         *
-         * Constructs the EntityArray's own member variables only from the input XML object.
-         *
-         * Do not consider about constructing children Entity objects' data in EntityArray::construct().
-         * Those children Entity objects' data will constructed by their own construct() method. Even insertion
-         * of XML objects representing children are done by abstract method of EntityArray::toXML().
-         *
-         * Constructs only data of EntityArray's own.
-         */
-        construct(xml: library.XML): void;
-        /**
-         * Factory method of a child Entity.
-         *
-         * EntityArray::createChild() is a factory method creating a new child Entity which is belonged
-         * to the EntityArray. This method is called by EntityArray::construct(). The children construction
-         * methods Entity::construct() will be called by abstract method of the EntityArray::construct().
-         *
-         * @return A new child Entity belongs to EntityArray.
-         */
-        createChild(xml: library.XML): T;
-        /**
-         * Get iterator to element.
-         *
-         * Searches the container for an element with a identifier equivalent to *key* and returns an
-         * iterator to it if found, otherwise it returns an iterator to {@link end end()}.
-         *
-         * Two keys are considered equivalent if the container's comparison object returns false reflexively
-         * (i.e., no matter the order in which the elements are passed as arguments).
-         *
-         * Another member functions, {@link has has()} and {@link count count()}, can be used to just check
-         * whether a particular *key* exists.
-         *
-         * @param key Key to be searched for
-         * @return An iterator to the element, if an element with specified *key* is found, or
-         *		   {@link end end()} otherwise.
-         */
-        /**
-         * Whether have the item or not.
-         *
-         * Indicates whether a map has an item having the specified identifier.
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @return Whether the map has an item having the specified identifier.
-         */
-        has(key: any): boolean;
-        /**
-         * Count elements with a specific key.
-         *
-         * Searches the container for elements whose key is *key* and returns the number of elements found.
-         *
-         * @param key Key value to be searched for.
-         *
-         * @return The number of elements in the container with a *key*.
-         */
-        count(key: any): number;
-        /**
-         * Get an element
-         *
-         * Returns a reference to the mapped value of the element identified with *key*.
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @throw exception out of range
-         *
-         * @return A reference object of the mapped value (_Ty)
-         */
-        get(key: any): T;
-        /**
-         * A tag name of children objects.
-         */
-        CHILD_TAG(): string;
-        /**
-         * Get an XML object represents the EntityArray.
-         *
-         * Archives the EntityArray's own member variables only to the returned XML object.
-         *
-         * Do not consider about archiving children Entity objects' data in EntityArray::toXML().
-         * Those children Entity objects will converted to XML object by their own toXML() method. The
-         * insertion of XML objects representing children are done by abstract method of
-         * EntityArray::toXML().
-         *
-         * Archives only data of EntityArray's own.
-         */
-        toXML(): library.XML;
-    }
-    /**
-     * @hidden
-     */
-    namespace IEntityGroup {
-        /**
-         * @hidden
-         */
-        function construct<T extends IEntity>(entityGroup: IEntityGroup<T>, xml: library.XML, ...prohibited_names: string[]): void;
-        /**
-         * @hidden
-         */
-        function toXML<T extends IEntity>(entityGroup: IEntityGroup<T>, ...prohibited_names: string[]): library.XML;
-        function has<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): boolean;
-        function count<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): number;
-        function get<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): T;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityArray<T extends IEntity> extends std.Vector<T> implements IEntityGroup<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityList<T extends IEntity> extends std.List<T> implements IEntityGroup<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityDeque<T extends IEntity> extends std.Deque<T> implements IEntityGroup<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * Standard message of network I/O.
-     *
-     * {@link Invoke} is a class used in network I/O in protocol package of Samchon Framework.
-     *
-     * The Invoke message has an XML structure like the result screen of provided example in below.
-     * We can enjoy lots of benefits by the normalized and standardized message structure used in
-     * network I/O.
-     *
-     * The greatest advantage is that we can make any type of network system, even how the system
-     * is enourmously complicated. As network communication message is standardized, we only need to
-     * concentrate on logical relationships between network systems. We can handle each network system
-     * like a object (class) in OOD. And those relationships can be easily designed by using design
-     * pattern.
-     *
-     * In Samchon Framework, you can make any type of network system with basic componenets
-     * (IProtocol, IServer and ICommunicator) by implemens or inherits them, like designing
-     * classes of S/W architecture.
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
-     *
-     * @see {@link IProtocol}
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Invoke extends EntityArray<InvokeParameter> {
-        /**
-         * Listener, represent function's name.
-         */
-        private listener;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        constructor(listener: string);
-        /**
-         * Copy Constructor.
-         *
-         * @param invoke
-         */
-        constructor(invoke: Invoke);
-        /**
-         * Construct from listener and parametric values.
-         *
-         * @param listener
-         * @param parameters
-         */
-        constructor(listener: string, ...parameters: Array<number | string | library.XML>);
-        /**
-         * @inheritdoc
-         */
-        createChild(xml: library.XML): InvokeParameter;
-        /**
-         * Get listener.
-         */
-        getListener(): string;
-        /**
-         * Get arguments for Function.apply().
-         *
-         * @return An array containing values of the contained parameters.
-         */
-        getArguments(): Array<any>;
-        /**
-         * Apply to a matched function.
-         *
-         * @param obj Target {@link IProtocol} object to find matched function.
-         * @return Whether succeded to find matched function.
-         */
-        apply(obj: IProtocol): boolean;
-        /**
-         * Apply to a function.
-         *
-         * @param thisArg Owner of the function.
-         * @param func Function to call.
-         */
-        apply(thisArg: IProtocol, func: Function): void;
-        /**
-         * @inheritdoc
-         */
-        TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        CHILD_TAG(): string;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A parameter belongs to an Invoke.
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class InvokeParameter extends Entity {
-        /**
-         * Name of the parameter.
-         *
-         * @details Optional property, can be omitted.
-         */
-        protected name: string;
-        /**
-         * Type of the parameter.
-         */
-        protected type: string;
-        /**
-         * Value of the parameter.
-         */
-        protected value: string | number | library.XML | Uint8Array;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        constructor(val: number);
-        constructor(val: string);
-        constructor(val: library.XML);
-        constructor(val: Uint8Array);
-        /**
-         * Construct from variable name and number value.
-         *
-         * @param name
-         * @param val
-         */
-        constructor(name: string, val: number);
-        constructor(name: string, val: string);
-        constructor(name: string, val: library.XML);
-        constructor(name: string, val: Uint8Array);
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        setValue(value: number): void;
-        setValue(value: string): void;
-        setValue(value: library.XML): void;
-        setValue(value: Uint8Array): void;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * Get name.
-         */
-        getName(): string;
-        /**
-         * Get type.
-         */
-        getType(): string;
-        /**
-         * Get value.
-         */
-        getValue(): any;
-        /**
-         * @inheritdoc
-         */
-        TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * History of an {@link Invoke} message.
-     *
-     * The {@link InvokeHistory} is a class archiving history log of an {@link Invoke} message with elapsed time. This
-     * {@link InvokeHistory} class is used to report elapsed time of handling a requested process from **slave** to
-     * **master** system.
-     *
-     * The **master** system utilizes derived {@link InvokeHistory} objects to compute performance indices.
-     * - {@link ParallelSytem.getPerformance}
-     * - {@link DistributedProcess.getResource}
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class InvokeHistory extends protocol.Entity {
-        /**
-         * @hidden
-         */
-        private uid;
-        /**
-         * @hidden
-         */
-        private listener;
-        /**
-         * @hidden
-         */
-        private start_time_;
-        /**
-         * @hidden
-         */
-        private end_time_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from an {@link Invoke} message.
-         *
-         * @param invoke An {@link Invoke} message requesting a *parallel or distributed process*.
-         */
-        constructor(invoke: protocol.Invoke);
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * Complete the history.
-         *
-         * Completes the history and determines the {@link getEndTime end time}.
-         */
-        complete(): void;
-        key(): number;
-        /**
-         * Get unique ID.
-         */
-        getUID(): number;
-        /**
-         * Get {@link Invoke.getListener listener} of the {@link Invoke} message.
-         */
-        getListener(): string;
-        /**
-         * Get start time.
-         */
-        getStartTime(): Date;
-        /**
-         * Get end time.
-         */
-        getEndTime(): Date;
-        /**
-         * Compute elapsed time.
-         *
-         * @return nanoseconds.
-         */
-        computeElapsedTime(): number;
-        /**
-         * @inheritdoc
-         */
-        TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-        /**
-         * Convert to an {@link Invoke} message.
-         *
-         * Creates and returns an {@link Invoke} message that is used to reporting to the **master**.
-         */
-        toInvoke(): protocol.Invoke;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An interface for {@link Invoke} message chain.
-     *
-     * {@link IProtocol} is an interface for {@link Invoke} message, which is standard message of network I/O in
-     * *Samchon Framework*, chain. The {@link IProtocol} interface is used to network drivers and some classes which are
-     * in a relationship of *Chain of Responsibility Pattern* with those network drivers.
-     *
-     * Implements {@link IProtocol} if the class sends and handles {@link Invoke} messages. Looking around source codes of
-     * the *Samchon Framework*, especially *Templates*, you can find out that all the classes and modules handling
-     * {@link Invoke} messages are always implementing this {@link IProtocol}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link Invoke}
-     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iprotocol
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IProtocol {
-        /**
-         * Sending message.
-         *
-         * Sends message to related system or shifts the responsibility to chain.
-         *
-         * @param invoke Invoke message to send
-         */
-        replyData(invoke: Invoke): void;
-        /**
-         * Handling replied message.
-         *
-         * Handles replied message or shifts the responsibility to chain.
-         *
-         * @param invoke An {@link Invoke} message has received.
-         */
-        sendData(invoke: Invoke): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An interface for a server.
-     *
-     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
-     * {@link IClientDriver accepting clients}.
-     *
-     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
-     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
-     * object. Then at last, call {@link open open()} method with specified port number.
-     *
-     * Protocol                | Derived Type                  | Related {@link IClientDriver}
-     * ------------------------|-------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerClientDriver}
-     *
-     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
-     * - {@link service.Server}
-     * - {@link external.ExternalClientArray}
-     * - {@link slave.SlaveServer}
-     *
-     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link IClientDriver}, {@link IServerBase}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IServer {
-        /**
-         * Open server.
-         *
-         * @param port Port number to open.
-         */
-        open(port: number): void;
-        /**
-         * Close server.
-         *
-         * Close opened server. All remote clients, have connected with this server, are also closed and their call back
-         * functions, for closed connection, {@link IClientDriver.onClose} are also called.
-         */
-        close(): void;
-        /**
-         * Add a newly connected remote client.
-         *
-         * The {@link addClient addClient()} is an abstract method being called when a remote client is newly connected
-         * with {@link IClientDriver} object who communicates with the remote system. Overrides this method and defines
-         * what to do with the *driver*, a newly connected remote client.
-         *
-         * Below methods and example codes may be good for comprehending how to utilize this {@link addClient} method.
-         *
-         * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-         * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
-         * - {@link service.Server.addClient}
-         * - {@link external.ExternalClientArray.addClient}
-         * - {@link slave.SlaveServer.addClient}
-         *
-         * @param driver A {@link ICommunicator communicator} with (newly connected) remote client.
-         */
-        addClient(driver: IClientDriver): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A server.
-     *
-     * The {@link Server} is an abstract class designed to open a server and accept clients who are following Samchon
-     * Framework's own protocol. Extends this {@link Server} class and overrides {@link addClient addClient()} method to
-     * define what to do with newly connected {@link ClientDriver remote clients}.
-     *
-     * #### [Inherited] {@link IServer}
-     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
-     * {@link IClientDriver accepting clients}.
-     *
-     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
-     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
-     * object. Then at last, call {@link open open()} method with specified port number.
-     *
-     * Protocol                | Derived Type                  | Related {@link IClientDriver}
-     * ------------------------|-------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerClientDriver}
-     *
-     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
-     * - {@link service.Server}
-     * - {@link external.ExternalClientArray}
-     * - {@link slave.SlaveServer}
-     *
-     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link ClientDriver}, {@link ServerBase}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Server implements IServer {
-        /**
-         * @hidden
-         */
-        private server;
-        /**
-         * @inheritdoc
-         */
-        abstract addClient(driver: ClientDriver): void;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @hidden
-         */
-        private handle_connect(socket);
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A web server.
-     *
-     * The {@link WebServer} is an abstract class designed to open a server and accept clients who are following
-     * web-socket protocol. Extends this {@link WebServer} class and overrides {@link addClient addClient()} method to
-     * define what to do with newly connected {@link WebClientDriver remote clients}.
-     *
-     * #### [Inherited] {@link IServer}
-     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
-     * {@link IClientDriver accepting clients}.
-     *
-     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
-     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
-     * object. Then at last, call {@link open open()} method with specified port number.
-     *
-     * Protocol                | Derived Type                  | Related {@link IClientDriver}
-     * ------------------------|-------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerClientDriver}
-     *
-     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
-     * - {@link service.Server}
-     * - {@link external.ExternalClientArray}
-     * - {@link slave.SlaveServer}
-     *
-     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link WebClientDriver}, {@link WebServerBase}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class WebServer implements IServer {
-        /**
-         * @hidden
-         */
-        private http_server_;
-        /**
-         * @hidden
-         */
-        private sequence_;
-        /**
-         * @hidden
-         */
-        private my_port_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @inheritdoc
-         */
-        abstract addClient(driver: WebClientDriver): void;
-        /**
-         * @hidden
-         */
-        private handle_request(request);
-        /**
-         * @hidden
-         */
-        private get_session_id(cookies);
-        /**
-         * @hidden
-         */
-        private issue_session_id();
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A SharedWorker server.
-     *
-     * The {@link DedicatedWorkerServer} is an abstract class is realized to open a DedicatedWorker server and accept
-     * web-browser client (master). Extends this {@link DedicatedWorkerServer} class and overrides
-     * {@link addClient addClient()} method to define what to do with a newly connected
-     * {@link DedicatedWorkerClientDriver remote client}.
-     *
-     * #### Why DedicatedWorker be a server?
-     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
-     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
-     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
-     * communication? Furthermore, there's not any difference between the worker communication and network communication.
-     * It's the reason why Samchon Framework considers the **Worker** as a network node.
-     *
-     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
-     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
-     * server and clients with this {@link DedicatedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link IServer}
-     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
-     * {@link IClientDriver accepting clients}.
-     *
-     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
-     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
-     * object. Then at last, call {@link open open()} method with specified port number.
-     *
-     * Protocol                | Derived Type                  | Related {@link IClientDriver}
-     * ------------------------|-------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerClientDriver}
-     *
-     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
-     * - {@link service.Server}
-     * - {@link external.ExternalClientArray}
-     * - {@link slave.SlaveServer}
-     *
-     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link DedicatedWorkerClientDriver}, {@link DedicatedWorkerServerBase}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DedicatedWorkerServer implements IServer {
-        /**
-         * @inheritdoc
-         */
-        open(): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @inheritdoc
-         */
-        abstract addClient(driver: DedicatedWorkerClientDriver): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A SharedWorker server.
-     *
-     * The {@link SharedWorker} is an abstract class is realized to open a SharedWorker server and accept web-browser
-     * clients. Extends this {@link SharedWorkerServer} class and overrides {@link addClient addClient()} method to
-     * define what to do with newly connected {@link SharedWorkerClientDriver remote clients}.
-     *
-     * #### Why SharedWorker be a server?
-     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
-     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
-     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
-     * clients.
-     *
-     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
-     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
-     * server and clients with this {@link SharedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link IServer}
-     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
-     * {@link IClientDriver accepting clients}.
-     *
-     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
-     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
-     * object. Then at last, call {@link open open()} method with specified port number.
-     *
-     * Protocol                | Derived Type                  | Related {@link IClientDriver}
-     * ------------------------|-------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerClientDriver}
-     *
-     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
-     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
-     * - {@link service.Server}
-     * - {@link external.ExternalClientArray}
-     * - {@link slave.SlaveServer}
-     *
-     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link SharedWorkerClientDriver}, {@link SharedWorkerServerBase}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class SharedWorkerServer implements IServer {
-        /**
-         * @inheritdoc
-         */
-        abstract addClient(driver: SharedWorkerClientDriver): void;
-        /**
-         * @inheritdoc
-         */
-        open(): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @hidden
-         */
-        private handle_connect(event);
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An interface for substitute server classes.
-     *
-     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
-     *
-     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
-     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
-     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
-     * the aggregated {@link IServerBase}.
-     *
-     * Protocol                | {@link IServer}               | {@link IServerBase}               | {@link IClientDriver}
-     * ------------------------|-------------------------------|-----------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ServerBase}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebServerBase}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerServerBase} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerServerBase}    | {@link SharedWorkerClientDriver}
-     *
-     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
-     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
-     * specified port number.
-     *
-     * ```typescript
-     * class MyServer extends Something implements IServer
-     * {
-     * 	private server_base_: IServerBase = new WebServerBase(this);
-     *
-     * 	public addClient(driver: IClientDriver): void
-     * 	{
-     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
-     * 	}
-     *
-     * 	public open(port: number): void
-     * 	{
-     * 		this.server_base_.open();
-     * 	}
-     * 	public close(): void
-     * 	{
-     * 		this.server_base_.close();
-     * 	}
-     * }
-     * ```
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link IServer}, {@link IClientDriver}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IServerBase extends IServer {
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A substitute {@link Server}.
-     *
-     * The {@link ServerBase} is a substitute class who subrogates {@link Server}'s responsibility.
-     *
-     * #### [Inherited] {@link IServerBase}
-     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
-     *
-     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
-     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
-     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
-     * the aggregated {@link IServerBase}.
-     *
-     * Protocol                | {@link IServer}               | {@link IServerBase}               | {@link IClientDriver}
-     * ------------------------|-------------------------------|-----------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ServerBase}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebServerBase}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerServerBase} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerServerBase}    | {@link SharedWorkerClientDriver}
-     *
-     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
-     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
-     * specified port number.
-     *
-     * ```typescript
-     * class MyServer extends Something implements IServer
-     * {
-     * 	private server_base_: IServerBase = new WebServerBase(this);
-     *
-     * 	public addClient(driver: IClientDriver): void
-     * 	{
-     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
-     * 	}
-     *
-     * 	public open(port: number): void
-     * 	{
-     * 		this.server_base_.open();
-     * 	}
-     * 	public close(): void
-     * 	{
-     * 		this.server_base_.close();
-     * 	}
-     * }
-     * ```
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     *
-     * @see {@link Server}, {@link ClientDriver}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ServerBase extends Server implements IServerBase {
-        /**
-         * @hidden
-         */
-        private hooker_;
-        /**
-         * Construct from a *hooker*.
-         *
-         * @param hooker A hooker throwing responsibility of server's role.
-         */
-        constructor(hooker: IServer);
-        /**
-         * @inheritdoc
-         */
-        addClient(driver: IClientDriver): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A substitute {@link WebServer}.
-     *
-     * The {@link WebServerBase} is a substitute class who subrogates {@link WebServer}'s responsibility.
-     *
-     * #### [Inherited] {@link IServerBase}
-     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
-     *
-     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
-     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
-     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
-     * the aggregated {@link IServerBase}.
-     *
-     * Protocol                | {@link IServer}               | {@link IServerBase}               | {@link IClientDriver}
-     * ------------------------|-------------------------------|-----------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ServerBase}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebServerBase}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerServerBase} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerServerBase}    | {@link SharedWorkerClientDriver}
-     *
-     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
-     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
-     * specified port number.
-     *
-     * ```typescript
-     * class MyServer extends Something implements IServer
-     * {
-     * 	private server_base_: IServerBase = new WebServerBase(this);
-     *
-     * 	public addClient(driver: IClientDriver): void
-     * 	{
-     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
-     * 	}
-     *
-     * 	public open(port: number): void
-     * 	{
-     * 		this.server_base_.open();
-     * 	}
-     * 	public close(): void
-     * 	{
-     * 		this.server_base_.close();
-     * 	}
-     * }
-     * ```
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link WebServer}, {@link WebClientDriver}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class WebServerBase extends WebServer implements IServerBase {
-        /**
-         * @hidden
-         */
-        private hooker_;
-        /**
-         * Construct from a *hooker*.
-         *
-         * @param hooker A hooker throwing responsibility of server's role.
-         */
-        constructor(hooker: IServer);
-        /**
-         * @inheritdoc
-         */
-        addClient(driver: IClientDriver): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A substitute {@link DedicatedWorkerServer}.
-     *
-     * The {@link DedicatedWorkerServerBase} is a substitute class who subrogates {@link DedicatedWorkerServer}'s
-     * responsibility.
-     *
-     * #### [Inherited] {@link IServerBase}
-     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
-     *
-     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
-     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
-     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
-     * the aggregated {@link IServerBase}.
-     *
-     * Protocol                | {@link IServer}               | {@link IServerBase}               | {@link IClientDriver}
-     * ------------------------|-------------------------------|-----------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ServerBase}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebServerBase}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerServerBase} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerServerBase}    | {@link SharedWorkerClientDriver}
-     *
-     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
-     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
-     * specified port number.
-     *
-     * ```typescript
-     * class MyServer extends Something implements IServer
-     * {
-     * 	private server_base_: IServerBase = new WebServerBase(this);
-     *
-     * 	public addClient(driver: IClientDriver): void
-     * 	{
-     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
-     * 	}
-     *
-     * 	public open(port: number): void
-     * 	{
-     * 		this.server_base_.open();
-     * 	}
-     * 	public close(): void
-     * 	{
-     * 		this.server_base_.close();
-     * 	}
-     * }
-     * ```
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link DedicatedWorkerServer}, {@link DedicatedWorkerClientDriver}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DedicatedWorkerServerBase extends DedicatedWorkerServer implements IServerBase {
-        /**
-         * @hidden
-         */
-        private hooker_;
-        /**
-         * Construct from a *hooker*.
-         *
-         * @param hooker A hooker throwing responsibility of server's role.
-         */
-        constructor(hooker: IServer);
-        /**
-         * @inheritdoc
-         */
-        addClient(driver: IClientDriver): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A substitute {@link SharedWorkerServer}.
-     *
-     * The {@link SharedWorkerServerBase} is a substitute class who subrogates {@link SharedWorkerServer}'s
-     * responsibility.
-     *
-     * #### [Inherited] {@link IServerBase}
-     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
-     *
-     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
-     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
-     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
-     * the aggregated {@link IServerBase}.
-     *
-     * Protocol                | {@link IServer}               | {@link IServerBase}               | {@link IClientDriver}
-     * ------------------------|-------------------------------|-----------------------------------|-------------------------------------
-     * Samchon Framework's own | {@link Server}                | {@link ServerBase}                | {@link ClientDriver}
-     * Web-socket protocol     | {@link WebServer}             | {@link WebServerBase}             | {@link WebClientDriver}
-     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerServerBase} | {@link DedicatedWorkerClientDriver}
-     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerServerBase}    | {@link SharedWorkerClientDriver}
-     *
-     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
-     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
-     * specified port number.
-     *
-     * ```typescript
-     * class MyServer extends Something implements IServer
-     * {
-     * 	private server_base_: IServerBase = new WebServerBase(this);
-     *
-     * 	public addClient(driver: IClientDriver): void
-     * 	{
-     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
-     * 	}
-     *
-     * 	public open(port: number): void
-     * 	{
-     * 		this.server_base_.open();
-     * 	}
-     * 	public close(): void
-     * 	{
-     * 		this.server_base_.close();
-     * 	}
-     * }
-     * ```
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @see {@link SharedWorkerServer}, {@link SharedWorkerClientDriver}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SharedWorkerServerBase extends SharedWorkerServer implements IServerBase {
-        /**
-         * @hidden
-         */
-        private hooker_;
-        /**
-         * Construct from a *hooker*.
-         *
-         * @param hooker A hooker throwing responsibility of server's role.
-         */
-        constructor(hooker: IServer);
-        /**
-         * @inheritdoc
-         */
-        addClient(driver: IClientDriver): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * An interface for server connector.
-     *
-     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
-     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
-     * charge of network communication with the remote server.
-     *
-     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
-     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
-     * be converted to an {@link Invoke} object and the {@link Invoke} object will be shifted to the
-     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method. Below code is an example
-     * connecting to remote server and interacting with it.
-     *
-     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-application.ts
-     *
-     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
-     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
-     *
-     * Protocol                | Derived Type                           | Connect to
-     * ------------------------|----------------------------------------|-------------------------------
-     * Samchon Framework's own | {@link ServerConnector}                | {@link Server}
-     * Web-socket protocol     | {@link WebServerConnector}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerServerConnector} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerServerConnector}    | {@link SharedWorkerServer}
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
-     *
-     * @see {@link IServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IServerConnector extends ICommunicator {
-        /**
-         * Callback function for connection completed.
-         *
-         * When you call {@link connect connect()} and the connection has completed, then this call back function
-         * {@link onConnect} will be called. Note that, if the listener of this {@link onConnect} is a member method of
-         * some class, then you've use the ```bind```.
-         */
-        onConnect: Function;
-        /**
-         * Connect to a server.
-         *
-         * Connects to a server with specified *host* address and *port* number. After the connection has
-         * succeeded, callback function {@link onConnect} is called. Listening data from the connected server also begins.
-         * Replied messages from the connected server will be converted to {@link Invoke} classes and will be shifted to
-         * the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method.
-         *
-         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
-         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
-         * the status of the connection is reported by an event. If the socket is already connected, the existing
-         * connection is closed first.
-         *
-         * @param ip The name or IP address of the host to connect to.
-         *			 If no host is specified, the host that is contacted is the host where the calling file resides.
-         *			 If you do not specify a host, use an event listener to determine whether the connection was
-         *			 successful.
-         * @param port The port number to connect to.
-         */
-        connect(ip: string, port: number): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * Server connnector.
-     *
-     * {@link ServerConnector} is a class connecting to remote server who follows Samchon Framework's own protocol and
-     * taking full charge of network communication with the remote server. Create a {@link ServerConnector} instance from
-     * the {@IProtocol listener} and call the {@link connect connect()} method.
-     *
-     * #### [Inherited] {@link IServerConnector}
-     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
-     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
-     * charge of network communication with the remote server.
-     *
-     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
-     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
-     * be converted to an {@link Invoke} object and the {@link Invoke} object will be shifted to the
-     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
-     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
-     *
-     * Protocol                | Derived Type                           | Connect to
-     * ------------------------|----------------------------------------|-------------------------------
-     * Samchon Framework's own | {@link ServerConnector}                | {@link Server}
-     * Web-socket protocol     | {@link WebServerConnector}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerServerConnector} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerServerConnector}    | {@link SharedWorkerServer}
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
-     *
-     * @see {@link Server}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ServerConnector extends Communicator implements IServerConnector {
-        /**
-         * @inheritdoc
-         */
-        onConnect: Function;
-        /**
-         * Construct from *listener*.
-         *
-         * @param listener A listener object to listen replied message from newly connected client in
-         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
-         */
-        constructor(listener: IProtocol);
-        /**
-         * @inheritdoc
-         */
-        connect(ip: string, port: number): void;
-        /**
-         * @hidden
-         */
-        private handle_connect(...arg);
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A server connector for web-socket protocol.
-     *
-     * {@link WebServerConnector} is a class connecting to remote server who follows Web-socket protocol and taking full
-     * charge of network communication with the remote server. Create an {@link WebServerConnector} instance from the
-     * {@IProtocol listener} and call the {@link connect connect()} method.
-     *
-     * #### [Inherited] {@link IServerConnector}
-     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
-     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
-     * charge of network communication with the remote server.
-     *
-     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
-     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
-     * be converted to an {@link Invoke} class and the {@link Invoke} object will be shifted to the
-     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
-     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
-     *
-     * Protocol                | Derived Type                           | Connect to
-     * ------------------------|----------------------------------------|-------------------------------
-     * Samchon Framework's own | {@link ServerConnector}                | {@link Server}
-     * Web-socket protocol     | {@link WebServerConnector}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerServerConnector} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerServerConnector}    | {@link SharedWorkerServer}
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
-     *
-     * @see {@link WebServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class WebServerConnector extends WebCommunicator implements IServerConnector {
-        /**
-         * @hidden
-         */
-        private browser_socket_;
-        /**
-         * @hidden
-         */
-        private node_client_;
-        /**
-         * @inheritdoc
-         */
-        onConnect: Function;
-        /**
-         * Construct from *listener*.
-         *
-         * @param listener A listener object to listen replied message from newly connected client in
-         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
-         */
-        constructor(listener: IProtocol);
-        /**
-         * Connect to a web server.
-         *
-         * Connects to a server with specified *host* address, *port* number and *path*. After the connection has
-         * succeeded, callback function {@link onConnect} is called. Listening data from the connected server also begins.
-         * Replied messages from the connected server will be converted to {@link Invoke} classes and will be shifted to
-         * the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method.
-         *
-         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
-         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
-         * the status of the connection is reported by an event. If the socket is already connected, the existing
-         * connection is closed first.
-         *
-         * @param ip The name or IP address of the host to connect to.
-         *			 If no host is specified, the host that is contacted is the host where the calling file resides.
-         *			 If you do not specify a host, use an event listener to determine whether the connection was
-         *			 successful.
-         * @param port The port number to connect to.
-         * @param path Path of service which you want.
-         */
-        connect(ip: string, port: number, path?: string): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @inheritdoc
-         */
-        sendData(invoke: Invoke): void;
-        /**
-         * @hidden
-         */
-        private handle_browser_connect(event);
-        /**
-         * @hidden
-         */
-        private handle_browser_message(event);
-        /**
-         * @hidden
-         */
-        private handle_node_connect(connection);
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A server connector for DedicatedWorker.
-     *
-     * {@link DedicatedWorkerServerConnector} is a class connecting to SharedWorker and taking full charge of network
-     * communication with the SharedWorker. Create an {@link DedicatedWorkerServer} instance from the
-     * {@IProtocol listener} and call the {@link connect connect()} method.
-     *
-     * #### Why DedicatedWorker be a server?
-     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
-     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
-     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
-     * communication? Furthermore, there's not any difference between the worker communication and network communication.
-     * It's the reason why Samchon Framework considers the **Worker** as a network node.
-     *
-     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
-     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
-     * server and clients with this {@link DedicatedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link IServerConnector}
-     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
-     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
-     * charge of network communication with the remote server.
-     *
-     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
-     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
-     * be converted to an {@link Invoke} class and the {@link Invoke} object will be shifted to the
-     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
-     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
-     *
-     * Protocol                | Derived Type                           | Connect to
-     * ------------------------|----------------------------------------|-------------------------------
-     * Samchon Framework's own | {@link ServerConnector}                | {@link Server}
-     * Web-socket protocol     | {@link WebServerConnector}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerServerConnector} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerServerConnector}    | {@link SharedWorkerServer}
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
-     *
-     * @see {@link DedicatedWorkerServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DedicatedWorkerServerConnector extends DedicatedWorkerCommunicator implements IServerConnector {
-        /**
-         * @hidden
-         */
-        private worker;
-        /**
-         * @inheritdoc
-         */
-        onConnect: Function;
-        /**
-         * Construct from *listener*.
-         *
-         * @param listener A listener object to listen replied message from newly connected client in
-         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
-         */
-        constructor(listener: IProtocol);
-        /**
-         * @inheritdoc
-         */
-        connect(jsFile: string): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-        /**
-         * @inheritdoc
-         */
-        sendData(invoke: Invoke): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * A server connector for SharedWorker.
-     *
-     * {@link SharedWorkerServerConnector} is a class connecting to SharedWorker and taking full charge of network
-     * communication with the SharedWorker. Create an {@link SharedWorkerServerConnector} instance from the
-     * {@IProtocol listener} and call the {@link connect connect()} method.
-     *
-     * #### Why SharedWorker be a server?
-     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
-     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
-     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
-     * clients.
-     *
-     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
-     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
-     * server and clients with this {@link SharedWorkerCommunicator}.
-     *
-     * #### [Inherited] {@link IServerConnector}
-     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
-     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
-     * charge of network communication with the remote server.
-     *
-     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
-     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
-     * be converted to an {@link Invoke} class and the {@link Invoke} object will be shifted to the
-     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
-     *
-     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
-     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
-     *
-     * Protocol                | Derived Type                           | Connect to
-     * ------------------------|----------------------------------------|-------------------------------
-     * Samchon Framework's own | {@link ServerConnector}                | {@link Server}
-     * Web-socket protocol     | {@link WebServerConnector}             | {@link WebServer}
-     * DedicatedWorker         | {@link DedicatedWorkerServerConnector} | {@link DedicatedWorkerServer}
-     * SharedWorker            | {@link SharedWorkerServerConnector}    | {@link SharedWorkerServer}
-     *
-     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
-     *
-     * @see {@link SharedWorkerServer}, {@link IProtocol}
-     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SharedWorkerServerConnector extends SharedWorkerCommunicator implements IServerConnector {
-        /**
-         * @inheritdoc
-         */
-        onConnect: Function;
-        /**
-         * Construct from *listener*.
-         *
-         * @param listener A listener object to listen replied message from newly connected client in
-         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
-         */
-        constructor(listener: IProtocol);
-        /**
-         * Connect to a SharedWorker.
-         *
-         * Connects to a server with specified *jstFile* path. If a SharedWorker instance of the *jsFile* is not
-         * constructed yet, then the SharedWorker will be newly constructed. Otherwise the SharedWorker already exists,
-         * then connect to the SharedWorker. After those processes, callback function {@link onConnect} is called.
-         * Listening data from the connected server also begins. Replied messages from the connected server will be
-         * converted to {@link Invoke} classes and will be shifted to the {@link WebCommunicator.listener listener}'s
-         * {@link IProtocol.replyData replyData()} method.
-         *
-         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
-         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
-         * the status of the connection is reported by an event. If the socket is already connected, the existing
-         * connection is closed first.
-         *
-         * @param jsFile Path of JavaScript file to execute who defines SharedWorker.
-         */
-        connect(jsFile: string): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @hidden
-     */
-    namespace socket {
-        type socket = any;
-        type server = any;
-        type http_server = any;
-    }
-    /**
-     * @hidden
-     */
-    namespace websocket {
-        type connection = any;
-        type request = any;
-        type IMessage = any;
-        type ICookie = any;
-        type client = any;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * Master of Distributed Processing System, a server accepting slave clients.
-     *
-     * The {@link DistributedClientArray} is an abstract class, derived from the {@link DistributedSystemArray} class,
-     * opening a server accepting {@link DistributedSystem distributed clients}.
-     *
-     * Extends this {@link DistributedClientArray}, overrides {@link createServerBase createServerBase()} to determine
-     * which protocol to follow and {@link createExternalClient createExternalClient()} creating child
-     * {@link DistributedSystem} object. After the extending and overridings, open this server using the
-     * {@link open open()} method.
-     *
-     * #### [Inherited] {@link DistributedSystemArray}
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedClientArray<System extends DistributedSystem> extends DistributedSystemArray<System> implements external.IExternalClientArray<System> {
-        /**
-         * @hidden
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating {@link IServerBase} object.
-         *
-         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified protocol.
-         *
-         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
-         *
-         * - {@link ServerBase}
-         * - {@link WebServerBase}
-         * - {@link SharedWorkerServerBase}
-         *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): protocol.IServerBase;
-        /**
-         * Add a newly connected remote client.
-         *
-         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
-         * then this {@link ParallelClientArray} creates a child {@link ParallelSystem parallel client} object through
-         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
-         *
-         * @param driver A communicator for external client.
-         */
-        addClient(driver: protocol.IClientDriver): void;
-        /**
-         * (Deprecated) Factory method creating child object.
-         *
-         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
-         *
-         * Note that, the {@link ParallelClientArray} is a server accepting {@link ParallelSystem parallel clients}.
-         * There's no way to creating the {@link ParallelSystem parallel clients} in advance before opening the server.
-         *
-         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
-         * @return ```null```
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating {@link DistributedSystem} object.
-         *
-         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
-         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
-         * {@link addClient addClient()}.
-         *
-         * Overrides this {@link createExternalClient} method and creates a type of {@link DistributedSystem} object with
-         * the *driver* that communicates with the parallel client. After the creation, returns the object. Then whenever
-         * a parallel client has connected, matched {@link DistributedSystem} object will be constructed and
-         * {@link insert inserted} into this {@link DistributedSystemArray} object.
-         *
-         * @param driver A communicator with the parallel client.
-         * @return A newly created {@link ParallelSystem} object.
-         */
-        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * Mediator of Distributed Processing System, a server accepting slave clients.
-     *
-     * The {@link DistributedClientArrayMediator} is an abstract class, derived from {@link DistributedSystemArrayMediator}
-     * class, opening a server accepting {@link DistributedSystem distributed clients} as a **master**.
-     *
-     * Extends this {@link DistributedClientArrayMediator}, overrides {@link createServerBase createServerBase()} to
-     * determine which protocol to follow and {@link createExternalClient createExternalClient()} creating child
-     * {@link DistributedSystem} object. After the extending and overridings, open this server using the
-     * {@link open open()} method.
-     *
-     * #### [Inherited] {@link DistributedSystemArrayMediator}
-     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
-     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
-     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
-     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
-     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link DistributedSystemArray}
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedClientArrayMediator<System extends DistributedSystem> extends DistributedSystemArrayMediator<System> implements external.IExternalClientArray<System> {
-        /**
-         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating {@link IServerBase} object.
-         *
-         * This method {@link createServerBase createServerBase()} determines which protocol is used in this
-         * {@link DistributedClientArrayMediator} object as a **master**. If the protocol is determined, then
-         * {@link DistributedSystem distributed clients} who may connect to {@link DistributedClientArrayMediator this
-         * server} must follow the specified protocol.
-         *
-         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
-         *
-         * - {@link ServerBase}
-         * - {@link WebServerBase}
-         * - {@link SharedWorkerServerBase}
-         *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): protocol.IServerBase;
-        /**
-         * Add a newly connected remote client.
-         *
-         * When a {@link IClientDriver remote client} connects to this *master server of distributed processing system*,
-         * then this {@link DistributedClientArrayMediator} creates a child {@link Distributed distributed client} object
-         * through the {@link createExternalClient createExternalClient()} method.
-         *
-         * @param driver A communicator for external client.
-         */
-        addClient(driver: protocol.IClientDriver): void;
-        /**
-         * (Deprecated) Factory method creating child object.
-         *
-         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
-         *
-         * Note that, the {@link DistributedClientArrayMediator} is a server accepting {@link DistributedSystem distributed
-         * clients} as a master. There's no way to creating the {@link DistributedSystem distributed clients} in advance
-         * before opening the server.
-         *
-         * @param xml An {@link XML} object represents the child {@link DistributedSystem} object.
-         * @return null
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating {@link DistributedSystem} object.
-         *
-         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
-         * {@link DistributedSystem} object, that is called whenever a distributed client has connected, by
-         * {@link addClient addClient()}.
-         *
-         * Overrides this {@link createExternalClient} method and creates a type of {@link DistributedSystem} object with
-         * the *driver* that communicates with the distributed client. After the creation, returns the object. Then whenever
-         * a distributed client has connected, matched {@link DistributedSystem} object will be constructed and
-         * {@link insert inserted} into this {@link DistributedClientArrayMediator} object.
-         *
-         * @param driver A communicator with the distributed client.
-         * @return A newly created {@link DistributedSystem} object.
-         */
-        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * A process of Distributed Processing System.
-     *
-     * The {@link DistributedProcess} is an abstract class who represents a **process**, *SOMETHING TO DISTRIBUTE* in a Distributed
-     * Processing System. Overrides the {@link DistributedProcess} and defines the *SOMETHING TO DISTRIBUTE*.
-     *
-     * Relationship between {@link DistributedSystem} and {@link DistributedProcess} objects are **M: N Associative**.
-     * Unlike {@link ExternalSystemRole}, the {@link DistributedProcess} objects are not belonged to a specific
-     * {@link DistributedSystem} object. The {@link DistributedProcess} objects are belonged to the
-     * {@link DistributedSystemArrayMediator} directly.
-     *
-     * When you need the **distributed process**, then call {@link sendData sendData()}. The {@link sendData} will find
-     * the most idle {@link DistributedSystem slave system} considering not only number of processes on progress, but also
-     * {@link DistributedSystem.getPerformance performance index} of each {@link DistributedSystem} object and
-     * {@link getResource resource index} of this {@link DistributedProcess} object. The {@link Invoke} message
-     * requesting the **distributed process** will be sent to the most idle {@link DistributedSystem slave system}.
-     *
-     * Those {@link DistributedSystem.getPerformance performance index} and {@link getResource resource index} are
-     * revaluated whenever the **distributed process** has completed basis on the execution time.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedProcess extends protocol.Entity implements protocol.IProtocol {
-        /**
-         * @hidden
-         */
-        private system_array_;
-        /**
-         * A name, represents and identifies this {@link DistributedProcess process}.
-         *
-         * This {@link name} is an identifier represents this {@link DistributedProcess process}. This {@link name} is
-         * used in {@link DistributedSystemArray.getProcess} and {@link DistributedSystemArray.getProcess}, as a key elements.
-         * Thus, this {@link name} should be unique in its parent {@link DistributedSystemArray} object.
-         */
-        protected name: string;
-        /**
-         * @hidden
-         */
-        private progress_list_;
-        /**
-         * @hidden
-         */
-        private history_list_;
-        /**
-         * @hidden
-         */
-        private resource;
-        /**
-         * @hidden
-         */
-        private enforced_;
-        /**
-         * Constrct from parent {@link DistributedSystemArray} object.
-         *
-         * @param systemArray The parent {@link DistributedSystemArray} object.
-         */
-        constructor(systemArray: DistributedSystemArray<DistributedSystem>);
-        /**
-         * Identifier of {@link ParallelProcess} is its {@link name}.
-         */
-        key(): string;
-        /**
-         * Get parent {@link DistributedSystemArray} object.
-         *
-         * @return The parent {@link DistributedSystemArray} object.
-         */
-        getSystemArray(): DistributedSystemArray<DistributedSystem>;
-        /**
-         * Get parent {@link DistributedSystemArray} object.
-         *
-         * @return The parent {@link DistributedSystemArray} object.
-         */
-        getSystemArray<SystemArray extends DistributedSystemArray<DistributedSystem>>(): SystemArray;
-        /**
-         * Get name, who represents and identifies this process.
-         */
-        getName(): string;
-        /**
-         * Get resource index.
-         *
-         * Get *resource index* that indicates how much this {@link DistributedProcess process} is heavy.
-         *
-         * If this {@link DistributedProcess process} does not have any	{@link Invoke} message had handled, then the
-         * *resource index* will be ```1.0```, which means default and average value between all
-         * {@link DistributedProcess} instances (that are belonged to a same {@link DistributedSystemArray} object).
-         *
-         * You can specify the *resource index* by yourself, but notice that, if the *resource index* is higher than
-         * other {@link DistributedProcess} objects, then this {@link DistributedProcess process} will be ordered to
-         * handle less processes than other {@link DistributedProcess} objects. Otherwise, the *resource index* is
-         * lower than others, of course, much processes will be requested.
-         *
-         * - {@link setResource setResource()}
-         * - {@link enforceResource enforceResource()}
-         *
-         * Unless {@link enforceResource enforceResource()} is called, This *resource index* is **revaluated** whenever
-         * {@link sendData sendData()} is called.
-         *
-         * @return Resource index.
-         */
-        getResource(): number;
-        /**
-         * Set resource index.
-         *
-         * Set *resource index* that indicates how much this {@link DistributedProcess process} is heavy. This
-         * *resource index* can be **revaulated**.
-         *
-         * Note that, initial and average *resource index* of {@link DistributedProcess} objects are ```1.0```. If the
-         * *resource index* is higher than other {@link DistributedProcess} objects, then this
-         * {@link DistributedProcess} will be ordered to handle more processes than other {@link DistributedProcess}
-         * objects. Otherwise, the *resource index* is lower than others, of course, less processes will be requested.
-         *
-         * Unlike {@link enforceResource}, configuring *resource index* by this {@link setResource} allows the
-         * **revaluation**. This **revaluation** prevents wrong valuation from user. For example, you *mis-valuated* the
-         * *resource index*. The {@link DistributedProcess process} is much heavier than any other, but you estimated it
-         * to the lightest one. It looks like a terrible case that causes
-         * {@link DistributedSystemArray entire distributed processing system} to be slower, however, don't mind. The
-         * {@link DistributedProcess process} will the direct to the *propriate resource index* eventually with the
-         * **revaluation**.
-         *
-         * - The **revaluation** is caused by the {@link sendData sendData()} method.
-         *
-         * @param val New resource index, but can be revaluated.
-         */
-        setResource(val: number): void;
-        /**
-         * Enforce resource index.
-         *
-         * Enforce *resource index* that indicates how much heavy the {@link DistributedProcess process is}. The
-         * *resource index* will be fixed, never be **revaluated**.
-         *
-         * Note that, initial and average *resource index* of {@link DistributedProcess} objects are ```1.0```. If the
-         * *resource index* is higher than other {@link DistributedProcess} objects, then this
-         * {@link DistributedProcess} will be ordered to handle more processes than other {@link DistributedProcess}
-         * objects. Otherwise, the *resource index* is lower than others, of course, less processes will be requested.
-         *
-         * The difference between {@link setResource} and this {@link enforceResource} is allowing **revaluation** or not.
-         * This {@link enforceResource} does not allow the **revaluation**. The *resource index* is clearly fixed and
-         * never be changed by the **revaluation**. But you've to keep in mind that, you can't avoid the **mis-valuation**
-         * with this {@link enforceResource}.
-         *
-         * For example, there's a {@link DistributedProcess process} much heavier than any other, but you
-         * **mis-estimated** it to the lightest. In that case, there's no way. The
-         * {@link DistributedSystemArray entire distributed processing system} will be slower by the **mis-valuation**.
-         * By the reason, using {@link enforceResource}, it's recommended only when you can clearly certain the
-         * *resource index*. If you can't certain the *resource index* but want to recommend, then use {@link setResource}
-         * instead.
-         *
-         * @param val New resource index to be fixed.
-         */
-        enforceResource(val: number): void;
-        /**
-         * @hidden
-         */
-        private compute_average_elapsed_time();
-        /**
-         * @inheritdoc
-         */
-        abstract replyData(invoke: protocol.Invoke): void;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * Sends an {@link Invoke} message requesting a **distributed process**. The {@link Invoke} message will be sent
-         * to the most idle {@link DistributedSystem} object, which represents a slave system, and the most idle
-         * {@link DistributedSystem} object will be returned.
-         *
-         * When the **distributed process** has completed, then the {@link DistributedSystemArray} object will revaluate
-         * {@link getResource resource index} and {@link DistributedSystem.getPerformance performance index} of this
-         * {@link DistributedSystem} and the most idle {@link DistributedSystem} objects basis on the execution time.
-         *
-         * @param invoke An {@link Invoke} message requesting distributed process.
-         * @return The most idle {@link DistributedSystem} object who may send the {@link Invoke} message.
-         */
-        sendData(invoke: protocol.Invoke): DistributedSystem;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * Sends an {@link Invoke} message requesting a **distributed process**. The {@link Invoke} message will be sent
-         * to the most idle {@link DistributedSystem} object, which represents a slave system, and the most idle
-         * {@link DistributedSystem} object will be returned.
-         *
-         * When the **distributed process** has completed, then the {@link DistributedSystemArray} object will revaluate
-         * {@link getResource resource index} and {@link DistributedSystem.getPerformance performance index} of this
-         * {@link DistributedSystem} and the most idle {@link DistributedSystem} objects basis on the execution time.
-         *
-         * @param invoke An {@link Invoke} message requesting distributed process.
-         * @param weight Weight of resource which indicates how heavy this {@link Invoke} message is. Default is 1.
-         *
-         * @return The most idle {@link DistributedSystem} object who may send the {@link Invoke} message.
-         */
-        sendData(invoke: protocol.Invoke, weight: number): DistributedSystem;
-        /**
-         * @hidden
-         */
-        private complete_history(history);
-        /**
-         * @inheritdoc
-         */
-        TAG(): string;
-    }
-}
-declare namespace samchon.templates.external {
-    /**
-     * An external system driver.
-     *
-     * The {@link ExternalSystem} class represents an external system, connected and interact with this system.
-     * {@link ExternalSystem} takes full charge of network communication with the remote, external system have connected.
-     * Replied {@link Invoke} messages from the external system is shifted to and processed in, children elements of this
-     * class, {@link ExternalSystemRole} objects.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Bridge & Proxy Pattern
-     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
-     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalSystem extends protocol.EntityDequeCollection<ExternalSystemRole> implements protocol.IProtocol {
-        /**
-         * The name represents external system have connected.
-         */
-        protected name: string;
-        /**
-         * @hidden
-         */
-        private system_array_;
-        /**
-         * @hidden
-         */
-        private communicator_;
-        /**
-         * Construct from parent {@link ExternalSystemArray}.
-         *
-         * @param systemArray The parent {@link ExternalSystemArray} object.
-         */
-        constructor(systemArray: ExternalSystemArray<ExternalSystem>);
-        /**
-         * Constrct from parent {@link ExternalSystemArray} and communicator.
-         *
-         * @param systemArray The parent {@link ExternalSystemArray} object.
-         * @param communicator Communicator with the remote, external system.
-         */
-        constructor(systemArray: ExternalSystemArray<ExternalSystem>, communicator: protocol.IClientDriver);
-        /**
-         * Default Destructor.
-         *
-         * This {@link destructor destructor()} method is called when the {@link ExternalSystem} object is destructed and
-         * the {@link ExternalSystem} object is destructed when connection with the remote system is closed or this
-         * {@link ExternalSystem} object is {@link ExternalSystemArray.erase erased} from its parent
-         * {@link ExternalSystemArray} object.
-         *
-         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
-         * by those *destruction* cases. Also, if your derived {@link ExternalSystem} class has something to do on the
-         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
-         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
-         *
-         * ```typescript
-         * class SomeSystem extends templates.external.ExternalSystem
-         * {
-         *     protected destructor(): void
-         *     {
-         *         // DO SOMETHING
-         *         this.do_something();
-         *
-         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
-         *         super.destructor();
-         *     }
-         * }
-         * ```
-         */
-        protected destructor(): void;
-        /**
-         * @hidden
-         */
-        private handle_close();
-        /**
-         * Get parent {@link ExternalSystemArray} object.
-         */
-        getSystemArray(): ExternalSystemArray<ExternalSystem>;
-        /**
-         * Get parent {@link ExternalSystemArray} object.
-         */
-        getSystemArray<SystemArray extends ExternalSystemArray<ExternalSystem>>(): SystemArray;
-        /**
-         * Identifier of {@link ExternalSystem} is its {@link name}.
-         *
-         * @return name.
-         */
-        key(): string;
-        /**
-         * Get {@link name}.
-         */
-        getName(): string;
-        /**
-         * @hidden
-         */
-        /**
-         * @hidden
-         */
-        protected communicator: protocol.ICommunicator;
-        /**
-         * Close connection.
-         */
-        close(): void;
-        /**
-         * Send {@link Invoke} message to external system.
-         *
-         * @param invoke An {@link Invoke} message to send.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * Handle an {@Invoke} message has received.
-         *
-         * @param invoke An {@link Invoke} message have received.
-         */
-        replyData(invoke: protocol.Invoke): void;
-        /**
-         * Tag name of the {@link ExternalSystem} in {@link XML}.
-         *
-         * @return *system*.
-         */
-        TAG(): string;
-        /**
-         * Tag name of {@link ExternalSystemRole children elements} belonged to the {@link ExternalSystem} in {@link XML}.
-         *
-         * @return *role*.
-         */
-        CHILD_TAG(): string;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * A driver for a parallel slave system.
-     *
-     * The {@link ParallelSystem} is an abstract class represents a **slave** system in *Parallel Processing System*,
-     * connected with this **master** system. This {@link ParallelSystem} takes full charge of network communication with
-     * the remote, parallel **slave** system has connected.
-     *
-     * When a *parallel process* is requested (by {@link ParallelSystemArray.sendSegmentData} or
-     * {@link ParallelSystemArray.sendPieceData}), the number of pieces to be allocated to a {@link ParallelSystem} is
-     * turn on its {@link getPerformance performance index}. Higher {@link getPerformance performance index}, then
-     * more pieces are requested. The {@link getPerformance performance index} is revaluated whenever a *parallel process*
-     * has completed, basic on the execution time and number of pieces. You can sugguest or enforce the
-     * {@link getPerformance performance index} with {@link setPerformance} or {@link enforcePerformance}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Bridge & Proxy Pattern
-     * This class {@link ParallelSystem} is derived from the {@link ExternalSystem} class. Thus, you can take advantage
-     * of the *Bridge & Proxy Pattern* in this {@link ParallelSystem} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Bridge & Proxy Pattern*:
-     *
-     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
-     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelSystem extends external.ExternalSystem {
-        /**
-         * @hidden
-         */
-        private progress_list_;
-        /**
-         * @hidden
-         */
-        private history_list_;
-        /**
-         * @hidden
-         */
-        private exclude_;
-        /**
-         * @hidden
-         */
-        private performance;
-        /**
-         * @hidden
-         */
-        private enforced_;
-        /**
-         * Construct from parent {@link ParallelSystemArray}.
-         *
-         * @param systemArray The parent {@link ParallelSystemArray} object.
-         */
-        constructor(systemArray: ParallelSystemArray<ParallelSystem>);
-        /**
-         * Construct from parent {@link ParallelSystemArray} and communicator.
-         *
-         * @param systemArray The parent {@link ParallelSystemArray} object.
-         * @param communicator A communicator communicates with remote, the external system.
-         */
-        constructor(systemArray: ParallelSystemArray<ParallelSystem>, communicator: protocol.IClientDriver);
-        /**
-         * Default Destructor.
-         *
-         * This {@link destructor destructor()} method is called when the {@link ParallelSystem} object is destructed and
-         * the {@link ParallelSystem} object is destructed when connection with the remote system is closed or this
-         * {@link ParallelSystem} object is {@link ParallelSystemArray.erase erased} from its parent
-         * {@link ParallelSystemArray} object.
-         *
-         * You may think if there're some *parallel processes* have requested but not completed yet, then it would be a
-         * critical problem because the *parallel processes* will not complete forever. Do not worry. The critical problem
-         * does not happen. After the destruction, the remained *parallel processes* will be shifted to and proceeded in
-         * other {@link ParallelSystem} objects.
-         *
-         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
-         * by those *destruction* cases. Also, if your derived {@link ParallelSystem} class has something to do on the
-         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
-         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
-         *
-         * ```typescript
-         * class SomeSystem extends protocol.external.ExternalSystem
-         * {
-         *     protected destructor(): void
-         *     {
-         *         // DO SOMETHING
-         *         this.do_something();
-         *
-         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
-         *         super.destructor();
-         *     }
-         * }
-         * ```
-         */
-        protected destructor(): void;
-        /**
-         * Get manager of this object.
-         *
-         * @return The parent {@link ParallelSystemArray} object.
-         */
-        getSystemArray(): ParallelSystemArray<ParallelSystem>;
-        /**
-         * Get manager of this object.
-         *
-         * @return The parent {@link ParallelSystemArray} object.
-         */
-        getSystemArray<SystemArray extends ParallelSystemArray<ParallelSystem>>(): SystemArray;
-        /**
-         * Get performance index.
-         *
-         * Get *performance index* that indicates how much fast the remote system is.
-         *
-         * If this {@link ParallelSystem parallel system} does not have any {@link Invoke} message had handled, then the
-         * *performance index* will be ```1.0```, which means default and average value between all {@link ParallelSystem}
-         * instances (that are belonged to a same {@link ParallelSystemArray} object).
-         *
-         * You can specify this *performance index* by yourself but notice that, if the *performance index* is higher
-         * than other {@link ParallelSystem} objects, then this {@link ParallelSystem parallel system} will be ordered to
-         * handle more processes than other {@link ParallelSystem} objects. Otherwise, the *performance index* is lower
-         * than others, of course, less processes will be delivered.
-         *
-         * - {@link setPerformance setPerformance()}
-         * - {@link enforcePerformance enforcePerformance()}
-         *
-         * Unless {@link enforcePerformance enforcePerformance()} is called, This *performance index* is **revaluated**
-         * whenever user calls one of them below.
-         *
-         * - {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()}
-         * - {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()}
-         * - {@link DistributedProcess.sendData DistributedProcess.sendData()}.
-         *
-         * @return Performance index.
-         */
-        getPerformance(): number;
-        /**
-         * Set performance index.
-         *
-         * Set *performance index* that indicates how much fast the remote system is. This *performance index* can be
-         * **revaulated**.
-         *
-         * Note that, initial and average *performance index* of {@link ParallelSystem} objects are ```1.0```. If the
-         * *performance index* is higher than other {@link ParallelSystem} objects, then this {@link ParallelSystem} will
-         * be ordered to handle more processes than other {@link ParallelSystem} objects. Otherwise, the
-         * *performance index* is lower than others, of course, less processes will be delivered.
-         *
-         * Unlike {@link enforcePerformance}, configuring *performance index* by this {@link setPerformance} allows
-         * **revaluation**. This **revaluation** prevents wrong valuation from user. For example, you *mis-valuated* the
-         * *performance index*. The remote system is much faster than any other, but you estimated it to the slowest one.
-         * It looks like a terrible case that causes {@link ParallelSystemArray entire parallel systems} to be slower,
-         * however, don't mind. The system will direct to the *propriate performance index* eventually with the
-         * **revaluation** by following methods.
-         *
-         * - {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()}
-         * - {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()}
-         * - {@link DistributedProcess.sendData DistributedProcess.sendData()}.
-         *
-         * @param val New performance index, but can be revaluated.
-         */
-        setPerformance(val: number): void;
-        /**
-         * Enforce performance index.
-         *
-         * Enforce *performance index* that indicates how much fast the remote system is. The *performance index* will be
-         * fixed, never be **revaluated**.
-         *
-         * Note that, initial and average *performance index* of {@link ParallelSystem} objects are ```1.0```. If the
-         * *performance index* is higher than other {@link ParallelSystem} objects, then this {@link ParallelSystem} will
-         * be ordered to handle more processes than other {@link ParallelSystem} objects. Otherwise, the
-         * *performance index* is lower than others, of course, less processes will be delivered.
-         *
-         * The difference between {@link setPerformance} and this {@link enforcePerformance} is allowing **revaluation**
-         * or not. This {@link enforcePerformance} does not allow the **revaluation**. The *performance index* is clearly
-         * fixed and never be changed by the **revaluation**. But you've to keep in mind that, you can't avoid the
-         * **mis-valuation** with this {@link enforcePerformance}.
-         *
-         * For example, there's a remote system much faster than any other, but you **mis-estimated** it to the slowest.
-         * In that case, there's no way. The {@link ParallelSystemArray entire parallel systems} will be slower by the
-         * **mis-valuation**. By the reason, using {@link enforcePerformance}, it's recommended only when you can clearly
-         * certain the *performance index*. If you can't certain the *performance index* but want to recommend, then use
-         * {@link setPerformance} instead.
-         *
-         * @param val New performance index to be fixed.
-         */
-        enforcePerformance(val: number): void;
-        /**
-         * @hidden
-         */
-        private send_piece_data(invoke, first, last);
-        /**
-         * @hidden
-         */
-        private _replyData(invoke);
-        /**
-         * @hidden
-         */
-        protected _Report_history(xml: library.XML): void;
-        /**
-         * @hidden
-         */
-        protected _Send_back_history(invoke: protocol.Invoke, history: protocol.InvokeHistory): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * A driver for a distributed slave system.
-     *
-     * The {@link DistributedSystem} is an abstract class represents a **slave** system in *Distributed Processing System*,
-     * connected with this **master** system. This {@link DistributedSystem} takes full charge of network communication
-     * with the remote, distributed **slave** system has connected.
-     *
-     * This {@link DistributedSystem} has a {@link getPerformance performance index} that indicates how much the **slave**
-     * system is fast. The {@link getPerformance performance index} is referenced and revaluated whenever those methods
-     * are called:
-     *
-     * - Requesting a *parallel process*
-     *   - {@link DistributedSystemArray.sendSegmentData}
-     *   - {@link DistributedSystemArray.sendPieceData}
-     * - Requesting a *distributed process*: {@link DistributedProcess.sendData}
-     *
-     * Note that, this {@link DistributedSystem} class derived from the {@link ExternalSystem} class. Thus, this
-     * {@link DistributedSystem} can also have children {@link ExternalSystemRole} objects exclusively. However, the
-     * children {@link ExternalSystemRole roles} objects are different with the {@link DistributedProcess}. The
-     * domestic {@link ExternalSystemRole roles} are belonged to only a specific {@link DistributedSystem} object.
-     * Otherwise, the {@link DistributedProcess} objects are belonged to a {@link DistributedSystemArray} object.
-     * Furthermore, the relationship between this {@link DistributedSystem} and {@link DistributedProcess} classes are
-     * **M: N Associative**.
-     *
-     * Articles     | {@link DistributedProcess}     | {@link ExternalSystemRole}
-     * -------------|--------------------------------|----------------------------
-     * Belonged to  | {@link DistributedSystemArray} | {@link DistributedSystem}
-     * Relationship | M: N Associative               | 1: N Composite
-     * Ownership    | References                     | Exclusive possession
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedSystem extends parallel.ParallelSystem {
-        /**
-         * Construct from parent {@link DistributedSystemArray}.
-         *
-         * @param systemArray The parent {@link DistributedSystemArray} object.
-         */
-        constructor(systemArray: DistributedSystemArray<DistributedSystem>);
-        /**
-         * Constrct from parent {@link DistributedSystemArray} and communicator.
-         *
-         * @param systemArray The parent {@link DistributedSystemArray} object.
-         * @param communicator A communicator communicates with remote, the external system.
-         */
-        constructor(systemArray: DistributedSystemArray<DistributedSystem>, communicator: protocol.IClientDriver);
-        /**
-         * Factory method creating a {@link ExternalSystemRole child} object.
-         *
-         * In {@link distributed} module, the process class {@link DistributedProcess} is not belonged to a specific
-         * {@link DistributedSystem} object. It only belongs to a {@link DistributedSystemArray} object and has a
-         * **M: N Associative Relationship** between this {@link DistributedSystem} class.
-         *
-         * By that reason, it's the normal case that the {@link DistributedSystem} object does not have any children
-         * {@link ExternalSystemRole} object. Thus, default {@link createChild} returns ```null```.
-         *
-         * However, if you want a {@link DistributedSystem} to have its own domestic {@link ExternalSystemRole} objects
-         * without reference to the {@link DistributedProcess} objects, it is possible. Creates and returns the
-         * domestic {@link ExternalSystemRole} object.
-         *
-         * @param xml {@link XML} represents the {@link ExternalSystemRole child} object.
-         * @return A newly created {@link ExternalSystemRole} object or ```null```.
-         */
-        createChild(xml: library.XML): external.ExternalSystemRole;
-        /**
-         * Get manager of this object.
-         *
-         * @return The parent {@link DistributedSystemArray} object.
-         */
-        getSystemArray(): DistributedSystemArray<DistributedSystem>;
-        /**
-         * Get manager of this object.
-         *
-         * @return The parent {@link DistributedSystemArray} object.
-         */
-        getSystemArray<SystemArray extends DistributedSystemArray<DistributedSystem>>(): SystemArray;
-        /**
-         * @hidden
-         */
-        private compute_average_elapsed_time();
-        /**
-         * @inheritdoc
-         */
-        replyData(invoke: protocol.Invoke): void;
-        /**
-         * @hidden
-         */
-        protected _Report_history(xml: library.XML): void;
-        /**
-         * @hidden
-         */
-        protected _Send_back_history(invoke: protocol.Invoke, history: protocol.InvokeHistory): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * An interface for a distributed slave server driver.
-     *
-     * The easiest way to defining a driver for distributed **slave** server is extending {@link DistributedServer} class.
-     * However, if you've to interact with a prallel **slave** system who can be both server and client, them make a class
-     * (let's name it **BaseSystem**) extending the {@link DistributedServer} class. At next, make a new class (now, I name
-     * it **BaseServer**) extending the **BaseSystem** and implements this interface {@link IParallelServer}. Define the
-     * **BaseServer** following those codes on below:
-     *
-     * <ul>
-     *	<li> {@link ExternalServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IDistributedServer extends DistributedSystem {
-        /**
-         * Connect to external server.
-         */
-        connect(): void;
-    }
-    /**
-     * A driver for distributed slave server.
-     *
-     * The {@link DistributedServer} is an abstract class, derived from the {@link DistributedSystem} class, connecting to
-     * remote, distributed **slave** server. Extends this {@link DistributedServer} class and overrides the
-     * {@link createServerConnector createServerConnector()} method following which protocol the **slave** server uses.
-     *
-     * #### [Inheritdoc] {@link DistributedSystem}
-     * The {@link DistributedSystem} is an abstract class represents a **slave** system in *Distributed Processing System*,
-     * connected with this **master** system. This {@link DistributedSystem} takes full charge of network communication
-     * with the remote, distributed **slave** system has connected.
-     *
-     * This {@link DistributedSystem} has a {@link getPerformance performance index} that indicates how much the **slave**
-     * system is fast. The {@link getPerformance performance index} is referenced and revaluated whenever those methods
-     * are called:
-     *
-     * - Requesting a *parallel process*
-     *   - {@link DistributedSystemArray.sendSegmentData}
-     *   - {@link DistributedSystemArray.sendPieceData}
-     * - Requesting a *distributed process*: {@link DistributedProcess.sendData}
-     *
-     * Note that, this {@link DistributedSystem} class derived from the {@link ExternalSystem} class. Thus, this
-     * {@link DistributedSystem} can also have children {@link ExternalSystemRole} objects exclusively. However, the
-     * children {@link ExternalSystemRole roles} objects are different with the {@link DistributedProcess}. The
-     * domestic {@link ExternalSystemRole roles} are belonged to only a specific {@link DistributedSystem} object.
-     * Otherwise, the {@link DistributedProcess} objects are belonged to a {@link DistributedSystemArray} object.
-     * Furthermore, the relationship between this {@link DistributedSystem} and {@link DistributedProcess} classes are
-     * **M: N Associative**.
-     *
-     * Articles     | {@link DistributedProcess}     | {@link ExternalSystemRole}
-     * -------------|--------------------------------|----------------------------
-     * Belonged to  | {@link DistributedSystemArray} | {@link DistributedSystem}
-     * Relationship | M: N Associative               | 1: N Composite
-     * Ownership    | References                     | Exclusive possession
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedServer extends DistributedSystem implements external.IExternalServer {
-        /**
-         * IP address of target external system to connect.
-         */
-        protected ip: string;
-        /**
-         * Port number of target external system to connect.
-         */
-        protected port: number;
-        /**
-         * Construct from parent {@link DistributedSystemArray}.
-         *
-         * @param systemArray The parent {@link DistributedSystemArray} object.
-         */
-        constructor(systemArray: DistributedSystemArray<DistributedSystem>);
-        /**
-         * Factory method creating {@link IServerConnector} object.
-         *
-         * The {@link createServerConnector createServerConnector()} is an abstract method creating
-         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the slave server
-         * follows:
-         *
-         * - {@link ServerConnector}
-         * - {@link WebServerConnector}
-         * - {@link DedicatedWorkerServerConnector}
-         * - {@link SharedWorkerServerConnector}
-         *
-         * @return A newly created {@link IServerConnector} object.
-         */
-        protected abstract createServerConnector(): protocol.IServerConnector;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * Master of Distributed Processing System, a client connecting to slave servers.
-     *
-     * The {@link DistributedServerArray} is an abstract class, derived from the {@link DistributedSystemArray} class,
-     * connecting to {@link IDistributedServer distributed servers}.
-     *
-     * Extends this {@link DistributedServerArray} and overrides {@link createChild createChild()} method creating child
-     * {@link IDistributedServer} object. After the extending and overriding, construct children {@link IDistributedServer}
-     * objects and call the {@link connect connect()} method.
-     *
-     * #### [Inherited] {@link DistributedSystemArray}
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedServerArray<System extends IDistributedServer> extends DistributedSystemArray<System> implements external.IExternalServerArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * Mediator of Distributed Processing System, a client connecting to slave servers.
-     *
-     * The {@link DistributedServerArrayMediator} is an abstract class, derived from {@link DistributedSystemArrayMediator}
-     * class, connecting to {@link IDistributedServer distributed servers}.
-     *
-     * Extends this {@link DistributedServerArrayMediator} and overrides {@link createChild createChild()} method creating
-     * child {@link IDistributedServer} object. After the extending and overriding, construct children
-     * {@link IDistributedServer} objects and call the {@link connect connect()} method.
-     *
-     * #### [Inherited] {@link DistributedSystemArrayMediator}
-     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
-     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
-     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
-     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
-     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link DistributedSystemArray}
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedServerArrayMediator<System extends IDistributedServer> extends DistributedSystemArrayMediator<System> implements external.IExternalServerArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * Master of Distributed Processing System, be a server and client at the same time.
-     *
-     * The {@link DistributedServerClientArray} is an abstract class, derived from the {@link DistributedSystemArray}
-     * class, opening a server accepting {@link Distributed distributed clients} and being a client connecting to
-     * {@link IDistributedServer distributed servers} at the same time.
-     *
-     * Extends this {@link DistributedServerClientArray} and overrides below methods. After the overridings, open server
-     * with {@link open open()} method and connect to {@link IDistributedServer distributed servers} through the
-     * {@link connect connect()} method.
-     *
-     * - {@link createServerBase createServerBase()}
-     * - {@link createExternalClient createExternalClient()}
-     * - {@link createExternalServer createExternalServer()}
-     *
-     * #### [Inherited] {@link DistributedSystemArray}
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedServerClientArray<System extends DistributedSystem> extends DistributedClientArray<System> implements external.IExternalServerClientArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method of a child Entity.
-         *
-         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating an {@link IDistributedServer} object.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A newly created {@link IDistributedServer} object.
-         */
-        protected abstract createExternalServer(xml: library.XML): System;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * Mediator of Distributed Processing System, be a server and client at the same time as a **master**.
-     *
-     * The {@link DistributedServerClientArrayMediator} is an abstract class, derived from the
-     * {@link DistributedSystemArrayMediator} class, opening a server accepting {@link DistributedSystem distributed
-     * clients} and being a client connecting to {@link IDistributedServer distributed servers} at the same time.
-     *
-     * Extends this {@link DistributedServerClientArrayMediator} and overrides below methods. After the overridings, open
-     * server with {@link open open()} method and connect to {@link IDistributedServer distributed servers} through the
-     * {@link connect connect()} method.
-     *
-     * - {@link createServerBase createServerBase()}
-     * - {@link createExternalClient createExternalClient()}
-     * - {@link createExternalServer createExternalServer()}
-     *
-     * #### [Inherited] {@link DistributedSystemArrayMediator}
-     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
-     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
-     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
-     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
-     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link DistributedSystemArray}
-     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
-     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
-     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
-     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
-     * requested the *distributed processes*.
-     *
-     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
-     * **distributed process** through the {@link DistributedProcess} object. You can access the
-     * {@link DistributedProcess} object(s) with those methods:
-     *
-     * - {@link hasProcess}
-     * - {@link getProcess}
-     * - {@link insertProcess}
-     * - {@link eraseProcess}
-     * - {@link getProcessMap}
-     *
-     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
-     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
-     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
-     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
-     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Parallel Process
-     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
-     * a **parallel process**, too.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
-     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * #### Proxy Pattern
-     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class DistributedServerClientArrayMediator<System extends DistributedSystem> extends DistributedClientArrayMediator<System> implements external.IExternalServerClientArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method of a child Entity.
-         *
-         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating an {@link IDistributedServer} object.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A newly created {@link IDistributedServer} object.
-         */
-        protected abstract createExternalServer(xml: library.XML): System;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.distributed {
-    /**
-     * History of an {@link Invoke} message.
-     *
-     * The {@link PRInvokeHistory} is a class archiving history log of an {@link Invoke} message which requests the
-     * *distributed process*, created whenever {@link DistributedProcess.sendData} is called.
-     *
-     * When the *distributed process* has completed, then {@link complete complete()} is called and the *elapsed time* is
-     * determined. The elapsed time is utilized for computation of {@link DistributedSystem.getPerformance performance index}
-     * and {@link DistributedProcess.getResource resource index} of related objects.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DSInvokeHistory extends protocol.InvokeHistory {
-        /**
-         * @hidden
-         */
-        private system_;
-        /**
-         * @hidden
-         */
-        private process_;
-        /**
-         * @hidden
-         */
-        private weight_;
-        /**
-         * Construct from a DistributedSystem.
-         *
-         * @param system The {@link DistributedSystem} object who sent the {@link Invoke} message.
-         */
-        constructor(system: DistributedSystem);
-        /**
-         * Initilizer Constructor.
-         *
-         * @param system The {@link DistributedSystem} object who sent the {@link Invoke} message.
-         * @param process The {@link DistributedProcess} object who sent the {@link Invoke} message.
-         * @param invoke An {@link Invoke} message requesting the *distributed process*.
-         * @param weight Weight of resource which indicates how heavy this {@link Invoke} message is.
-         */
-        constructor(system: DistributedSystem, process: DistributedProcess, invoke: protocol.Invoke, weight: number);
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * Get the related {@link DistributedSystem} object.
-         */
-        getSystem(): DistributedSystem;
-        /**
-         * Get the related {@link DistributedProcess} object.
-         */
-        getProcess(): DistributedProcess;
-        /**
-         * Get weight.
-         *
-         * Gets weight of resource which indicates how heavy this {@link Invoke} message is. Default is 1.
-         */
-        getWeight(): number;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.templates.external {
-    /**
-     * An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
-     * {@link IServer server}.
-     *
-     * The easiest way to defining an {@link ExternalSystemArray} who opens server and accepts
-     * {@link ExternalSystem external clients} is to extending one of below, who are derived from this interface
-     * {@link IExternalClientArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
-     * client, then make a class (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make
-     * a new class (now, I name it **BaseClientArray**) extending **BaseSystemArray** and implementing this
-     * interface {@link IExternalClientArray}. Define the **BaseClientArray** following those codes on below:
-     *
-     * <ul>
-     *	<li> {@link ExternalClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IExternalClientArray<System extends ExternalSystem> extends ExternalSystemArray<System>, protocol.IServer {
-    }
-    /**
-     * An array and manager of {@link ExternalSystem external clients} as a server.
-     *
-     * The {@link ExternalClientArray} is an abstract class, derived from the {@link ExternalSystemArray} class, opening
-     * a server accepting {@link ExternalSystem external clients}.
-     *
-     * Extends this {@link ExternalClientArray}, overrides {@link createServerBase createServerBase()} to determine which
-     * protocol to follow and {@link createExternalClient createExternalClient()} creating child {@link ExternalSystem}
-     * object. After the extending and overridings, open this server using the {@link open open()} method.
-     *
-     * #### [Inherited] {@link ExternalSystemArray}
-     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
-     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
-     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
-     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalClientArray<T extends ExternalSystem> extends ExternalSystemArray<T> implements IExternalClientArray<T> {
-        /**
-         * @hidden
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating {@link IServerBase} object.
-         *
-         * This method {@link createServerBase createServerBase()} determines which templates is used in this server,
-         * {@link ExternalClientArray}. If the templates is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified templates.
-         *
-         * Creates and returns one of them:
-         *
-         * - {@link ServerBase}
-         * - {@link WebServerBase}
-         * - {@link SharedWorkerServerBase}
-         *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): protocol.IServerBase;
-        /**
-         * Add a newly connected remote client.
-         *
-         * When a {@link IClientDriver remote client} connects to this *server* {@link ExternalClientArray} object,
-         * then this {@link ExternalClientArray} creates a child {@link ExternalSystem external client} object through
-         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
-         *
-         * @param driver A communicator for external client.
-         */
-        addClient(driver: protocol.IClientDriver): void;
-        /**
-         * (Deprecated) Factory method creating child object.
-         *
-         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
-         *
-         * Note that, the {@link ExternalClientArray} is a server accepting {@link ExternalSystem external clients}.
-         * There's no way to creating the {@link ExternalSystem external clients} in advance before opening the server.
-         *
-         * @param xml An {@link XML} object represents the child {@link ExternalSystem} object.
-         * @return null
-         */
-        createChild(xml: library.XML): T;
-        /**
-         * Factory method creating a child {@link ExternalSystem} object.
-         *
-         * @param driver A communicator with connected client.
-         * @return A newly created {@link ExternalSystem} object.
-         */
-        protected abstract createExternalClient(driver: protocol.IClientDriver): T;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.templates.external {
-    /**
-     * An interface for an external server driver.
-     *
-     * The easiest way to defining an external server driver is to extending one of below, who are derived from this
-     * interface {@link IExternalServer}. However, if you've to interact with an external system who can be both server
-     * and client, then make a class (let's name it as **BaseSystem**) extending {@link ExternalSystem} and make a
-     * new class (now, I name it **BaseServer**) extending **BaseSystem** and implementing this interface
-     * {@link IExternalServer}. Define the **BaseServer** following those codes on below:
-     *
-     * <ul>
-     *	<li> {@link ExternalServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IExternalServer extends ExternalSystem {
-        /**
-         * Connect to external server.
-         */
-        connect(): void;
-    }
-    /**
-     * An external server driver.
-     *
-     * The {@link ExternalServer} is an abstract class, derived from the {@link ExternalSystem} class, connecting to
-     * remote, external server. Extends this {@link ExternalServer} class and overrides the
-     * {@link createServerConnector createServerConnector()} method following which protocol the external server uses.
-     *
-     * #### [Inherited] {@link ExternalSystem}
-     * The {@link ExternalSystem} class represents an external system, connected and interact with this system.
-     * {@link ExternalSystem} takes full charge of network communication with the remote, external system have connected.
-     * Replied {@link Invoke} messages from the external system is shifted to and processed in, children elements of this
-     * class, {@link ExternalSystemRole} objects.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Bridge & Proxy Pattern
-     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
-     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalServer extends ExternalSystem implements IExternalServer {
-        /**
-         * IP address of target external system to connect.
-         */
-        protected ip: string;
-        /**
-         * Port number of target external system to connect.
-         */
-        protected port: number;
-        /**
-         * Construct from parent {@link ExternalSystemArray}.
-         *
-         * @param systemArray The parent {@link ExternalSystemArray} object.
-         */
-        constructor(systemArray: ExternalSystemArray<IExternalServer>);
-        /**
-         * Factory method creating {@link IServerConnector} object.
-         *
-         * The {@link createServerConnector createServerConnector()} is an abstract method creating
-         * {@link IServerConnector} object. Overrides and returns one of them, considering which templates the external
-         * system follows:
-         *
-         * - {@link ServerConnector}
-         * - {@link WebServerConnector}
-         * - {@link DedicatedWorkerServerConnector}
-         * - {@link SharedWorkerServerConnector}
-         *
-         * @return A newly created {@link IServerConnector} object.
-         */
-        protected abstract createServerConnector(): protocol.IServerConnector;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.external {
-    /**
-     * An interface for an {@link ExternalSystemArray} connects to {@link IExternalServer external servers} as a
-     * **client**.
-     *
-     * The easiest way to defining an {@link ExternalSystemArray} who connects to
-     * {@link IExternalServer external servers} is to extending one of below, who are derived from this interface
-     * {@link IExternalServerArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
-     * client, then make a class (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make
-     * a new class (now, I name it **BaseServerArray**) extending **BaseSystemArray** and implementing this
-     * interface {@link IExternalServerArray}. Define the **BaseServerArray** following those codes on below:
-     *
-     * <ul>
-     *	<li> {@link ExternalServerArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServerArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelServerArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelServerArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedServerArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedServerArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IExternalServerArray<System extends IExternalServer> extends ExternalSystemArray<System> {
-        /**
-         * Connect to {@link IExternalServer external servers}.
-         *
-         * This method calls children elements' method {@link IExternalServer.connect} gradually.
-         */
-        connect(): void;
-    }
-    /**
-     * An array and manager of {@link IExternalServer external servers}.
-     *
-     * The {@link ExternalServerArray} is an abstract class, derived from the {@link ExternalSystemArray} class,
-     * connecting to {@link IExternalServer external servers}.
-     *
-     * Extends this {@link ExternalServerArray} and overrides {@link createChild createChild()} method creating child
-     * {@link IExternalServer} object. After the extending and overriding, construct children {@link IExternalServer}
-     * objects and call the {@link connect connect()} method.
-     *
-     * #### [Inherited] {@link ExternalSystemArray}
-     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
-     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
-     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
-     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalServerArray<T extends IExternalServer> extends ExternalSystemArray<T> implements IExternalServerArray<T> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.external {
-    /**
-     * An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
-     * {@link IServer server} and connects to {@link IExternalServer} as **client**, at the same time.
-     *
-     * The easiest way to defining an {@link IExternalServerClientArray} who opens server, accepts
-     * {@link ExternalSystem external clients} and connects to {@link IExternalServer external servers} is to extending
-     * one of below, who are derived from this interface {@link IExternalServerClientArray}. However, if you can't
-     * specify an {@link ExternalSystemArray} to be whether server or client or even can both them, then make a class
-     * (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make a new class (now, I name
-     * it **BaseServerClientArray**) extending **BaseSystemArray** and implementing this interface
-     * {@link IExternalServerClientArray}. Define the **BaseServerClientArray** following those codes on below:
-     *
-     * <ul>
-     *	<li> {@link ExternalServerClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServerClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelServerClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelServerClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedServerClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedServerClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IExternalServerClientArray<System extends ExternalSystem> extends IExternalClientArray<System> {
-        /**
-         * Connect to {@link IExternalServer external servers}.
-         *
-         * This method calls children elements' method {@link IExternalServer.connect} gradually.
-         */
-        connect(): void;
-    }
-    /**
-     * An array and manager of {@link IExternalServer external servers} and {@link ExternalSystem external clients}.
-     *
-     * The {@link ExternalServerClientArray} is an abstract class, derived from the {@link ExternalSystemArray} class,
-     * opening a server accepting {@link ExternalSystem external clients} and being a client connecting to
-     * {@link IExternalServer external servers} at the same time.
-     *
-     * Extends this {@link ExternalServerClientArray} and overrides below methods. After the overridings, open server
-     * with {@link open open()} method and connect to {@link IExternalServer external servers} through the
-     * {@link connect connect()} method.
-     *
-     * - {@link createServerBase createServerBase()}
-     * - {@link createExternalClient createExternalClient()}
-     * - {@link createExternalServer createExternalServer()}
-     *
-     * #### [Inherited] {@link ExternalSystemArray}
-     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
-     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
-     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
-     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalServerClientArray<T extends ExternalSystem> extends ExternalClientArray<T> implements IExternalServerClientArray<T> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method of a child Entity.
-         *
-         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
-         */
-        createChild(xml: library.XML): T;
-        /**
-         * Factory method creating an {@link IExternalServer} object.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A newly created {@link IExternalServer} object.
-         */
-        protected abstract createExternalServer(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.external {
-    /**
-     * A role of an external system.
-     *
-     * The {@link ExternalSystemRole} class represents a role, *WHAT TO DO*. Extends the {@link ExternalSystemRole} class
-     * and overrides {@link replyData replyData()} to define the *WHAT TO DO*. And assign this {@link ExternalSystemRole}
-     * object to related {@link ExternalSystem} object.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * The {@link ExternalSystemRole} class can be an *logical proxy*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem} object, via {@link ExternalSystemArray.getRole ExternalSystemArray.getRole()}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalSystemRole extends protocol.Entity implements protocol.IProtocol {
-        /**
-         * @hidden
-         */
-        private system;
-        /**
-         * A name, represents and identifies this {@link ExternalSystemRole role}.
-         *
-         * This {@link name} is an identifier represents this {@link ExternalSystemRole role}. This {@link name} is
-         * used in {@link ExternalSystemArray.getRole} and {@link ExternalSystem.get}, as a key elements. Thus, this
-         * {@link name} should be unique in an {@link ExternalSystemArray}.
-         */
-        protected name: string;
-        /**
-         * Constructor from a system.
-         *
-         * @param system An external system containing this role.
-         */
-        constructor(system: ExternalSystem);
-        /**
-         * Identifier of {@link ExternalSystemRole} is its {@link name}.
-         */
-        key(): string;
-        /**
-         * Get grandparent {@link ExternalSystemArray}.
-         *
-         * Get the grandparent {@link ExternalSystemArray} object through this parent {@link ExternalSystem},
-         * {@link ExternalSystem.getSystemArray ExternalSystem.getSystemArray()}.
-         *
-         * @return The grandparent {@link ExternalSystemArray} object.
-         */
-        getSystemArray(): ExternalSystemArray<ExternalSystem>;
-        /**
-         * Get parent {@link ExternalSystemRole} object.
-         */
-        getSystem(): ExternalSystem;
-        /**
-         * Get name, who represents and identifies this role.
-         */
-        getName(): string;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * Sends an {@link Invoke} message to remote system through the parent {@link ExternalSystem} object.
-         *
-         * @param invoke An {@link Invoke} message to send to the external system.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * Handle replied {@link Invoke} message.
-         *
-         * {@link ExternalSystemRole.replyData ExternalSystemRole.replyData()} is an abstract method handling a replied
-         * {@link Invoke message} gotten from remote system via parent {@link ExternalSystem} object. Overrides this
-         * method and defines the *WHAT TO DO* with the {@link Invoke message}.
-         *
-         * @param invoke An {@link Invoke} message received from the {@link ExternalSystem external system}.
-         */
-        abstract replyData(invoke: protocol.Invoke): void;
-        /**
-         * Tag name of the {@link ExternalSytemRole} in {@link XML}.
-         *
-         * @return *role*.
-         */
-        TAG(): string;
-    }
-}
-declare namespace samchon.templates.slave {
-    abstract class SlaveSystem implements protocol.IProtocol {
-        /**
-         * @hidden
-         */
-        protected communicator_: protocol.ICommunicator;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * @hidden
-         */
-        protected _replyData(invoke: protocol.Invoke): void;
-        replyData(invoke: protocol.Invoke): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * A mediator, the master driver.
-     *
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class MediatorSystem extends slave.SlaveSystem {
-        /**
-         * @hidden
-         */
-        private system_array_;
-        /**
-         * @hidden
-         */
-        private progress_list_;
-        /**
-         * Construct from parent {@link ParallelSystemArrayMediator} object.
-         *
-         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
-         */
-        constructor(systemArray: ParallelSystemArrayMediator<ParallelSystem>);
-        /**
-         * Construct from parent {@link DistributedSystemArrayMediator} object.
-         *
-         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
-         */
-        constructor(systemArray: distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>);
-        /**
-         * Start interaction.
-         *
-         * The {@link start start()} is an abstract method starting interaction with the **master** system. If the
-         * **master** is a server, then connects to the **master**. Otherwise, the **master** is client, then this
-         * {@link MediatorSystem} object wil open a server accepting the **master**.
-         */
-        abstract start(): void;
-        /**
-         * Get parent {@link ParallelSystemArrayMediator} or {@link DistributedSystemArrayMediator} object.
-         */
-        getSystemArray(): ParallelSystemArrayMediator<ParallelSystem> | distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>;
-        /**
-         * Get parent {@link ParallelSystemArrayMediator} object.
-         */
-        getSystemArray<SystemArray extends ParallelSystemArray<ParallelSystem>>(): SystemArray;
-        /**
-         * Get parent {@link DistributedSystemArrayMediator} object.
-         */
-        getSystemArray<SystemArray extends distributed.DistributedSystemArray<distributed.DistributedSystem>>(): SystemArray;
-        /**
-         * @hidden
-         */
-        private complete_history(uid);
-        /**
-         * @hidden
-         */
-        protected _replyData(invoke: protocol.Invoke): void;
-        /**
-         * @inheritdoc
-         */
-        replyData(invoke: protocol.Invoke): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * A mediator server, driver for the master client.
-     *
-     * The {@link MediatorServer} is a class opening a server accepting the **master** client, following the protocol of
-     * Samchon Framework's own.
-     *
-     * #### [Inherited] {@link MediatorSystem}
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MediatorServer extends MediatorSystem implements slave.ISlaveServer {
-        /**
-         * @hidden
-         */
-        private server_base_;
-        /**
-         * @hidden
-         */
-        private port;
-        /**
-         * Initializer Constructor.
-         *
-         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
-         * @param port Port number of server to open.
-         */
-        constructor(systemArray: ParallelSystemArrayMediator<ParallelSystem>, port: number);
-        /**
-         * Initializer Constructor.
-         *
-         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
-         * @param port Port number of server to open.
-         */
-        constructor(systemArray: distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>, port: number);
-        /**
-         * Factory method creating {@link IServerBase} object.
-         *
-         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link MediatorServer}. Note that, **slave** (this {@link MediatorServer} object) must follow the **master**'s
-         * protocol.
-         *
-         * Overrides and return one of them considering the which protocol to follow:
-         *
-         * - {@link ServerBase}
-         * - {@link WebServerBase}
-         * - {@link SharedWorkerServerBase}
-         */
-        protected createServerBase(): protocol.IServerBase;
-        /**
-         * Add a newly connected remote client.
-         *
-         * {@link MediatorServer} represents a **slave** dedicating to its **master**. In that reason, the
-         * {@link MediatorServer} does not accept multiple **master** clients. It accepts only one. Thus, *listener* of
-         * the *communicator* is {@link MediatorSystem} object, itself.
-         *
-         * @param driver A communicator with remote client.
-         */
-        addClient(driver: protocol.IClientDriver): void;
-        /**
-         * @inheritdoc
-         */
-        start(): void;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-    /**
-     * A mediator server, driver for the master client.
-     *
-     * The {@link MediatorWebServer} is a class opening a server accepting the **master** client, following the
-     * web-socket protocol.
-     *
-     * #### [Inherited] {@link MediatorSystem}
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MediatorWebServer extends MediatorServer {
-        /**
-         * @inheritdoc
-         */
-        protected createServerBase(): protocol.IServerBase;
-    }
-    /**
-     * A mediator server, driver for the master client.
-     *
-     * The {@link MediatorDedicatedWorkerServer} is a class opening a server accepting the **master** client, following
-     * the DedicatedWorker's protocol.
-     *
-     * #### [Inherited] {@link MediatorSystem}
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MediatorDedicatedWorkerServer extends MediatorServer {
-        /**
-         * @inheritdoc
-         */
-        protected createServerBase(): protocol.IServerBase;
-    }
-    /**
-     * A mediator server, driver for the master client.
-     *
-     * The {@link MediatorSharedWorkerServer} is a class opening a server accepting the **master** client, following the
-     * SharedWorker's protocol.
-     *
-     * #### [Inherited] {@link MediatorSystem}
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MediatorSharedWorkerServer extends MediatorServer {
-        /**
-         * @inheritdoc
-         */
-        protected createServerBase(): protocol.IServerBase;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * A mediator client, driver for the master server.
-     *
-     * The {@link MediatorServer} is a class being a client connecting to the **master** server, following the protocol
-     * of Samchon Framework's own.
-     *
-     * #### [Inherited] {@link MediatorSystem}
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MediatorClient extends MediatorSystem implements slave.ISlaveClient {
-        /**
-         * @hidden
-         */
-        private ip;
-        /**
-         * @hidden
-         */
-        private port;
-        /**
-         * Initializer Constructor.
-         *
-         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
-         * @param ip IP address to connect.
-         * @param port Port number to connect.
-         */
-        constructor(systemArray: ParallelSystemArrayMediator<ParallelSystem>, ip: string, port: number);
-        /**
-         * Initializer Constructor.
-         *
-         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
-         * @param ip IP address to connect.
-         * @param port Port number to connect.
-         */
-        constructor(systemArray: distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>, ip: string, port: number);
-        /**
-         * Factory method creating {@link IServerConnector} object.
-         *
-         * The {@link createServerConnector createServerConnector()} is an abstract method creating
-         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the **master**
-         * server follows:
-         *
-         * - {@link ServerConnector}
-         * - {@link WebServerConnector}
-         * - {@link SharedWorkerServerConnector}
-         *
-         * @return A newly created {@link IServerConnector} object.
-         */
-        protected createServerConnector(): protocol.IServerConnector;
-        /**
-         * @inheritdoc
-         */
-        start(): void;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-    /**
-     * A mediator client, driver for the master server.
-     *
-     * The {@link MediatorWebClient} is a class being a client connecting to the **master** server, following the
-     * web-socket protocol.
-     *
-     * #### [Inherited] {@link MediatorSystem}
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MediatorWebClient extends MediatorClient {
-        /**
-         * @inheritdoc
-         */
-        protected createServerConnector(): protocol.IServerConnector;
-    }
-    /**
-     * A mediator client, driver for the master server.
-     *
-     * The {@link MediatorSharedWorkerClient} is a class being a client connecting to the **master** server, following
-     * the SharedWorker's protocol.
-     *
-     * #### [Inherited] {@link MediatorSystem}
-     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
-     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
-     *
-     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
-     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
-     * type and protocol the **master** system follows:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
-     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
-     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
-     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
-     * result to its **master**.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
-     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MediatorSharedWorkerClient extends MediatorClient {
-        /**
-         * @inheritdoc
-         */
-        protected createServerConnector(): protocol.IServerConnector;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * Master of Parallel Processing System, a server accepting slave clients.
-     *
-     * The {@link ParallelClientArray} is an abstract class, derived from the {@link ParallelSystemArray} class, opening
-     * a server accepting {@link ParallelSystem parallel clients}.
-     *
-     * Extends this {@link ParallelClientArray}, overrides {@link createServerBase createServerBase()} to determine which
-     * protocol to follow and {@link createExternalClient createExternalClient()} creating child {@link ParallelSystem}
-     * object. After the extending and overridings, open this server using the {@link open open()} method.
-     *
-     * #### [Inherited] {@link ParallelSystemArray}
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
-     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
-     * *parallel processes*.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelClientArray<System extends ParallelSystem> extends ParallelSystemArray<System> implements external.IExternalClientArray<System> {
-        /**
-         * @hidden
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating {@link IServerBase} object.
-         *
-         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified protocol.
-         *
-         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
-         *
-         * - {@link ServerBase}
-         * - {@link WebServerBase}
-         * - {@link SharedWorkerServerBase}
-         *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): protocol.IServerBase;
-        /**
-         * Add a newly connected remote client.
-         *
-         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
-         * then this {@link ParallelClientArray} creates a child {@link ParallelSystem parallel client} object through
-         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
-         *
-         * @param driver A communicator for external client.
-         */
-        addClient(driver: protocol.IClientDriver): void;
-        /**
-         * (Deprecated) Factory method creating child object.
-         *
-         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
-         *
-         * Note that, the {@link ParallelClientArray} is a server accepting {@link ParallelSystem parallel clients}.
-         * There's no way to creating the {@link ParallelSystem parallel clients} in advance before opening the server.
-         *
-         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
-         * @return ```null```
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating {@link ParallelSystem} object.
-         *
-         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
-         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
-         * {@link addClient addClient()}.
-         *
-         * Overrides this {@link createExternalClient} method and creates a type of {@link ParallelSystem} object with
-         * the *driver* that communicates with the parallel client. After the creation, returns the {@link ParallelSystem}
-         * object. Then whenever a parallel client has connected, matched {@link ParallelSystem} object will be
-         * constructed and {@link insert inserted} into this {@link ParallelClientArray} object.
-         *
-         * @param driver A communicator with the parallel client.
-         * @return A newly created {@link ParallelSystem} object.
-         */
-        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * Mediator of Parallel Processing System.
-     *
-     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
-     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
-     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
-     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a **master**, you can specify this {@link ParallelSystemArrayMediator} class to be <i>a master server accepting
-     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
-     * of them below and overrides abstract factory method(s) creating the child {@link ParallelSystem} object.
-     *
-     * - {@link ParallelClientArrayMediator}: A server accepting {@link ParallelSystem parallel clients}.
-     * - {@link ParallelServerArrayMediator}: A client connecting to {@link ParallelServer parallel servers}.
-     * - {@link ParallelServerClientArrayMediator}: Both of them. Accepts {@link ParallelSystem parallel clients} and
-     *   connects to {@link ParallelServer parallel servers} at the same time.
-     *
-     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
-     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link ParallelSystemArray}
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
-     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
-     * *parallel processes*.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelSystemArrayMediator<System extends ParallelSystem> extends ParallelSystemArray<System> {
-        /**
-         * @hidden
-         */
-        private mediator_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating a {@link MediatorSystem} object.
-         *
-         * The {@link createMediator createMediator()} is an abstract method creating the {@link MediatorSystem} object.
-         *
-         * You know what? this {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a
-         * **slave** to its master system at the same time. The {@link MediatorSystem} object makes it possible; be a
-         * **slave** system. This {@link createMediator} determines specific type of the {@link MediatorSystem}.
-         *
-         * Overrides the {@link createMediator createMediator()} method to create and return one of them following which
-         * protocol and which type of remote connection (server or client) will be used:
-         *
-         * - A client slave connecting to master server:
-         *   - {@link MediatorClient}
-         *   - {@link MediatorWebClient}
-         *   - {@link MediatorSharedWorkerClient}
-         * - A server slave accepting master client:
-         *   - {@link MediatorServer}
-         *   - {@link MediatorWebServer}
-         *   - {@link MediatorDedicatedWorkerServer}
-         *   - {@link MediatorSharedWorkerServer}
-         *
-         * @return A newly created {@link MediatorSystem} object.
-         */
-        protected abstract createMediator(): MediatorSystem;
-        /**
-         * Start mediator.
-         *
-         * If the {@link getMediator mediator} is a type of server, then opens the server accepting master client.
-         * Otherwise, the {@link getMediator mediator} is a type of client, then connects the master server.
-         */
-        protected startMediator(): void;
-        /**
-         * Get {@link MediatorSystem} object.
-         *
-         * When you need to send an {@link Invoke} message to the master system of this
-         * {@link ParallelSystemArrayMediator}, then send to the {@link MediatorSystem} through this {@link getMediator}.
-         *
-         * ```typescript
-         * this.getMediator().sendData(...);
-         * ```
-         *
-         * @return The {@link MediatorSystem} object.
-         */
-        getMediator(): MediatorSystem;
-        /**
-         * @hidden
-         */
-        protected _Complete_history(history: PRInvokeHistory): boolean;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * Mediator of Parallel Processing System, a server accepting slave clients.
-     *
-     * The {@link ParallelClientArrayMediator} is an abstract class, derived from the {@link ParallelSystemArrayMediator}
-     * class, opening a server accepting {@link ParallelSystem parallel clients} as a **master**.
-     *
-     * Extends this {@link ParallelClientArrayMediator}, overrides {@link createServerBase createServerBase()} to
-     * determine which protocol to follow and {@link createExternalClient createExternalClient()} creating child
-     * {@link ParallelSystem} object. After the extending and overridings, open this server using the
-     * {@link open open()} method.
-     *
-     * #### [Inherited] {@link ParallelSystemArrayMediator}
-     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
-     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
-     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
-     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
-     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link ParallelSystemArray}
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
-     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
-     * *parallel processes*.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelClientArrayMediator<System extends ParallelSystem> extends ParallelSystemArrayMediator<System> implements external.IExternalClientArray<System> {
-        /**
-         * @hidden
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating {@link IServerBase} object.
-         *
-         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link ParallelClientArrayMediator}. If the protocol is determined, then
-         * {@link ParallelSystem parallel clients} who may connect to {@link ParallelClientArrayMediator this server}
-         * must follow the specified protocol.
-         *
-         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
-         *
-         * - {@link ServerBase}
-         * - {@link WebServerBase}
-         * - {@link SharedWorkerServerBase}
-         *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): protocol.IServerBase;
-        /**
-         * Add a newly connected remote client.
-         *
-         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
-         * then this {@link ParallelClientArrayMediator} creates a child {@link ParallelSystem parallel client} object
-         * through the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
-         *
-         * @param driver A communicator for parallel client.
-         */
-        addClient(driver: protocol.IClientDriver): void;
-        /**
-         * (Deprecated) Factory method creating child object.
-         *
-         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
-         *
-         * Note that, the {@link ParallelClientArrayMediator} is a server accepting {@link ParallelSystem parallel
-         * clients} as a master. There's no way to creating the {@link ParallelSystem parallel clients} in advance before
-         * opening the server.
-         *
-         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
-         * @return null
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating {@link ParallelSystem} object.
-         *
-         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
-         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
-         * {@link addClient addClient()}.
-         *
-         * Overrides this {@link createExternalClient} method and creates a type of {@link ParallelSystem} object with
-         * the *driver* that communicates with the parallel client. After the creation, returns the {@link ParallelSystem}
-         * object. Then whenever a parallel client has connected, matched {@link ParallelSystem} object will be
-         * constructed and {@link insert inserted} into this {@link ParallelClientArrayMediator} object.
-         *
-         * @param driver A communicator with the parallel client.
-         * @return A newly created {@link ParallelSystem} object.
-         */
-        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * An interface for a parallel slave server driver.
-     *
-     * The easiest way to defining a driver for parallel **slave** server is extending {@link ParallelServer} class.
-     * However, if you've to interact with a prallel **slave** system who can be both server and client, them make a class
-     * (let's name it **BaseSystem**) extending the {@link ParallelSystem} class. At next, make a new class (now, I name it
-     * **BaseServer**) extending the **BaseSystem** and implements this interface {@link IParallelServer}. Define the
-     * **BaseServer** following those codes on below:
-     *
-     * <ul>
-     *	<li> {@link ExternalServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IParallelServer extends ParallelSystem {
-        /**
-         * Connect to slave server.
-         */
-        connect(): void;
-    }
-    /**
-     * A driver for parallel slave server.
-     *
-     * The {@link ParallelServer} is an abstract class, derived from the {@link ParallelSystem} class, connecting to
-     * remote, parallel **slave** server. Extends this {@link ParallelServer} class and overrides the
-     * {@link createServerConnector createServerConnector()} method following which protocol the **slave** server uses.
-     *
-     * #### [Inherited] {@link ParallelSystem}
-     * The {@link ParallelSystem} is an abstract class represents a **slave** system in *Parallel Processing System*,
-     * connected with this **master** system. This {@link ParallelSystem} takes full charge of network communication with
-     * the remote, parallel **slave** system has connected.
-     *
-     * When a *parallel process* is requested (by {@link ParallelSystemArray.sendSegmentData} or
-     * {@link ParallelSystemArray.sendPieceData}), the number of pieces to be allocated to a {@link ParallelSystem} is
-     * turn on its {@link getPerformance performance index}. Higher {@link getPerformance performance index}, then
-     * more pieces are requested. The {@link getPerformance performance index} is revaluated whenever a *parallel process*
-     * has completed, basic on the execution time and number of pieces. You can sugguest or enforce the
-     * {@link getPerformance performance index} with {@link setPerformance} or {@link enforcePerformance}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Bridge & Proxy Pattern
-     * This class {@link ParallelSystem} is derived from the {@link ExternalSystem} class. Thus, you can take advantage
-     * of the *Bridge & Proxy Pattern* in this {@link ParallelSystem} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Bridge & Proxy Pattern*:
-     *
-     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
-     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelServer extends ParallelSystem implements IParallelServer {
-        /**
-         * IP address of target external system to connect.
-         */
-        protected ip: string;
-        /**
-         * Port number of target external system to connect.
-         */
-        protected port: number;
-        /**
-         * Construct from parent {@link ParallelSystemArray}.
-         *
-         * @param systemArray The parent {@link ParallelSystemArray} object.
-         */
-        constructor(systemArray: ParallelSystemArray<IParallelServer>);
-        /**
-         * Factory method creating {@link IServerConnector} object.
-         *
-         * The {@link createServerConnector createServerConnector()} is an abstract method creating
-         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the slave server
-         * follows:
-         *
-         * - {@link ServerConnector}
-         * - {@link WebServerConnector}
-         * - {@link DedicatedWorkerServerConnector}
-         * - {@link SharedWorkerServerConnector}
-         *
-         * @return A newly created {@link IServerConnector} object.
-         */
-        protected abstract createServerConnector(): protocol.IServerConnector;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * Master of Parallel Processing System, a client connecting to slave servers.
-     *
-     * The {@link ParallelServerArray} is an abstract class, derived from the {@link ParallelSystemArray} class,
-     * connecting to {@link IParallelServer parallel servers}.
-     *
-     * Extends this {@link ParallelServerArray} and overrides {@link createChild createChild()} method creating child
-     * {@link IParallelServer} object. After the extending and overriding, construct children {@link IParallelServer}
-     * objects and call the {@link connect connect()} method.
-     *
-     * #### [Inherited] {@link ParallelSystemArray}
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
-     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
-     * *parallel processes*.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelServerArray<System extends IParallelServer> extends ParallelSystemArray<System> implements external.IExternalServerArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * Mediator of Parallel Processing System, a client connecting to slave servers.
-     *
-     * The {@link ParallelServerArrayMediator} is an abstract class, derived from the {@link ParallelSystemArrayMediator}
-     * class, connecting to {@link IParallelServer parallel servers}.
-     *
-     * Extends this {@link ParallelServerArrayMediator} and overrides {@link createChild createChild()} method creating
-     * child {@link IParallelServer} object. After the extending and overriding, construct children
-     * {@link IParallelServer} objects and call the {@link connect connect()} method.
-     *
-     * #### [Inherited] {@link ParallelSystemArrayMediator}
-     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
-     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
-     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
-     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a **master**, you can specify this {@link ParallelSystemArrayMediator} class to be <i>a master server accepting
-     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
-     * of them below and overrides abstract factory method(s) creating the child {@link ParallelSystem} object.
-     *
-     * - {@link ParallelClientArrayMediator}: A server accepting {@link ParallelSystem parallel clients}.
-     * - {@link ParallelServerArrayMediator}: A client connecting to {@link ParallelServer parallel servers}.
-     * - {@link ParallelServerClientArrayMediator}: Both of them. Accepts {@link ParallelSystem parallel clients} and
-     *                                              connects to {@link ParallelServer parallel servers} at the same time.
-     *
-     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
-     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link ParallelSystemArray}
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
-     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
-     * *parallel processes*.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelServerArrayMediator<System extends IParallelServer> extends ParallelSystemArrayMediator<System> implements external.IExternalServerArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * Master of Parallel Processing System, be a server and client at the same time.
-     *
-     * The {@link ParallelServerClientArray} is an abstract class, derived from the {@link ParallelSystemArray} class,
-     * opening a server accepting {@link ParallelSystem parallel clients} and being a client connecting to
-     * {@link IParallelServer parallel servers} at the same time.
-     *
-     * Extends this {@link ParallelServerClientArray} and overrides below methods. After the overridings, open server
-     * with {@link open open()} method and connect to {@link IParallelServer parallel servers} through the
-     * {@link connect connect()} method.
-     *
-     * - {@link createServerBase createServerBase()}
-     * - {@link createExternalClient createExternalClient()}
-     * - {@link createExternalServer createExternalServer()}
-     *
-     * #### [Inherited] {@link ParallelSystemArray}
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
-     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
-     * *parallel processes*.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelServerClientArray<System extends ParallelSystem> extends ParallelClientArray<System> implements external.IExternalServerClientArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method of a child Entity.
-         *
-         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating an {@link IParallelServer} object.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A newly created {@link IParallelServer} object.
-         */
-        protected abstract createExternalServer(xml: library.XML): System;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * Mediator of Parallel Processing System, be a server and client at the same time as a **master**.
-     *
-     * The {@link ParallelServerClientArrayMediator} is an abstract class, derived from the
-     * {@link ParallelSystemArrayMediator} class, opening a server accepting {@link ParallelSystem parallel clients} and
-     * being a client connecting to {@link IParallelServer parallel servers} at the same time.
-     *
-     * Extends this {@link ParallelServerClientArrayMediator} and overrides below methods. After the overridings, open
-     * server with {@link open open()} method and connect to {@link IParallelServer parallel servers} through the
-     * {@link connect connect()} method.
-     *
-     * - {@link createServerBase createServerBase()}
-     * - {@link createExternalClient createExternalClient()}
-     * - {@link createExternalServer createExternalServer()}
-     *
-     * #### [Inherited] {@link ParallelSystemArrayMediator}
-     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
-     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
-     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
-     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
-     * derived from the {@link SlaveSystem} class.
-     *
-     * As a **master**, you can specify this {@link ParallelSystemArrayMediator} class to be <i>a master server accepting
-     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
-     * of them below and overrides abstract factory method(s) creating the child {@link ParallelSystem} object.
-     *
-     * - {@link ParallelClientArrayMediator}: A server accepting {@link ParallelSystem parallel clients}.
-     * - {@link ParallelServerArrayMediator}: A client connecting to {@link ParallelServer parallel servers}.
-     * - {@link ParallelServerClientArrayMediator}: Both of them. Accepts {@link ParallelSystem parallel clients} and
-     *                                              connects to {@link ParallelServer parallel servers} at the same time.
-     *
-     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
-     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
-     * Overrides the {@link createMediator createMediator()} method and return one of them:
-     *
-     * - A client slave connecting to master server:
-     *   - {@link MediatorClient}
-     *   - {@link MediatorWebClient}
-     *   - {@link MediatorSharedWorkerClient}
-     * - A server slave accepting master client:
-     *   - {@link MediatorServer}
-     *   - {@link MediatorWebServer}
-     *   - {@link MediatorDedicatedWorkerServer}
-     *   - {@link MediatorSharedWorkerServer}
-     *
-     * #### [Inherited] {@link ParallelSystemArray}
-     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
-     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
-     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
-     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
-     * *parallel processes*.
-     *
-     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
-     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
-     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
-     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * #### Proxy Pattern
-     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
-     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
-     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
-     * may better to utilizing the *Proxy Pattern*:
-     *
-     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
-     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is *which can be done*.
-     *
-     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called *Proxy Pattern*. </li>
-     * </ul>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelServerClientArrayMediator<System extends ParallelSystem> extends ParallelClientArrayMediator<System> implements external.IExternalServerClientArray<System> {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method of a child Entity.
-         *
-         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
-         */
-        createChild(xml: library.XML): System;
-        /**
-         * Factory method creating an {@link IParallelServer} object.
-         *
-         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         * @return A newly created {@link IParallelServer} object.
-         */
-        protected abstract createExternalServer(xml: library.XML): System;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.templates.parallel {
-    /**
-     * History of an {@link Invoke} message.
-     *
-     * The {@link PRInvokeHistory} is a class archiving history log of an {@link Invoke} message which requests the
-     * *parallel process*, created whenever {@link ParallelSystemArray.sendSegmentData} or
-     * {@link ParallelSystemArray.sendSegmentData} is called.
-     *
-     * When the *parallel process* has completed, then {@link complete complete()} is called and the *elapsed time* is
-     * determined. The elapsed time is utilized for computation of {@link ParallelSystem.getPerformance performance index}
-     * of each {@link ParallelSystem parallel slave system}.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class PRInvokeHistory extends protocol.InvokeHistory {
-        /**
-         * @hidden
-         */
-        private first;
-        /**
-         * @hidden
-         */
-        private last;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from an {@link Invoke} message.
-         *
-         * @param invoke An {@link Invoke} message requesting a *parallel process*.
-         */
-        constructor(invoke: protocol.Invoke);
-        /**
-         * Get initial piece's index.
-         *
-         * Returns initial piece's index in the section of requested *parallel process*.
-         *
-         * @return The initial index.
-         */
-        getFirst(): number;
-        /**
-         * Get final piece's index.
-         *
-         * Returns initial piece's index in the section of requested *parallel process*. The range used is
-         * [*first*, *last*), which contains all the pieces' indices between *first* and *last*, including the piece
-         * pointed by index *first*, but not the piece pointed by the index *last*.
-         *
-         * @return The final index.
-         */
-        getLast(): number;
-        /**
-         * Compute number of allocated pieces.
-         */
-        computeSize(): number;
-    }
-}
-declare namespace samchon.templates.service {
-    /**
-     * A driver of remote client.
-     *
-     * The {@link Client} is an abstract class representing and interacting with a remote client. It deals the network
-     * communication with the remote client and shifts {@link Invoke} message to related {@link User} and {@link Service}
-     * objects.
-     *
-     * Extends this {@link Client} class and override the {@link createService} method, a factory method creating a child
-     * {@link Service} object. Note that, {@link Client} represents a remote client, not *an user*, a specific *web page*
-     * or *service*. Do not define logics about user or account information. It must be declared in the parent
-     * {@link User} class. Also, don't define processes of a specific a web page or service. Defines them in the child
-     * {@link Service} class.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Client implements protocol.IProtocol {
-        /**
-         * @hidden
-         */
-        private user_;
-        /**
-         * @hidden
-         */
-        private no_;
-        /**
-         * @hidden
-         */
-        private communicator_;
-        /**
-         * @hidden
-         */
-        private service_;
-        /**
-         * Construct from parent {@link User} and communicator.
-         *
-         * @param user Parent {@link User} object.
-         * @param driver Communicator with remote client.
-         */
-        constructor(user: User, driver: protocol.WebClientDriver);
-        /**
-         * Default Destructor.
-         *
-         * This {@link destructor destructor()} method is called when the {@link Client} object is destructed and this
-         * {@link Client} object is destructed when connection with the remote client is closed or this {@link Client}
-         * object is {@link User.erase erased} from its parent {@link User} object.
-         *
-         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
-         * by those *destruction* cases. Also, if your derived {@link Client} class has something to do on the
-         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
-         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
-         *
-         * ```typescript
-         * class MyUser extends protocol.service.Client
-         * {
-         *     protected destructor(): void
-         *     {
-         *         // DO SOMETHING
-         *         this.do_something();
-         *
-         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
-         *         super.destructor();
-         *     }
-         * }
-         * ```
-         */
-        protected destructor(): void;
-        /**
-         * Factory method creating {@link Service} object.
-         *
-         * @param path Requested path.
-         * @return A newly created {@link Service} object or ```null```.
-         */
-        protected abstract createService(path: string): Service;
-        /**
-         * Close connection.
-         */
-        close(): void;
-        /**
-         * Get parent {@link User} object.
-         *
-         * Get the parent {@link User} object, who is groupping {@link Client} objects with same session id.
-         *
-         * @return The parent {@link User} object.
-         */
-        getUser(): User;
-        /**
-         * Get child {@link Service} object.
-         *
-         * @return The child {@link Service} object.
-         */
-        getService(): Service;
-        /**
-         * Get sequence number.
-         *
-         * Get sequence number of this {@link Client} object in the parent {@link User} object. This sequence number also
-         * be a *key* in the parent {@link User} object, who extended the ```std.HashMap<number, Client>```.
-         *
-         * @return Sequence number.
-         */
-        getNo(): number;
-        /**
-         * Change related {@link Service} object.
-         *
-         * @param path Requested, identifier path.
-         */
-        protected changeService(path: string): void;
-        /**
-         * Change {@link Service} to another.
-         *
-         * @param service {@link service} object to newly assigned.
-         */
-        protected changeService(service: Service): void;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * Sends an {@link Invoke} message to remote client.
-         *
-         * @param invoke An {@link Invoke} messgae to send to remote client.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * Handle a replied {@link Invoke} message.
-         *
-         * The default {@link Client.replyData Client.replyData()} shifts chain to its parent {@link User} and belonged
-         * {@link Service} objects, by calling the the {@link User.replyData User.replyData()} and
-         * {@link Service.replyData Service.replyData()} methods.
-         *
-         * Note that, {@link Client} represents a remote client, not *an user*, a specific *web page* or *service*. Do not
-         * define logics about user or account information. It must be declared in the parent {@link User} class. Also,
-         * don't define processes of a specific a web page or service. Defines them in the child {@link Service} class.
-         *
-         * ```typescript
-         * class protocol.service.Client
-         * {
-         *     public replyData(invoke: protocol.Invoke): void
-         *     {
-         *         // SHIFT TO PARENT USER
-         *         // THE PARENT USER ALSO MAY SHIFT TO ITS PARENT SERVER
-         *         this.getUser().replyData(invoke);
-         *
-         *         // SHIFT TO BELOGED SERVICE
-         *         if (this.getService() != null)
-         *             this.getService().replyData(invoke);
-         *     }
-         * }
-         *
-         * class MyClient extends protocol.service.Client
-         * {
-         *     public replyData(invoke: protocol.Invoke): void
-         *     {
-         *         if (invoke.getListener() == "do_something_in_client_level")
-         *             this.do_something_in_client_level();
-         *         else
-         *             super.replyData(invoke);
-         *     }
-         * }
-         * ```
-         *
-         * @param invoke An {@link Invoke invoke} message to be handled in {@link Client} level.
-         */
-        replyData(invoke: protocol.Invoke): void;
-    }
-}
-/**
- * A system template for Cloud Service.
- *
- * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace samchon.templates.service {
-    /**
-     * A cloud server.
-     *
-     * The {@link Server} is an abstract server class, who can build a real-time cloud server, that is following the
-     * web-socket protocol. Extends this {@link Server} and related classes and overrides abstract methods under below.
-     * After the overridings, open this {@link Server cloud server} using the {@link open open()} method.
-     *
-     * - Objects in composite relationship and their factory methods
-     *   - {@link User}: {@link Server.createUser Server.createUser()}
-     *   - {@link Client}: {@link User.createClient User.createClient()}
-     *   - {@link Service}: {@link Client.createService Client.createService()}
-     * - {@link Invoke} message chains; {@link IProtocol.replyData replyData}
-     *   - {@link Server.replyData}
-     *   - {@link User.replyData}
-     *   - {@link Client.replyData}
-     *   - {@link Service.replyData}
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Server extends protocol.WebServer implements protocol.IProtocol {
-        /**
-         * @hidden
-         */
-        private session_map_;
-        /**
-         * @hidden
-         */
-        private account_map_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Factory method creating {@link User} object.
-         *
-         * @return A newly created {@link User} object.
-         */
-        protected abstract createUser(): User;
-        /**
-         * Test wheter an {@link User} exists with the *accountID*.
-         *
-         * @param accountID Account id of {@link User} to find.
-         * @return Exists or not.
-         */
-        has(accountID: string): boolean;
-        /**
-         * Get an {@link User} object by its *accountID*.
-         *
-         * @param accountID Account id of {@link User} to get.
-         * @return An {@link User} object.
-         */
-        get(accountID: string): User;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * Sends an {@link Invoke} message to all remote clients through the belonged {@link User} and {@link Client}
-         * objects. Sending the {@link Invoke} message to all remote clients, it's came true by passing through
-         * {@link User.sendData User.sendData()}. And the {@link User.sendData} also pass through the
-         * {@link Client.sendData Client.sendData()}.
-         *
-         * ```typescript
-         * class protocol.service.Server
-         * {
-         *     public sendData(invoke: Invoke): void
-         *     {
-         *         for (user: User in this)
-         *             for (client: Client in user)
-         *                 client.sendData(invoke);
-         *     }
-         * }
-         * ```
-         *
-         * @param invoke {@link Invoke} message to send to all remote clients.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * Handle a replied {@link Invoke} message.
-         *
-         * The {@link Server.replyData Server.replyData()} is an abstract method that handling {@link Invoke} message
-         * that should be handled in the {@link Server} level. Overrides this {@link replyData replyData()} method and
-         * defines what to do with the {@link Invoke} message in this {@link Server} level.
-         *
-         * @param invoke An {@link Invoke invoke} message to be handled in {@link Server} level.
-         */
-        abstract replyData(invoke: protocol.Invoke): void;
-        /**
-         * Add a newly connected remote client.
-         *
-         * When a {@link WebClientDriver remote client} connects to this cloud server, then {@link Server} queries the
-         * {WebClientDriver.getSessionID session id} of the {@link WebClientDriver remote client}. If the
-         * {WebClientDriver.getSessionID session id} is new one, then creates a new {@link User} object.
-         *
-         * At next, creates a {@link Client} object who represents the newly connected remote client and insert the
-         * {@link Client} object to the matched {@link User} object which is new or ordinary one following the
-         * {WebClientDriver.getSessionID session id}. At last, a {@link Service} object can be created with referencing
-         * the {@link WebClientDriver.getPath path}.
-         *
-         * List of objects can be created by this method.
-         * - {@link User} by {@link createUser createUser()}.
-         * - {@link Client} by {@link User.createClient User.createClient()}.
-         * - {@link Service} by {@link Client.createService Client.createService()}.
-         *
-         * @param driver A web communicator for remote client.
-         */
-        addClient(driver: protocol.WebClientDriver): void;
-        /**
-         * @hidden
-         */
-        private erase_user(user);
-    }
-}
-declare namespace samchon.templates.service {
-    /**
-     * A service.
-     *
-     * The {@link Service} is an abstract class who represents a service, that is providing functions a specific page.
-     *
-     * Extends the {@link Service} class and defines its own service, which to be provided for the specific weg page,
-     * by overriding the {@link replyData replyData()} method. Note that, the service, functions for the specific page
-     * should be defined in this {@link Service} class, not its parent {@link Client} class who represents a remote client
-     * and takes communication responsibility.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Service implements protocol.IProtocol {
-        /**
-         * @hidden
-         */
-        private client_;
-        /**
-         * @hidden
-         */
-        private path_;
-        /**
-         * Construct from parent {@link Client} and requested path.
-         *
-         * @param client Driver of remote client.
-         * @param path Requested path that identifies this {@link Service}.
-         */
-        constructor(client: Client, path: string);
-        /**
-         * Default Destructor.
-         *
-         * This {@link destructor destructor()} method is call when the {@link Service} object is destructed and the
-         * {@link Service} object is destructed when its parent {@link Client} object has
-         * {@link Client.destructor destructed} or the {@link Client} object {@link Client.changeService changed} its
-         * child {@link Service service} object to another one.
-         *
-         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
-         * by those *destruction* cases. Also, if your derived {@link Service} class has something to do on the
-         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
-         */
-        protected destructor(): void;
-        /**
-         * Get client.
-         */
-        getClient(): Client;
-        /**
-         * Get requested path.
-         */
-        getPath(): string;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * Sends an {@link Invoke} message to remote system through parent {@link Client} object ({@link Client.sendData}).
-         *
-         * @param invoke An {@link Invoke} message to send to the remte system.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * @inheritdoc
-         */
-        abstract replyData(invoke: protocol.Invoke): void;
-    }
-}
-declare namespace samchon.templates.service {
-    /**
-     * An user.
-     *
-     * The {@link User} is an abstract class groupping {@link Client} objects, who communicates with remote client, with
-     * same *session id*. This {@link User} represents a *remote user* literally. Within framework of remote system,
-     * an {@link User} corresponds to a web-browser and a {@link Client} represents a window in the web-browser.
-     *
-     * Extends this {@link User} class and override the {@link createClient} method, a factory method creating a child
-     * {@link Client} object. I repeat, the {@link User} class represents a *remote user*, groupping {@link Client}
-     * objects with same *session id*. If your cloud server has some processes to be handled in the **user level**, then
-     * defines method in this {@link User} class. Methods managing **account** under below are some of them:
-     *
-     * - {@link setAccount setAccount()}
-     * - {@link getAccountID getAccountID()}
-     * - {@link getAuthority getAuthority()}
-     *
-     * The children {@link Client} objects, they're contained with their key, the {@link Client.getNo sequence number}.
-     * If you {@link User.erase erase} the children {@link Client} object by yourself, then their connection with the
-     * remote clients will be {@link Client.close closed} and their {@link Client.destructor destruction method} will be
-     * called. If you remove {@link clear all children}, then this {@link User} object will be also
-     * {@link destructor destructed} and erased from the parent {@link Server} object.
-     *
-     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
-     *		 style="max-width: 100%" />
-     * </a>
-     *
-     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class User extends collections.HashMapCollection<number, Client> implements protocol.IProtocol {
-        /**
-         * @hidden
-         */
-        private server_;
-        /**
-         * @hidden
-         */
-        private session_id_;
-        /**
-         * @hidden
-         */
-        private sequence_;
-        /**
-         * @hidden
-         */
-        private account_id_;
-        /**
-         * @hidden
-         */
-        private authority_;
-        /**
-         * Construct from its parent {@link Server}.
-         *
-         * @param server The parent {@link Server} object.
-         */
-        constructor(server: Server);
-        /**
-         * Default Destructor.
-         *
-         * This {@link destructor destructor()} method is called when the {@link User} object is destructed. The
-         * {@link User} object is destructed when connections with the remote clients are all closed, that is all the
-         * children {@link Client} objects are all removed, and 30 seconds has left. If some remote client connects
-         * within the 30 seconds, then the {@link User} object doesn't be destructed.
-         *
-         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
-         * by those *destruction* cases. Also, if your derived {@link User} class has something to do on the
-         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
-         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
-         *
-         * ```typescript
-         * class MyUser extends protocol.service.User
-         * {
-         *     protected destructor(): void
-         *     {
-         *         // DO SOMETHING
-         *         this.do_something();
-         *
-         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
-         *         super.destructor();
-         *     }
-         * }
-         * ```
-         */
-        protected destructor(): void;
-        /**
-         * Factory method creating a {@link Client} object.
-         *
-         * @param driver A web communicator for remote client.
-         * @return A newly created {@link Client} object.
-         */
-        protected abstract createClient(driver: protocol.WebClientDriver): Client;
-        /**
-         * @hidden
-         */
-        private handle_erase_client(event);
-        /**
-         * Get parent {@lin Server} object.
-         *
-         * @return Parent {@link Server} object.
-         */
-        getServer(): Server;
-        /**
-         * Get account id.
-         *
-         * @return Account ID.
-         */
-        getAccountID(): string;
-        /**
-         * Get authority.
-         *
-         * @return Authority
-         */
-        getAuthority(): number;
-        /**
-         * Set *account id* and *authority*.
-         *
-         * The {@link setAccount setAccount()} is a method configuring *account id* and *authority* of this {@link User}.
-         *
-         * After the configuring, the {@link getAccountID account id} is enrolled into the parent {@link Server} as a
-         * **key** for this {@link User} object. You can test existence and access this {@link User} object from
-         * {@link Server.has Server.has()} and {@link Server.get Server.get()} with the {@link getAccountID account id}.
-         * Of course, if ordinary {@link getAccountID account id} had existed, then the ordinary **key** will be
-         * replaced.
-         *
-         * As you suggest, this {@link setAccount setAccount()} is something like a **log-in** function. If what you want
-         * is not **logging-in**, but **logging-out**, then configure the *account id* to empty string ``""```` or call
-         * the {@link lgout logout()} method.
-         *
-         * @param id To be account id.
-         * @param authority To be authority.
-         */
-        setAccount(id: string, authority: number): void;
-        /**
-         * Log-out.
-         *
-         * This {@link logout logout()} method configures {@link getAccountID account id} to empty string and
-         * {@link getAuthority authority} to zero.
-         *
-         * The ordinary {@link getAccountID account id} will be also erased from the parent {@link Server} object. You
-         * can't access this {@link User} object from {@link Server.has Server.has()} and {@link Server.get Server.get()}
-         * with the ordinary {@link getAccountID account id} more.
-         */
-        logout(): void;
-        /**
-         * Send an {@link Invoke} message.
-         *
-         * Sends an {@link Invoke} message to all remote clients through the belonged {@link Client} objects. Sending the
-         * {@link Invoke} message to all remote clients, it's came true by passing through the
-         * {@link Client.sendData Client.sendData()} methods.
-         *
-         * ```typescript
-         * class protocol.service.User
-         * {
-         *     public sendData(invoke: Invoke): void
-         *     {
-         *         for (let it = this.begin(); !it.equal_to(this.end()); it = it.next())
-         *             it.second.sendData(invoke);
-         *     }
-         * }
-         * ```
-         *
-         * @param invoke {@link Invoke} message to send to all remote clients.
-         */
-        sendData(invoke: protocol.Invoke): void;
-        /**
-         * Handle a replied {@link Invoke} message.
-         *
-         * The default {@link User.replyData User.replyData()} shifts chain to its parent {@link Server} object, by
-         * calling the {@link Server.replyData Server.replyData()} method. If there're some {@link Invoke} message to be
-         * handled in this {@link User} level, then override this method and defines what to do with the {@link Invoke}
-         * message in this {@link User} level.
-         *
-         * ```typescript
-         * class protocol.service.User
-         * {
-         *     public replyData(invoke: protocol.Invoke): void
-         *     {
-         *         this.getServer().replyData(invoke);
-         *     }
-         * }
-         *
-         * class MyUser extends protocol.service.User
-         * {
-         *     public replyData(invoke: protocol.Invoke): void
-         *     {
-         *          if (invoke.apply(this) == false) // IS TARGET TO BE HANDLED IN THIS USER LEVEL
-         *              super.replyData(invoke); // SHIFT TO SERVER
-         *     }
-         * }
-         * ```
-         *
-         * @param invoke An {@link Invoke invoke} message to be handled in {@link User} level.
-         */
-        replyData(invoke: protocol.Invoke): void;
-    }
-}
-declare namespace samchon.templates.slave {
-    interface ISlaveClient extends SlaveSystem {
-        connect(ip: string, port: number): void;
-    }
-    abstract class SlaveClient extends SlaveSystem implements ISlaveClient {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        protected abstract createServerConnector(): protocol.IServerConnector;
-        /**
-         * @inheritdoc
-         */
-        connect(ip: string, port: number): void;
-    }
-}
-declare namespace samchon.templates.slave {
-    interface ISlaveServer extends SlaveSystem, protocol.IServer {
-    }
-    abstract class SlaveServer extends SlaveSystem implements ISlaveServer {
-        private server_base_;
-        constructor();
-        protected abstract createServerBase(): protocol.IServerBase;
-        open(port: number): void;
-        close(): void;
-        addClient(driver: protocol.IClientDriver): void;
-    }
-}
+}
\ No newline at end of file
diff --git a/samchon/index.d.ts b/samchon/index.d.ts
new file mode 100644
index 0000000000..6f2bc17b43
--- /dev/null
+++ b/samchon/index.d.ts
@@ -0,0 +1,8403 @@
+// Type definitions for Samchon Framework v2.0.7
+// Project: https://github.com/samchon/framework
+// Definitions by: Jeongho Nam <http://samchon.org>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="tstl" />
+
+declare module "samchon"
+{
+	export = samchon;
+}
+
+/**
+ * # Samchon Framework
+ *
+ * <a href="https://nodei.co/npm/samchon">
+ *	<img src="https://nodei.co/npm/samchon.png?downloads=true&downloadRank=true&stars=true"> </a>
+ *
+ * Samchon, a OON (Object-Oriented Network) framework.
+ *
+ * With Samchon Framework, you can implement distributed processing system within framework of OOD like handling S/W
+ * objects (classes). You can realize cloud and distributed system very easily with provided system templates and even
+ * integration with C++ is possible.
+ *
+ * The goal, ultimate utilization model of Samchon Framework is, building cloud system with NodeJS and taking heavy works
+ * to C++ distributed systems with provided modules (those are system templates).
+ *
+ * @git https://github.com/samchon/framework
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon {
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link Vector} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     *   - {@link push_back}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link pop_back}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link Vector}
+     * @copydoc Vector
+     */
+    class ArrayCollection<T> extends std.Vector<T> implements ICollection<T> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @inheritdoc
+         */
+        push(...items: T[]): number;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.VectorIterator<T>, begin: InputIterator, end: InputIterator): std.VectorIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: std.VectorIterator<T>, last: std.VectorIterator<T>): std.VectorIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Notify_insert(first, last);
+        /**
+         * @hidden
+         */
+        private _Notify_erase(first, last);
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.VectorIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.VectorIterator<T>, last: std.VectorIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * A basic event class of Samchon Framework.
+     *
+     * @reference https://developer.mozilla.org/en-US/docs/Web/API/Event
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-EventDispatcher
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class BasicEvent {
+        protected type_: string;
+        protected target_: IEventDispatcher;
+        private currentTarget_;
+        protected trusted_: boolean;
+        protected bubbles_: boolean;
+        protected cancelable_: boolean;
+        protected defaultPrevented_: boolean;
+        protected cancelBubble_: boolean;
+        private timeStamp_;
+        constructor(type: string, bubbles?: boolean, cancelable?: boolean);
+        /**
+         * @inheritdoc
+         */
+        initEvent(type: string, bubbles: boolean, cancelable: boolean): void;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * @inheritdoc
+         */
+        stopImmediatePropagation(): void;
+        /**
+         * @inheritdoc
+         */
+        stopPropagation(): void;
+        /**
+         * @inheritdoc
+         */
+        readonly type: string;
+        /**
+         * @inheritdoc
+         */
+        target: IEventDispatcher;
+        /**
+         * @inheritdoc
+         */
+        readonly currentTarget: IEventDispatcher;
+        /**
+         * @inheritdoc
+         */
+        readonly bubbles: boolean;
+        /**
+         * @inheritdoc
+         */
+        readonly cancelable: boolean;
+        /**
+         * @inheritdoc
+         */
+        readonly eventPhase: number;
+        /**
+         * @inheritdoc
+         */
+        readonly defaultPrevented: boolean;
+        /**
+         * @inheritdoc
+         */
+        readonly srcElement: Element;
+        /**
+         * @inheritdoc
+         */
+        readonly cancelBubble: boolean;
+        /**
+         * @inheritdoc
+         */
+        readonly timeStamp: number;
+        /**
+         * Don't know what it is.
+         */
+        readonly returnValue: boolean;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * Type of function pointer for listener of {@link CollectionEvent CollectionEvents}.
+     */
+    type CollectionEventListener<T> = (event: CollectionEvent<T>) => void;
+}
+declare namespace samchon.collections {
+    /**
+     * An event occured in a {@link ICollection collection} object.
+     *
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class CollectionEvent<T> extends library.BasicEvent {
+        /**
+         * @hidden
+         */
+        private first_;
+        /**
+         * @hidden
+         */
+        private last_;
+        /**
+         * @hidden
+         */
+        private temporary_container_;
+        /**
+         * @hidden
+         */
+        private origin_first_;
+        /**
+         * Initialization Constructor.
+         *
+         * @param type Type of collection event.
+         * @param first An {@link Iterator} to the initial position in this {@link CollectionEvent}.
+         * @param last An {@link Iterator} to the final position in this {@link CollectionEvent}.
+         */
+        constructor(type: string, first: std.Iterator<T>, last: std.Iterator<T>);
+        constructor(type: "insert", first: std.Iterator<T>, last: std.Iterator<T>);
+        constructor(type: "erase", first: std.Iterator<T>, last: std.Iterator<T>);
+        constructor(type: "refresh", first: std.Iterator<T>, last: std.Iterator<T>);
+        /**
+         * Associative target, the {@link ICollection collection}.
+         */
+        readonly target: ICollection<T>;
+        /**
+         * An {@link Iterator} to the initial position in this {@link CollectionEvent}.
+         */
+        readonly first: std.Iterator<T>;
+        /**
+         * An {@link Iterator} to the final position in this {@link CollectionEvent}.
+         */
+        readonly last: std.Iterator<T>;
+        /**
+         * @inheritdoc
+         */
+        preventDefault(): void;
+    }
+}
+declare namespace samchon.collections.CollectionEvent {
+    const INSERT: "insert";
+    const ERASE: "erase";
+    const REFRESH: "refresh";
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link Deque} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     *   - {@link push_front}
+     *   - {@link push_back}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link pop_front}
+     *   - {@link pop_back}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link Deque}
+     * @copydoc Deque
+     */
+    class DequeCollection<T> extends std.Deque<T> implements ICollection<T> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @inheritdoc
+         */
+        push_front(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.DequeIterator<T>, begin: InputIterator, end: InputIterator): std.DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        pop_front(): void;
+        /**
+         * @inheritdoc
+         */
+        pop_back(): void;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: std.DequeIterator<T>, last: std.DequeIterator<T>): std.DequeIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Notify_insert(first, last);
+        /**
+         * @hidden
+         */
+        private _Notify_erase(first, last);
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.DequeIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.DequeIterator<T>, last: std.DequeIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link HashMap} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link insert_or_assign}
+     *   - {@link emplace}
+     *   - {@link set}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link HashMap}
+     * @copydoc HashMap
+     */
+    class HashMapCollection<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Pair<Key, T>> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link HashMultiMap} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link emplace}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link HashMultiMap}
+     * @copydoc HashMultiMap
+     */
+    class HashMultiMapCollection<Key, T> extends std.HashMultiMap<Key, T> implements ICollection<std.Pair<Key, T>> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link HashMultiSet} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link HashMultiSet}
+     * @copydoc HashMultiSet
+     */
+    class HashMultiSetCollection<T> extends std.HashMultiSet<T> implements ICollection<T> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link HashSet} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     *   - {@link insert_or_assign}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link HashSet}
+     * @copydoc HashSet
+     */
+    class HashSetCollection<T> extends std.HashSet<T> implements ICollection<T> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+}
+/**
+ * Collections, elements I/O detectable STL containers.
+ *
+ * STL Containers       | Collections
+ * ---------------------|-------------------
+ * {@link Vector}       | {@link ArrayCollection}
+ * {@link List}         | {@link ListCollection}
+ * {@link Deque}        | {@link DequeCollection}
+ *                      |
+ * {@link TreeSet}      | {@link TreeSetCollection}
+ * {@link HashSet}      | {@link HashSetCollection}
+ * {@link TreeMultiSet} | {@link TreeMultiSetCollection}
+ * {@link HashMultiSet} | {@link HashMultiSetCollection}
+ *                      |
+ * {@link TreeMap}      | {@link TreeMapCollection}
+ * {@link HashMap}      | {@link HashMapCollection}
+ * {@link TreeMultiMap} | {@link TreeMultiMapCollection}
+ * {@link HashMultiMap} | {@link HashMultiMapCollection}
+ *
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.collections {
+    /**
+     * An interface for {@link IContainer containers} who can detect element I/O events.
+     *
+     * Below are list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *	 - {@link assign}
+     *   - {@link insert}
+     *	 - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface ICollection<T> extends std.base.Container<T>, library.IEventDispatcher {
+        /**
+         * Dispatch a {@link CollectionEvent} with *refresh* typed.
+         *
+         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
+         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
+         * There's no way to detect those events automatically by {@link IContainer}.
+         *
+         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
+         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
+         * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
+         * *refresh* typed will be dispatched.
+         *
+         * If you don't specify any iterator, then the range of the *refresh* event will be all elements in this
+         * {@link ICollection collection}; {@link begin begin()} to {@link end end()}.
+         */
+        refresh(): void;
+        /**
+         * Dispatch a {@link CollectionEvent} with *refresh* typed.
+         *
+         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
+         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
+         * There's no way to detect those events automatically by {@link IContainer}.
+         *
+         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
+         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
+         * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
+         * *refresh* typed will be dispatched.
+         *
+         * @param it An iterator targeting the content changed element.
+         */
+        refresh(it: std.Iterator<T>): void;
+        /**
+         * Dispatch a {@link CollectionEvent} with *refresh* typed.
+         *
+         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
+         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
+         * There's no way to detect those events automatically by {@link IContainer}.
+         *
+         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
+         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
+         * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
+         * *refresh* typed will be dispatched.
+         *
+         * @param first An Iterator to the initial position in a sequence of the content changed elmeents.
+         * @param last An {@link Iterator} to the final position in a sequence of the content changed elements. The range
+         *			   used is [*first*, *last*), which contains all the elements between *first* and
+         *			   *last*, including the element pointed by *first* but not the element pointed by
+         *			   *last*.
+         */
+        refresh(first: std.Iterator<T>, last: std.Iterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+    /**
+     * @hidden
+     */
+    namespace ICollection {
+        /**
+         * @hidden
+         */
+        function _Dispatch_CollectionEvent<T>(collection: ICollection<T>, type: string, first: std.Iterator<T>, last: std.Iterator<T>): void;
+        /**
+         * @hidden
+         */
+        function _Dispatch_MapCollectionEvent<Key, T>(collection: ICollection<std.Pair<Key, T>>, type: string, first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link List} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     *	- *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     *   - {@link push_front}
+     *   - {@link push_back}
+     *   - {@link merge}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link pop_front}
+     *   - {@link pop_back}
+     *   - {@link unique}
+     *   - {@link remove}
+     *   - {@link remove_if}
+     *   - {@link splice}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *   - {@link sort}
+     *
+     * #### [Inherited] {@link List}
+     * @copydoc List
+     */
+    class ListCollection<T> extends std.List<T> implements ICollection<T> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.ListIterator<T>, begin: InputIterator, end: InputIterator): std.ListIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: std.ListIterator<T>, last: std.ListIterator<T>): std.ListIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Notify_insert(first, last);
+        /**
+         * @hidden
+         */
+        private _Notify_erase(first, last);
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.ListIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.ListIterator<T>, last: std.ListIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    type MapCollectionEventListener<Key, T> = (event: MapCollectionEvent<Key, T>) => void;
+    /**
+     * An event occured in a {@link MapContainer map container} object.
+     *
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MapCollectionEvent<Key, T> extends CollectionEvent<std.Pair<Key, T>> {
+        /**
+         * @inheritdoc
+         */
+        readonly first: std.MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        readonly last: std.MapIterator<Key, T>;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link TreeMap} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link insert_or_assign}
+     *   - {@link emplace}
+     *   - {@link set}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link TreeMap}
+     * @copydoc TreeMap
+     */
+    class TreeMapCollection<Key, T> extends std.TreeMap<Key, T> implements ICollection<std.Pair<Key, T>> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link TreeMultiMap} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link emplace}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link TreeMultiMap}
+     * @copydoc TreeMultiMap
+     */
+    class TreeMultiMapCollection<Key, T> extends std.TreeMultiMap<Key, T> implements ICollection<std.Pair<Key, T>> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link TreeMultiSet} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link TreeMultiSet}
+     * @copydoc TreeMultiSet
+     */
+    class TreeMultiSetCollection<T> extends std.TreeMultiSet<T> implements ICollection<T> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.collections {
+    /**
+     * A {@link TreeMap} who can detect element I/O events.
+     *
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link insert_or_assign}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}7
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *
+     * #### [Inherited] {@link TreeSet}
+     * @copydoc TreeSet
+     */
+    class TreeSetCollection<T> extends std.TreeSet<T> implements ICollection<T> {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        refresh(): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(it: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
+        removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * Case generator.
+     *
+     * {@link CaseGenerator} is an abstract case generator being used like a matrix.
+     * <ul>
+     *  <li> n��r(n^r) -> {@link CombinedPermutationGenerator} </li>
+     *  <li> nPr -> {@link PermutationGenerator} </li>
+     *  <li> n! -> {@link FactorialGenerator} </li>
+     * </ul>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class CaseGenerator {
+        /**
+         * Size, the number of all cases.
+         */
+        protected size_: number;
+        /**
+         * N, size of the candidates.
+         */
+        protected n_: number;
+        /**
+         * R, size of elements of each case.
+         */
+        protected r_: number;
+        /**
+         * Construct from size of N and R.
+         *
+         * @param n Size of candidates.
+         * @param r Size of elements of each case.
+         */
+        constructor(n: number, r: number);
+        /**
+         * Get size of all cases.
+         *
+         * @return Get a number of the all cases.
+         */
+        size(): number;
+        /**
+         * Get size of the N.
+         */
+        n(): number;
+        /**
+         * Get size of the R.
+         */
+        r(): number;
+        /**
+         * Get index'th case.
+         *
+         * @param index Index number
+         * @return The row of the index'th in combined permuation case
+         */
+        abstract at(index: number): number[];
+    }
+    /**
+     * A combined-permutation case generator.
+     *
+     * <sub>n</sub>��<sub>r</sub>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class CombinedPermutationGenerator extends CaseGenerator {
+        /**
+         * An array using for dividing each element index.
+         */
+        private divider_array;
+        /**
+         * Construct from size of N and R.
+         *
+         * @param n Size of candidates.
+         * @param r Size of elements of each case.
+         */
+        constructor(n: number, r: number);
+        at(index: number): number[];
+    }
+    /**
+     * A permutation case generator.
+     *
+     * <sub>n</sub>P<sub>r</sub>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class PermuationGenerator extends CaseGenerator {
+        /**
+         * Construct from size of N and R.
+         *
+         * @param n Size of candidates.
+         * @param r Size of elements of each case.
+         */
+        constructor(n: number, r: number);
+        /**
+         * @inheritdoc
+         */
+        at(index: number): number[];
+    }
+    /**
+     * Factorial case generator.
+     *
+     * n! = <sub>n</sub>P<sub>n</sub>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class FactorialGenerator extends PermuationGenerator {
+        /**
+         * Construct from factorial size N.
+         *
+         * @param n Factoria size N.
+         */
+        constructor(n: number);
+    }
+}
+declare namespace samchon.library {
+    type BasicEventListener = (event: BasicEvent) => void;
+    /**
+     * The IEventDispatcher interface defines methods for adding or removing event listeners, checks whether specific
+     * types of event listeners are registered, and dispatches events.
+     *
+     * The event target serves as the local point for how events flow through the display list hierarchy. When an
+     * event such as a mouse click or a key press occurs, an event object is dispatched into the event flow from the
+     * root of the display list. The event object makes a round-trip journey to the event target, which is
+     * conceptually divided into three phases: the capture phase includes the journey from the root to the last node
+     * before the event target's node; the target phase includes only the event target node; and the bubbling phase
+     * includes any subsequent nodes encountered on the return trip to the root of the display list.
+     *
+     * In general, the easiest way for a user-defined class to gain event dispatching capabilities is to extend
+     * {@link EventDispatcher}. If this is impossible (that is, if the class is already extending another class), you
+     * can instead implement the {@link IEventDispatcher} interface, create an {@link EventDispatcher} member, and
+     * write simple hooks to route calls into the aggregated {@link EventDispatcher}.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/IEventDispatcher.html
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-EventDispatcher
+     * @author Migrated by Jeongho Nam <http://samchon.org>
+     */
+    interface IEventDispatcher {
+        /**
+         * Checks whether the {@link EventDispatcher} object has any listeners registered for a specific type of event.
+         * This allows you to determine where an {@link EventDispatcher} object has altered handling of an event type
+         * in the event flow hierarchy. To determine whether a specific event type actually triggers an event listener,
+         * use {@link willTrigger willTrigger()}.
+         *
+         * The difference between {@link hasEventListener hasEventListener()} and {@link willTrigger willTrigger()} is
+         * that {@link hasEventListener} examines only the object to which it belongs, whereas {@link willTrigger}
+         * examines the entire event flow for the event specified by the type parameter.
+         *
+         * @param type The type of event.
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * Dispatches an event into the event flow.
+         *
+         * The event target is the {@link EventDispatcher} object upon which the {@link dispatchEvent dispatchEvent()}
+         * method is called.
+         *
+         * @param event The {@link BasicEvent} object that is dispatched into the event flow. If the event is being
+         *				redispatched, a clone of the event is created automatically. After an event is dispatched, its
+         *				target property cannot be changed, so you must create a new copy
+         *				of the event for redispatching to work.
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * Registers an event listener object with an {@link EventDispatcher} object so that the listener receives
+         * notification of an event. You can register event listeners on all nodes in the display list for a specific
+         * type of event, phase, and priority.
+         *
+         * After you successfully register an event listener, you cannot change its priority through additional calls
+         * to {@link addEventListener addEventListener()|} To change a listener's priority, you must first call
+         * {@link removeEventListener removeEventListener()}. Then you can register the listener again with the new
+         * priority level.
+         *
+         * Keep in mind that after the listener is registered, subsequent calls to {@link addEventListener} with a
+         * different type or useCapture value result in the creation of a separate listener registration. For example,
+         * if you first register a listener with useCapture set to true, it listens only during the capture phase. If
+         * you call {@link addEventListener} again using the same listener object, but with useCapture set to false,
+         * you have two separate listeners: one that listens during the capture phase and another that listens during
+         * the target and bubbling phases.
+         *
+         * You cannot register an event listener for only the target phase or the bubbling phase. Those phases are
+         * coupled during registration because bubbling applies only to the ancestors of the target node.
+         *
+         * If you no longer need an event listener, remove it by calling {@link removeEventListener}, or memory
+         * problems could result. Event listeners are not automatically removed from memory because the garbage
+         * collector does not remove the listener as long as the dispatching object exists (unless the
+         * useWeakReference parameter is set to true).
+         *
+         * Copying an {@link EventDispatcher} instance does not copy the event listeners attached to it. (If your n
+         * ewly created node needs an event listener, you must attach the listener after creating the node.) However,
+         * if you move an {@link EventDispatcher} instance, the event listeners attached to it move along with it.
+         *
+         * If the event listener is being registered on a node while an event is also being processed on this node,
+         * the event listener is not triggered during the current phase but may be triggered during a later phase in
+         * the event flow, such as the bubbling phase.
+         *
+         * If an event listener is removed from a node while an event is being processed on the node, it is still
+         * triggered by the current actions. After it is removed, the event listener is never invoked again (unless it
+         * is registered again for future processing).
+         *
+         * @param event The type of event.
+         * @param listener The listener function that processes the event.
+         *				 This function must accept an Event object as its only parameter and must return
+         *				 nothing.
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        /**
+         * Registers an event listener object with an {@link EventDispatcher} object so that the listener receives
+         * notification of an event. You can register event listeners on all nodes in the display list for a specific
+         * type of event, phase, and priority.
+         *
+         * After you successfully register an event listener, you cannot change its priority through additional calls
+         * to {@link addEventListener addEventListener()|} To change a listener's priority, you must first call
+         * {@link removeEventListener removeEventListener()}. Then you can register the listener again with the new
+         * priority level.
+         *
+         * Keep in mind that after the listener is registered, subsequent calls to {@link addEventListener} with a
+         * different type or useCapture value result in the creation of a separate listener registration. For example,
+         * if you first register a listener with useCapture set to true, it listens only during the capture phase. If
+         * you call {@link addEventListener} again using the same listener object, but with useCapture set to false,
+         * you have two separate listeners: one that listens during the capture phase and another that listens during
+         * the target and bubbling phases.
+         *
+         * You cannot register an event listener for only the target phase or the bubbling phase. Those phases are
+         * coupled during registration because bubbling applies only to the ancestors of the target node.
+         *
+         * If you no longer need an event listener, remove it by calling {@link removeEventListener}, or memory
+         * problems could result. Event listeners are not automatically removed from memory because the garbage
+         * collector does not remove the listener as long as the dispatching object exists (unless the
+         * useWeakReference parameter is set to true).
+         *
+         * Copying an {@link EventDispatcher} instance does not copy the event listeners attached to it. (If your n
+         * ewly created node needs an event listener, you must attach the listener after creating the node.) However,
+         * if you move an {@link EventDispatcher} instance, the event listeners attached to it move along with it.
+         *
+         * If the event listener is being registered on a node while an event is also being processed on this node,
+         * the event listener is not triggered during the current phase but may be triggered during a later phase in
+         * the event flow, such as the bubbling phase.
+         *
+         * If an event listener is removed from a node while an event is being processed on the node, it is still
+         * triggered by the current actions. After it is removed, the event listener is never invoked again (unless it
+         * is registered again for future processing).
+         *
+         * @param event The type of event.
+         * @param listener The listener function that processes the event.
+         *				 This function must accept an Event object as its only parameter and must return
+         *				 nothing.
+         * @param thisArg The object to be used as the **this** object.
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        /**
+         * Removes a listener from the {@link EventDispatcher} object. If there is no matching listener registered
+         * with the {@link EventDispatcher} object, a call to this method has no effect.
+         *
+         * @param type The type of event.
+         * @param listener The listener object to remove.
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        /**
+         * Removes a listener from the {@link EventDispatcher} object. If there is no matching listener registered
+         * with the {@link EventDispatcher} object, a call to this method has no effect.
+         *
+         * @param type The type of event.
+         * @param listener The listener object to remove.
+         * @param thisArg The object to be used as the **this** object.
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+    }
+    /**
+     * The {@link EventDispatcher} class is the base class for all classes that dispatch events. The
+     * {@link EventDispatcher} class implements the {@link IEventDispatcher} interface and is the base class for the
+     * {@link DisplayObject} class. The {@link EventDispatcher} class allows any object on the display list to be an
+     * event target and as such, to use the methods of the {@link IEventDispatcher} interface.
+     *
+     * The event target serves as the local point for how events flow through the display list hierarchy. When an
+     * event such as a mouse click or a key press occurs, an event object is dispatched into the event flow from the
+     * root of the display list. The event object makes a round-trip journey to the event target, which is
+     * conceptually divided into three phases: the capture phase includes the journey from the root to the last node
+     * before the event target's node; the target phase includes only the event target node; and the bubbling phase
+     * includes any subsequent nodes encountered on the return trip to the root of the display list.
+     *
+     * In general, the easiest way for a user-defined class to gain event dispatching capabilities is to extend
+     * {@link EventDispatcher}. If this is impossible (that is, if the class is already extending another class), you
+     * can instead implement the {@link IEventDispatcher} interface, create an {@link EventDispatcher} member, and
+     * write simple hooks to route calls into the aggregated {@link EventDispatcher}.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/EventDispatcher.html
+     * @author Migrated by Jeongho Nam <http://samchon.org>
+     */
+    class EventDispatcher implements IEventDispatcher {
+        /**
+         * @hidden
+         */
+        private event_dispatcher_;
+        /**
+         * @hidden
+         */
+        private event_listeners_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from the origin event dispatcher.
+         *
+         * @param dispatcher The origin object who issuing events.
+         */
+        constructor(dispatcher: IEventDispatcher);
+        /**
+         * @inheritdoc
+         */
+        hasEventListener(type: string): boolean;
+        /**
+         * @inheritdoc
+         */
+        dispatchEvent(event: library.BasicEvent): boolean;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener): void;
+        /**
+         * @inheritdoc
+         */
+        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener): void;
+        /**
+         * @inheritdoc
+         */
+        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * The {@link FileReference} class provides a means to load and save files in browser level.
+     *
+     * The {@link FileReference} class provides a means to {@link load} and {@link save} files in browser level. A
+     * browser-system dialog box prompts the user to select a file to {@link load} or a location for {@link svae}. Each
+     * {@link FileReference} object refers to a single file on the user's disk and has properties that contain
+     * information about the file's size, type, name, creation date, modification date, and creator type (Macintosh only).
+     *
+     *
+     * FileReference instances are created in the following ways:
+     * <ul>
+     *	<li>
+     *		When you use the new operator with the {@link FileReference} constructor:
+     *		<code>let myFileReference: FileReference = new FileReference();</code>
+     *	</li>
+     *	<li>
+     *		When you call the {@link FileReferenceList.browse} method, which creates an array of {@link FileReference}
+     *		objects.
+     *	</li>
+     * </ul>
+     *
+     * During a load operation, all the properties of a {@link FileReference} object are populated by calls to the
+     * {@link FileReference.browse} or {@link FileReferenceList.browse} methods. During a save operation, the name
+     * property is populated when the select event is dispatched; all other properties are populated when the complete
+     * event is dispatched.
+     *
+     * The {@link browse browse()} method opens an browser-system dialog box that prompts the user to select a file
+     * for {@link load}. The {@link FileReference.browse} method lets the user select a single file; the
+     * {@link FileReferenceList.browse} method lets the user select multiple files. After a successful call to the
+     * {@link browse browse()} method, call the {@link FileReference.load} method to load one file at a time. The
+     * {@link FileReference.save} method prompts the user for a location to save the file and initiates downloading from
+     * a binary or string data.
+     *
+     * The {@link FileReference} and {@link FileReferenceList} classes do not let you set the default file location
+     * for the dialog box that the {@link browse} or {@link save} methods generate. The default location shown in the
+     * dialog box is the most recently browsed folder, if that location can be determined, or the desktop. The classes do
+     * not allow you to read from or write to the transferred file. They do not allow the browser that initiated the
+     * {@link load} or {@link save} to access the loaded or saved file or the file's location on the user's disk.
+     *
+     * @references http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReference.html
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class FileReference extends EventDispatcher {
+        /**
+         * @hidden
+         */
+        private file_;
+        /**
+         * @hidden
+         */
+        private data_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * The data from the loaded file after a successful call to the {@link load load()} method.
+         *
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
+         *
+         */
+        readonly data: any;
+        /**
+         * The name of the file on the local disk.
+         *
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
+         *
+         */
+        readonly name: string;
+        /**
+         * The filename extension.
+         *
+         * A file's extension is the part of the name following (and not including) the final dot (&quot;.&quot;). If
+         * there is no dot in the filename, the extension is <code>null</code>.
+         *
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
+         *
+         */
+        readonly extension: string;
+        /**
+         * The file type, metadata of the {@link extension}.
+         *
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
+         *
+         */
+        readonly type: string;
+        /**
+         * The size of the file on the local disk in bytes.
+         *
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
+         *
+         */
+        readonly size: number;
+        /**
+         * The date that the file on the local disk was last modified.
+         *
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
+         *
+         */
+        readonly modificationDate: Date;
+        /**
+         * Displays a file-browsing dialog box that lets the user select a file to upload. The dialog box is native
+         * to the user's browser system. The user can select a file on the local computer or from other systems, for
+         * example, through a UNC path on Windows.
+         *
+         * When you call this method and the user successfully selects a file, the properties of this
+         * {@link FileReference} object are populated with the properties of that file. Each subsequent time that the
+         * {@link FileReference.browse} method is called, the {@link FileReference} object's properties are reset to
+         * the file that the user selects in the dialog box. Only one {@link browse browse()} can be performed at a time
+         * (because only one dialog box can be invoked at a time).
+         *
+         * Using the *typeFilter parameter*, you can determine which files the dialog box displays.
+         *
+         * @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
+         *					 If you omit this parameter, all files are displayed.
+         */
+        browse(...typeFilter: string[]): void;
+        /**
+         * Starts the load of a local file selected by a user.
+         *
+         * You must call the {@link FileReference.browse} or {@link FileReferenceList.browse} method before you call
+         * the {@link load load()} method.
+         *
+         * Listeners receive events to indicate the progress, success, or failure of the load. Although you can use
+         * the {@link FileReferenceList} object to let users select multiple files to load, you must {@link load} the
+         * {@link FileReferenceList files} one by one. To {@link load} the files one by one, iterate through the
+         * {@link FileReferenceList.fileList} array of {@link FileReference} objects.
+         *
+         * If the file finishes loading successfully, its contents are stored in the {@link data} property.
+         */
+        load(): void;
+        /**
+         * Save a file to local filesystem.
+         *
+         * {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
+         * However, the plan, future's {@link FileReference} will follow such rule:
+         *
+         * Opens a dialog box that lets the user save a file to the local filesystem.
+         *
+         * The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
+         * filename and select a location on the local computer to save the file. When the user selects a location and
+         * confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
+         * to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
+         * and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
+         * open, progress, and complete.
+         *
+         * When the file is saved successfully, the properties of the {@link FileReference} object are populated with
+         * the properties of the local file. The complete event is dispatched if the save is successful.
+         *
+         * Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
+         * dialog box can be invoked at a time).
+         *
+         * @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
+         * @param fileName File name to be saved.
+         */
+        save(data: string, fileName: string): void;
+        /**
+         * Save a file to local filesystem.
+         *
+         * {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
+         * However, the plan, future's {@link FileReference} will follow such rule:
+         *
+         * Opens a dialog box that lets the user save a file to the local filesystem.
+         *
+         * The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
+         * filename and select a location on the local computer to save the file. When the user selects a location and
+         * confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
+         * to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
+         * and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
+         * open, progress, and complete.
+         *
+         * When the file is saved successfully, the properties of the {@link FileReference} object are populated with
+         * the properties of the local file. The complete event is dispatched if the save is successful.
+         *
+         * Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
+         * dialog box can be invoked at a time).
+         *
+         * @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
+         * @param fileName File name to be saved.
+         */
+        static save(data: string, fileName: string): void;
+    }
+    /**
+     * The {@link FileReferenceList} class provides a means to let users select one or more files for
+     * {@link FileReference.load loading}. A {@link FileReferenceList} object represents a group of one or more local
+     * files on the user's disk as an array of {@link FileReference} objects. For detailed information and important
+     * considerations about {@link FileReference} objects and the FileReference class, which you use with
+     * {@link FileReferenceList}, see the {@link FileReference} class.
+     *
+     * To work with the {@link FileReferenceList} class:
+     * <ul>
+     *	<li> Instantiate the class: <code>var myFileRef = new FileReferenceList();</code> </li>
+     *	<li>
+     *		Call the {@link FileReferenceList.browse} method, which opens a dialog box that lets the user select one or
+     *		more files for upload: <code>myFileRef.browse();</code>
+     *	</li>
+     *	<li>
+     *		After the {@link browse browse()} method is called successfully, the {@link fileList} property of the
+     *		{@link FileReferenceList} object is populated with an array of {@link FileReference} objects.
+     *	</li>
+     *	<li> Call {@link FileReference.load} on each element in the {@link fileList} array. </li>
+     * </ul>
+     *
+     * The {@link FileReferenceList} class includes a {@link browse browse()} method and a {@link fileList} property
+     * for working with multiple files.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReferenceList.html
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class FileReferenceList extends EventDispatcher {
+        /**
+         * @hidden
+         */
+        file_list: std.Vector<FileReference>;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * An array of {@link FileReference} objects.
+         *
+         * When the {@link FileReferenceList.browse} method is called and the user has selected one or more files
+         * from the dialog box that the {@link browse browse()} method opens, this property is populated with an array of
+         * {@link FileReference} objects, each of which represents the files the user selected.
+         *
+         * The {@link fileList} property is populated anew each time {@link browse browse()} is called on that
+         * {@link FileReferenceList} object.
+         */
+        readonly fileList: std.Vector<FileReference>;
+        /**
+         * Displays a file-browsing dialog box that lets the user select one or more local files to upload. The
+         * dialog box is native to the user's browser system.
+         *
+         * When you call this method and the user successfully selects files, the {@link fileList} property of this
+         * {@link FileReferenceList} object is populated with an array of {@link FileReference} objects, one for each
+         * file that the user selects. Each subsequent time that the {@link FileReferenceList.browse} method is called,
+         * the {@link FileReferenceList.fileList} property is reset to the file(s) that the user selects in the dialog
+         * box.
+         *
+         * Using the *typeFilter* parameter, you can determine which files the dialog box displays.
+         *
+         * Only one {@link FileReference.browse}, {@link FileReference.load}, or {@link FileReferenceList.browse}
+         * session can be performed at a time on a {@link FileReferenceList} object (because only one dialog box can be
+         * opened at a time).
+         *
+         * @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
+         *					 If you omit this parameter, all files are displayed.
+         */
+        browse(...typeFilter: string[]): void;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * A genetic algorithm class.
+     *
+     * In the field of artificial intelligence, a genetic algorithm (GA) is a search heuristic that mimics the
+     * process of natural selection. This heuristic (also sometimes called a metaheuristic) is routinely used to generate
+     * useful solutions to optimization and search problems.
+     *
+     * Genetic algorithms belong to the larger class of evolutionary algorithms (EA), which generate solutions to
+     * optimization problems using techniques inspired by natural evolution, such as inheritance, {@link mutate mutation},
+     * {@link selection}, and {@link crossover}.
+     *
+     * @reference https://en.wikipedia.org/wiki/Genetic_algorithm
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class GeneticAlgorithm {
+        /**
+         * Whether each element (Gene) is unique in their GeneArray.
+         */
+        private unique_;
+        /**
+         * Rate of mutation.
+         *
+         * The {@link mutation_rate} determines the percentage of occurence of mutation in GeneArray.
+         *
+         * <ul>
+         *	<li> When {@link mutation_rate} is too high, it is hard to ancitipate studying on genetic algorithm. </li>
+         *	<li>
+         *		When {@link mutation_rate} is too low and initial set of genes (GeneArray) is far away from optimal, the
+         *		evolution tends to wandering outside of he optimal.
+         *	</li>
+         * </ul>
+         */
+        private mutation_rate_;
+        /**
+         * Number of tournaments in selection.
+         */
+        private tournament_;
+        /**
+         * Initialization Constructor.
+         *
+         * @param unique Whether each Gene is unique in their GeneArray.
+         * @param mutation_rate Rate of mutation.
+         * @param tournament Number of tournaments in selection.
+         */
+        constructor(unique?: boolean, mutation_rate?: number, tournament?: number);
+        /**
+         * Evolove *GeneArray*.
+         *
+         * Convenient method accessing to {@link evolvePopulation evolvePopulation()}.
+         *
+         * @param individual An initial set of genes; sequence listing.
+         * @param population Size of population in a generation.
+         * @param generation Size of generation in evolution.
+         * @param compare A comparison function returns whether left gene is more optimal.
+         *
+         * @return An evolved *GeneArray*, optimally.
+         *
+         * @see {@link GAPopulation.compare}
+         */
+        evolveGeneArray<T, GeneArray extends std.base.IArrayContainer<T>>(individual: GeneArray, population: number, generation: number, compare?: (left: T, right: T) => boolean): GeneArray;
+        /**
+         * Evolve *population*, a mass of *GeneArraies*.
+         *
+         * @param population An initial population.
+         * @param compare A comparison function returns whether left gene is more optimal.
+         *
+         * @return An evolved population.
+         *
+         * @see {@link GAPopulation.compare}
+         */
+        evolvePopulation<T, GeneArray extends std.base.IArrayContainer<T>>(population: GAPopulation<T, GeneArray>, compare?: (left: T, right: T) => boolean): GAPopulation<T, GeneArray>;
+        /**
+         * Select the best GeneArray in *population* from tournament.
+         *
+         * {@link selection Selection} is the stage of a genetic algorithm in which individual genomes are chosen
+         * from a population for later breeding (using {@linlk crossover} operator). A generic {@link selection}
+         * procedure may be implemented as follows:
+         *
+         * <ol>
+         *	<li>
+         *		The fitness function is evaluated for each individual, providing fitness values, which are then
+         *		normalized. ization means dividing the fitness value of each individual by the sum of all fitness
+         *		values, so that the sum of all resulting fitness values equals 1.
+         *	</li>
+         *	<li> The population is sorted by descending fitness values. </li>
+         *	<li>
+         *		Accumulated normalized fitness values are computed (the accumulated fitness value of an individual is the
+         *		sum of its own fitness value plus the fitness values of all the previous individuals). The accumulated
+         *		fitness of the last individual should be 1 (otherwise something went wrong in the normalization step).
+         *	</li>
+         *	<li> A random number R between 0 and 1 is chosen. </li>
+         *	<li> The selected individual is the first one whose accumulated normalized value is greater than R. </li>
+         * </ol>
+         *
+         * @param population The target of tournament.
+         * @return The best genes derived by the tournament.
+         *
+         * @reference https://en.wikipedia.org/wiki/Selection_(genetic_algorithm)
+         */
+        private selection<T, GeneArray>(population);
+        /**
+         * Create a new GeneArray by crossing over two *GeneArray*(s).
+         *
+         * {@link crossover} is a genetic operator used to vary the programming of a chromosome or chromosomes from
+         * one generation to the next. It is analogous to reproduction and biological crossover, upon which genetic
+         * algorithms are based.
+         *
+         * {@link crossover Cross over} is a process of taking more than one parent solutions and producing a child
+         * solution from them. There are methods for selection of the chromosomes.
+         *
+         * @param parent1 A parent sequence listing
+         * @param parent2 A parent sequence listing
+         *
+         * @reference https://en.wikipedia.org/wiki/Crossover_(genetic_algorithm)
+         */
+        private crossover<T, GeneArray>(parent1, parent2);
+        /**
+         * Cause a mutation on the *GeneArray*.
+         *
+         * {@link mutate Mutation} is a genetic operator used to maintain genetic diversity from one generation of a
+         * population of genetic algorithm chromosomes to the next. It is analogous to biological mutation.
+         *
+         * {@link mutate Mutation} alters one or more gene values in a chromosome from its initial state. In
+         * {@link mutate mutation}, the solution may change entirely from the previous solution. Hence GA can come to
+         * better solution by using {@link mutate mutation}.
+         *
+         * {@link mutate Mutation} occurs during evolution according to a user-definable mutation probability. This
+         * probability should be set low. If it is set too high, the search will turn into a primitive random search.
+         *
+         * <h4> Note </h4>
+         * Muttion is pursuing diversity. Mutation is useful for avoiding the following problem.
+         *
+         * When initial set of genes(GeneArray) is far away from optimail, without mutation (only with selection and
+         * crossover), the genetic algorithm has a tend to wandering outside of the optimal.
+         *
+         * Genes in the GeneArray will be swapped following percentage of the {@link mutation_rate}.
+         *
+         * @param individual A container of genes to mutate
+         *
+         * @reference https://en.wikipedia.org/wiki/Mutation_(genetic_algorithm)
+         * @see {@link mutation_rate}
+         */
+        private mutate<T, GeneArray>(individual);
+    }
+    /**
+     * A population in a generation.
+     *
+     * {@link GAPopulation} is a class representing population of candidate genes (sequence listing) having an array
+     * of GeneArray as a member. {@link GAPopulation} also manages initial set of genes and handles fitting test direclty
+     * by the method {@link fitTest fitTest()}.
+     *
+     * The success of evolution of genetic algorithm is depend on the {@link GAPopulation}'s initial set and fitting
+     * test. (*GeneArray* and {@link compare}.)
+     *
+     * <h4> Warning </h4>
+     * Be careful for the mistakes of direction or position of the {@link compare}.
+     * Most of logical errors failed to access optimal solution are occured from those mistakes.
+     *
+     * @param <T> Type of gene elements.
+     * @param <GeneArray> An array containing genes as elments; sequnce listing.
+     *
+     * @author Jeongho Nam <http://samcho.org>
+     */
+    class GAPopulation<T, GeneArray extends std.base.IArrayContainer<T>> {
+        /**
+         * Genes representing the population.
+         */
+        private children_;
+        /**
+         * A comparison function returns whether left gene is more optimal, greater.
+         *
+         * Default value of this {@link compare} is {@link std.greater}. It means to compare two array
+         * (GeneArray must be a type of {@link std.base.IArrayContainer}). Thus, you've to keep follwing rule.
+         *
+         * <ul>
+         *	<li> GeneArray is implemented from {@link std.base.IArrayContainer}. </li>
+         *	<ul>
+         *		<li> {@link std.Vector} </li>
+         *		<li> {@link std.Deque} </li>
+         *	</ul>
+         *	<li> GeneArray has custom <code>public less(obj: T): boolean;</code> function. </li>
+         * </ul>
+         *
+         * If you don't want to follow the rule or want a custom comparison function, you have to realize a
+         * comparison function.
+         */
+        private compare_;
+        /**
+         * Private constructor with population.
+         *
+         * Private constructor of GAPopulation does not create {@link children}. (candidate genes) but only assigns
+         * *null* repeatedly following the *population size*.
+         *
+         * This private constructor is designed only for {@link GeneticAlgorithm}. Don't create {@link GAPopulation}
+         * with this constructor, by yourself.
+         *
+         * @param size Size of the population.
+         */
+        constructor(size: number);
+        /**
+         * Construct from a {@link GeneArray} and *size of the population*.
+         *
+         * This public constructor creates *GeneArray(s)* as population (size) having shuffled genes which are
+         * came from the initial set of genes (*geneArray*). It uses {@link std.greater} as default comparison function.
+         *
+         *
+         * @param geneArray An initial sequence listing.
+         * @param size The size of population to have as children.
+         */
+        constructor(geneArray: GeneArray, size: number);
+        /**
+         * Constructor from a GeneArray, size of the poluation and custom comparison function.
+         *
+         * This public constructor creates *GeneArray(s)* as population (size) having shuffled genes which are
+         * came from the initial set of genes (*geneArray*). The *compare* is used for comparison function.
+         *
+         *
+         * @param geneArray An initial sequence listing.
+         * @param size The size of population to have as children.
+         * @param compare A comparison function returns whether left gene is more optimal.
+         */
+        constructor(geneArray: GeneArray, size: number, compare: (left: GeneArray, right: GeneArray) => boolean);
+        children(): std.Vector<GeneArray>;
+        /**
+         * Test fitness of each *GeneArray* in the {@link population}.
+         *
+         * @return The best *GeneArray* in the {@link population}.
+         */
+        fitTest(): GeneArray;
+        /**
+         * @hidden
+         */
+        private clone(obj);
+    }
+}
+declare namespace samchon.library {
+    /**
+     * A utility class supporting static methods of string.
+     *
+     * The {@link StringUtil} utility class is an all-static class with methods for working with string objects.
+     * You do not create instances of {@link StringUtil}; instead you call methods such as the
+     * ```StringUtil.substitute()``` method.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/mx/utils/StringUtil.html
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class StringUtil {
+        /**
+         * Generate a substring.
+         *
+         * Extracts a substring consisting of the characters from specified start to end.
+         * It's same with str.substring( ? = (str.find(start) + start.size()), str.find(end, ?) )
+         *
+         * ```typescript
+         * let str: string = StringUtil.between("ABCD(EFGH)IJK", "(", ")");
+         * console.log(str); // PRINTS "EFGH"
+         * ```
+         *
+         * - If start is not specified, extracts from begin of the string to end. </li>
+         * - If end is not specified, extracts from start to end of the string. </li>
+         * - If start and end are all omitted, returns str, itself. </li>
+         *
+         * @param str Target string to be applied between.
+         * @param start A string for separating substring at the front.
+         * @param end A string for separating substring at the end.
+         *
+         * @return substring by specified terms.
+         */
+        static between(str: string, start?: string, end?: string): string;
+        /**
+         * Fetch substrings.
+         *
+         * Splits a string into an array of substrings dividing by specified delimeters of start and end.
+         * It's the array of substrings adjusted the between.
+         *
+         * <ul>
+         *	<li> If startStr is omitted, it's same with the split by endStr not having last item. </li>
+         *	<li> If endStr is omitted, it's same with the split by startStr not having first item. </li>
+         *	<li> If startStr and endStar are all omitted, returns *str*. </li>
+         * </ul>
+         *
+         * @param str Target string to split by between.
+         * @param start A string for separating substring at the front.
+         *				If omitted, it's same with split(end) not having last item.
+         * @param end A string for separating substring at the end.
+         *			  If omitted, it's same with split(start) not having first item.
+         * @return An array of substrings.
+         */
+        static betweens(str: string, start?: string, end?: string): Array<string>;
+        /**
+         * An array containing whitespaces.
+         */
+        private static SPACE_ARRAY;
+        /**
+         * Remove all designated characters from the beginning and end of the specified string.
+         *
+         * @param str The string whose designated characters should be trimmed.
+         * @param args Designated character(s).
+         *
+         * @return Updated string where designated characters was removed from the beginning and end.
+         */
+        static trim(str: string, ...args: string[]): string;
+        /**
+         * Remove all designated characters from the beginning of the specified string.
+         *
+         * @param str The string should be trimmed.
+         * @param delims Designated character(s).
+         *
+         * @return Updated string where designated characters was removed from the beginning
+         */
+        static ltrim(str: string, ...args: string[]): string;
+        /**
+         * Remove all designated characters from the end of the specified string.
+         *
+         * @param str The string should be trimmed.
+         * @param delims Designated character(s).
+         *
+         * @return Updated string where designated characters was removed from the end.
+         */
+        static rtrim(str: string, ...args: string[]): string;
+        /**
+         * Substitute `{n}` tokens within the specified string.
+         *
+         * @param format The string to make substitutions in. This string can contain special tokens of the form
+         *				 `{n}`, where *n* is a zero based index, that will be replaced with the additional parameters
+         *				 found at that index if specified.
+         * @param args Additional parameters that can be substituted in the *format* parameter at each
+         *			   `{n}` location, where *n* is an integer (zero based) index value into the array of values
+         *			   specified.
+         *
+         * @return New string with all of the `{n}` tokens replaced with the respective arguments specified.
+         */
+        static substitute(format: string, ...args: any[]): string;
+        /**
+         * Substitute `{n}` tokens within the specified SQL-string.
+         *
+         * @param format The string to make substitutions in. This string can contain special tokens of the form
+         *				 `{n}`, where *n* is a zero based index, that will be replaced with the additional parameters
+         *				 found at that index if specified.
+         * @param args Additional parameters that can be substituted in the *format* parameter at each
+         *			   `{n}` location, where *n* is an integer (zero based) index value into the array of values
+         *			   specified.
+         *
+         * @return New SQL-string with all of the `{n}` tokens replaced with the respective arguments specified.
+         */
+        static substituteSQL(format: string, ...args: any[]): string;
+        /**
+         * @hidden
+         */
+        private static _Fetch_substitute_index(format);
+        /**
+         * Returns a string specified word is replaced.
+         *
+         * @param str Target string to replace
+         * @param before Specific word you want to be replaced
+         * @param after Specific word you want to replace
+         *
+         * @return A string specified word is replaced
+         */
+        static replaceAll(str: string, before: string, after: string): string;
+        /**
+         * Returns a string specified words are replaced.
+         *
+         * @param str Target string to replace
+         * @param pairs A specific word's pairs you want to replace and to be replaced
+         *
+         * @return A string specified words are replaced
+         */
+        static replaceAll(str: string, ...pairs: std.Pair<string, string>[]): string;
+        /**
+         * Replace all HTML spaces to a literal space.
+         *
+         * @param str Target string to replace.
+         */
+        static removeHTMLSpaces(str: string): string;
+        /**
+         * Repeat a string.
+         *
+         * Returns a string consisting of a specified string concatenated with itself a specified number of times.
+         *
+         * @param str The string to be repeated.
+         * @param n The repeat count.
+         *
+         * @return The repeated string.
+         */
+        static repeat(str: string, n: number): string;
+        /**
+         * Number to formatted string with &quot;,&quot; sign.
+         *
+         * Returns a string converted from the number rounded off from specified precision with &quot;,&quot; symbols.
+         *
+         * @param val A number wants to convert to string.
+         * @param precision Target precision of round off.
+         *
+         * @return A string who represents the number with roundoff and &quot;,&quot; symbols.
+         */
+        static numberFormat(val: number, precision?: number): string;
+        static percentFormat(val: number, precision?: number): string;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * URLVariables class is for representing variables of HTTP.
+     *
+     * {@link URLVariables} class allows you to transfer variables between an application and server.
+     *
+     * When transfering, {@link URLVariables} will be converted to a *URI* string.
+     * - URI: Uniform Resource Identifier
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/URLVariables.html
+     * @author Migrated by Jeongho Nam <http://samchon.org>
+     */
+    class URLVariables extends std.HashMap<string, string> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from a URL-encoded string.
+         *
+         * The {@link decode decode()} method is automatically called to convert the string to properties of the {@link URLVariables} object.
+         *
+         * @param str A URL-encoded string containing name/value pairs.
+         */
+        constructor(str: string);
+        /**
+         * Converts the variable string to properties of the specified URLVariables object.
+         *
+         * @param str A URL-encoded query string containing name/value pairs.
+         */
+        decode(str: string): void;
+        /**
+         * Returns a string containing all enumerable variables, in the MIME content encoding application/x-www-form-urlencoded.
+         */
+        toString(): string;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * A tree-structured XML object.
+     *
+     * The {@link XML| class contains methods and properties for working with XML objects. The {@link XML} class (along
+     * with the {@link XMLList}) implements the powerful XML-handling standards defined in ECMAScript for XML (E4X)
+     * specification (ECMA-357 edition 2).
+     *
+     * An XML object, it is composed with three members; {@link getTag tag}, {@link getProperty properties} and
+     * {@link getValue value}. As you know, XML is a tree structured data expression method. The tree-stucture;
+     * {@link XML} class realizes it by extending ```std.HashMap<string, XMLList>```. Child {@link XML} objects are
+     * contained in the matched {@link XMLList} object being grouped by their {@link getTag tag name}. The
+     * {@link XMLList} objects, they're stored in the {@link std.HashMap} ({@link XML} itself) with its **key**; common
+     * {@link getTag tag name} of children {@link XML} objects.
+     *
+     * ```typescript
+     * class XML extends std.HashMap<string, XMLList>
+     * {
+     *	private tag_: string;
+     *	private properties_: std.HashMap<string, string>;
+     *	private value_: string;
+     * }
+     * ```
+     *
+     * ```xml
+     * <?xml version="1.0" ?>
+     * <TAG property_name={property_value}>
+     *	<!--
+     *		The child XML objects with "CHILD_TAG", They're contained in an XMLList object.
+     *		The XMLList object, it is stored in std.HashMap (XML class itself) with its key "CHILD_TAG"
+     *	-->
+     *	<CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
+     *  <CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
+     *	<CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
+     *
+     *	<!--
+     *		The child XML object named "ANOTHER_TAG", it also belonged to an XMLList ojbect.
+     *		And the XMLList is also being contained in the std.HashMap with its key "ANOTHER_TAG"
+     *	-->
+     *	<ANOTHER_TAG />
+     * </TAG>
+     * ```
+     *
+     * Use the {@link toString toString()} method to return a string representation of the {@link XML} object regardless
+     * of whether the {@link XML} object has simple content or complex content.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/XML.html
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-XML
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class XML extends std.HashMap<string, XMLList> {
+        /**
+         * @hidden
+         */
+        private tag_;
+        /**
+         * @hidden
+         */
+        private value_;
+        /**
+         * @hidden
+         */
+        private property_map_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from string.
+         *
+         * Creates {@link XML} object by parsing a string who represents xml structure.
+         *
+         * @param str A string represents XML structure.
+         */
+        constructor(str: string);
+        /**
+         * @hidden
+         */
+        private _Parse(str);
+        /**
+         * @hidden
+         */
+        private _Parse_tag(str);
+        /**
+         * @hidden
+         */
+        private _Parse_properties(str);
+        /**
+         * @hidden
+         */
+        private _Parse_value(str);
+        /**
+         * @hidden
+         */
+        private _Parse_children(str);
+        /**
+         * Get tag.
+         *
+         * ```xml
+         * <TAG property_key={property_value}>{value}</TAG>
+         * ```
+         *
+         * @return tag.
+         */
+        getTag(): string;
+        /**
+         * Get value.
+         *
+         * ```xml
+         * <tag property_key={property_value}>{VALUE}</tag>
+         * ```
+         *
+         * @return value.
+         */
+        getValue(): string;
+        /**
+         * Get iterator to property element.
+         *
+         * Searches the {@link getPropertyMap properties} for an element with a identifier equivalent to <i>key</i>
+         * and returns an iterator to it if found, otherwise it returns an iterator to {@link HashMap.end end()}.
+         *
+         * <p> Two keys are considered equivalent if the properties' comparison object returns false reflexively
+         * (i.e., no matter the order in which the elements are passed as arguments). </p>
+         *
+         * Another member function, {@link hasProperty hasProperty()} can be used to just check whether a particular
+         * <i>key</i> exists.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={property_value}>{value}</tag>
+         * ```
+         *
+         * @param key Key to be searched for
+         * @return An iterator to the element, if an element with specified <i>key</i> is found, or
+         *		   {@link end HashMap.end()} otherwise.
+         */
+        findProperty(key: string): std.MapIterator<string, string>;
+        /**
+         * Test whether a property exists.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={property_value}>{value}</tag>
+         * ```
+         *
+         * @return Whether a property has the *key* exists or not.
+         */
+        hasProperty(key: string): boolean;
+        /**
+         * Get property.
+         *
+         * Get property by its *key*, property name. If the matched *key* does not exist, then exception
+         * {@link std.OutOfRange} is thrown. Thus, it would better to test whether the *key* exits or not by calling the
+         * {@link hasProperty hasProperty()} method before calling this {@link getProperty getProperty()}.
+         *
+         * This method can be substituted by {@link getPropertyMap getPropertyMap()} such below:
+         * - ```getPropertyMap().get(key, value);```
+         * - ```getPropertyMap().find(key).second;```
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={PROPERTY_VALUE}>{value}</tag>
+         * ```
+         *
+         * @return Value of the matched property.
+         */
+        getProperty(key: string): string;
+        /**
+         * Get property map.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY1={PROPERTY_VALUE1}
+         *		PROPERTY_KEY2={PROPERTY_VALUE2}
+         *		PROPERTY_KEY3={PROPERTY_VALUE3}>{value}</tag>
+         * ```
+         *
+         * @return {@link HashMap} containing properties' keys and values.
+         */
+        getPropertyMap(): std.HashMap<string, string>;
+        /**
+         * Set tag.
+         *
+         * Set tag name, identifier of this {@link XML} object.
+         *
+         * If this {@link XML} object is belonged to, a child of, an {@link XMLList} and its related {@link XML} objects,
+         * then calling this {@link setTag setTag()} method direclty is not recommended. Erase this {@link XML} object
+         * from parent objects and insert this object again.
+         *
+         * ```xml
+         * <TAG property_key={property_value}>{value}</TAG>
+         * ```
+         *
+         * @param val To be new {@link getTag tag}.
+         */
+        setTag(val: string): void;
+        /**
+         * Set value.
+         *
+         * ```xml
+         * <tag property_key={property_value}>{VALUE}</tag>
+         * ```
+         *
+         * @param val To be new {@link getValue value}.
+         */
+        setValue(val: string): void;
+        /**
+         * Set property.
+         *
+         * Set a property *value* with its *key*. If the *key* already exists, then the *value* will be overwritten to
+         * the property. Otherwise the *key* is not exist yet, then insert the *key* and *value* {@link Pair pair} to
+         * {@link getPropertyMao property map}.
+         *
+         * This method can be substituted by {@link getPropertyMap getPropertyMap()} such below:
+         * - ```getPropertyMap().set(key, value);```
+         * - ```getPropertyMap().emplace(key, value);```
+         * - ```getPropertyMap().insert([key, value]);```
+         * - ```getPropertyMap().insert(std.make_pair(key, value));```
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={PROPERTY_VALUE}>{value}</tag>
+         * ```
+         *
+         * @param key Key, identifier of property to be newly inserted.
+         * @param value Value of new property to be newly inserted.
+         */
+        setProperty(key: string, value: string): void;
+        /**
+         * Erase property.
+         *
+         * Erases a property by its *key*, property name. If the matched *key* does not exist, then exception
+         * {@link std.OutOfRange} is thrown. Thus, it would better to test whether the *key* exits or not by calling the
+         * {@link hasProperty hasProperty()} method before calling this {@link eraseProperty eraseProperty()}.
+         *
+         * This method can be substituted by ``getPropertyMap().erase(key)````.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={property_value}>{value}</tag>
+         * ```
+         *
+         * @param key Key of the property to erase
+         * @throw {@link std.OutOfRange}
+         */
+        eraseProperty(key: string): void;
+        /**
+         * @hidden
+         */
+        push(...args: std.Pair<string, XMLList>[]): number;
+        /**
+         * @hidden
+         */
+        push(...args: [string, XMLList][]): number;
+        push(...xmls: XML[]): number;
+        push(...xmlLists: XMLList[]): number;
+        /**
+         * Add all properties from other {@link XML} object.
+         *
+         * All the properties in the *obj* are copied to this {@link XML} object. If this {@link XML} object has same
+         * property key in the *obj*, then value of the property will be replaced to *obj*'s own. If you don't want to
+         * overwrite properties with same key, then use {@link getPropertyMap getPropertyMap()} method.
+         *
+         * ```typescript
+         * let x: library.XML;
+         * let y: library.XML;
+         *
+         * x.addAllProperties(y); // duplicated key exists, then overwrites
+         * x.getPropertyMap().insert(y.getPropertyMap().begin(), y.getPropertyMap().end());
+         *	// ducpliated key, then ignores. only non-duplicateds are copied.
+         * ```
+         *
+         * ```xml
+         * <tag PROPERTY_KEY1={property_value1}
+         *		PROPERTY_KEY2={property_value2}
+         *		PROPERTY_KEY3={property_value3}>{value}</tag>
+         * ```
+         *
+         * @param obj Target {@link XML} object to copy properties.
+         */
+        insertAllProperties(obj: XML): void;
+        /**
+         * Clear properties.
+         *
+         * Remove all properties. It's same with calling ```getPropertyMap().clear()```.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY1={property_value1}
+         *		PROPERTY_KEY2={property_value2}
+         *		PROPERTY_KEY3={property_value3}>{value}</tag>
+         * ```
+         */
+        clearProperties(): void;
+        /**
+         * @hidden
+         */
+        private _Compute_min_index(...args);
+        /**
+         * @hidden
+         */
+        private _Decode_value(str);
+        /**
+         * @hidden
+         */
+        private _Encode_value(str);
+        /**
+         * @hidden
+         */
+        private _Decode_property(str);
+        /**
+         * @hidden
+         */
+        private _Encode_property(str);
+        /**
+         * {@link XML} object to xml string.
+         *
+         * Returns a string representation of the {@link XML} object.
+         *
+         * @param tab Number of tabs to spacing.
+         * @return The string representation of the {@link XML} object.
+         */
+        toString(tab?: number): string;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * List of {@link XML} objects with same tag.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/XMLList.html
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-XML
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class XMLList extends std.Deque<XML> {
+        /**
+         * Get tag.
+         */
+        getTag(): string;
+        /**
+         * {@link XMLList XML objects} to string.
+         *
+         * Returns a string representation of the {@link XMLList XML objects}.
+         *
+         * @param tab Number of tabs to spacing.
+         * @return The string representation of the {@link XMLList XML objects}.
+         */
+        toString(level?: number): string;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface of entity.
+     *
+     * Entity is a class for standardization of expression method using on network I/O by XML. If
+     * Invoke is a standard message protocol of Samchon Framework which must be kept, Entity is a
+     * recommended semi-protocol of message for expressing a data class. Following the semi-protocol
+     * Entity is not imposed but encouraged.
+     *
+     * As we could get advantages from standardization of message for network I/O with Invoke,
+     * we can get additional advantage from standardizing expression method of data class with Entity.
+     * We do not need to know a part of network communication. Thus, with the Entity, we can only
+     * concentrate on entity's own logics and relationships between another entities. Entity does not
+     * need to how network communications are being done.
+     *
+     * I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
+     * protocol for network I/O but not a essential protocol must be kept. The expression method of
+     * Entity, using on network I/O, is expressed by XML string.
+     *
+     * If your own network system has a critical performance issue on communication data class,
+     * it would be better to using binary communication (with ByteArray).
+     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray).
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IEntity {
+        /**
+         * Construct data of the Entity from a XML object.
+         *
+         * Overrides the construct() method and fetch data of member variables from the XML.
+         *
+         * By recommended guidance, data representing member variables are contained in properties
+         * of the put XML object.
+         *
+         * @param xml An xml used to contruct data of entity.
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Get a key that can identify the Entity uniquely.
+         *
+         * If identifier of the Entity is not atomic value, returns a paired or tuple object
+         * that can represents the composite identifier.
+         *
+         * <code>
+         * class Point extends Entity
+         * {
+         *     private x: number;
+         *     private y: number;
+         *
+         *     public key(): std.Pair<number, number>
+         *     {
+         *         return std.make_pair(this.x, this.y);
+         *     }
+         * }
+         * </code>
+         */
+        key(): any;
+        /**
+         * A tag name when represented by XML.
+         *
+         * <code> <TAG {...properties} /> </code>
+         */
+        TAG(): string;
+        /**
+         * Get a XML object represents the Entity.
+         *
+         * A member variable (not object, but atomic value like number, string or date) is categorized
+         * as a property within the framework of entity side. Thus, when overriding a toXML() method and
+         * archiving member variables to an XML object to return, puts each variable to be a property
+         * belongs to only a XML object.
+         *
+         * Don't archive the member variable of atomic value to XML::value causing enormouse creation
+         * of XML objects to number of member variables. An Entity must be represented by only a XML
+         * instance (tag).
+         *
+         * <h4> Standard Usage. </h4>
+         * <code>
+         * <memberList>
+         *	<member id='jhnam88' name='Jeongho Nam' birthdate='1988-03-11' />
+         *	<member id='master' name='Administartor' birthdate='2011-07-28' />
+         * </memberList>
+         * </code>
+         *
+         * <h4> Non-standard usage abusing value. </h4>
+         * <code>
+         * <member>
+         *	<id>jhnam88</id>
+         *	<name>Jeongho Nam</name>
+         *	<birthdate>1988-03-11</birthdate>
+         * </member>
+         * <member>
+         *	<id>master</id>
+         *	<name>Administartor</name>
+         *	<birthdate>2011-07-28</birthdate>
+         * </member>
+         * </code>
+         *
+         * @return An XML object representing the Entity.
+         */
+        toXML(): library.XML;
+    }
+    /**
+     * @hidden
+     */
+    namespace IEntity {
+        function construct(entity: IEntity, xml: library.XML, ...prohibited_names: string[]): void;
+        function toXML(entity: IEntity, ...prohibited_names: string[]): library.XML;
+    }
+    /**
+     * An entity, a standard data class.
+     *
+     * Entity is a class for standardization of expression method using on network I/O by XML. If
+     * Invoke is a standard message protocol of Samchon Framework which must be kept, Entity is a
+     * recommended semi-protocol of message for expressing a data class. Following the semi-protocol
+     * Entity is not imposed but encouraged.
+     *
+     * As we could get advantages from standardization of message for network I/O with Invoke,
+     * we can get additional advantage from standardizing expression method of data class with Entity.
+     * We do not need to know a part of network communication. Thus, with the Entity, we can only
+     * concentrate on entity's own logics and relationships between another entities. Entity does not
+     * need to how network communications are being done.
+     *
+     * I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
+     * protocol for network I/O but not a essential protocol must be kept. The expression method of
+     * Entity, using on network I/O, is expressed by XML string.
+     *
+     * If your own network system has a critical performance issue on communication data class,
+     * it would be better to using binary communication (with ByteArray).
+     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray).
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Entity implements IEntity {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    interface IEntityCollection<T extends IEntity> extends IEntityGroup<T>, collections.ICollection<T> {
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityArrayCollection<T extends IEntity> extends collections.ArrayCollection<T> implements IEntityCollection<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityListCollection<T extends IEntity> extends collections.ListCollection<T> implements IEntityCollection<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityDequeCollection<T extends IEntity> extends collections.DequeCollection<T> implements IEntityCollection<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+/**
+ * A template for External Systems Manager.
+ *
+ * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.external {
+    /**
+     * An array and manager of {@link ExternalSystem external system drivers}.
+     *
+     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
+     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
+     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
+     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
+     *
+     * You can specify this {@link ExternalSystemArray} class to be *a server accepting external clients* or
+     * *a client connecting to external servers*. Even both of them is also possible.
+     *
+     * - {@link ExternalClientArray}: A server accepting {@link ExternalSystem external clients}.
+     * - {@link ExternalServerArray}: A client connecting to {@link ExternalServer external servers}.
+     * - {@link ExternalServerClientArray}: Both of them. Accepts {@link ExternalSystem external clients} and connects to
+     *   {@link ExternalServer external servers} at the same time.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalSystemArray<System extends ExternalSystem> extends protocol.EntityDequeCollection<System> implements protocol.IProtocol {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @hidden
+         */
+        private _Handle_system_erase(event);
+        /**
+         * Test whether the role exists.
+         *
+         * @param name Name, identifier of target {@link ExternalSystemRole role}.
+         *
+         * @return Whether the role has or not.
+         */
+        hasRole(name: string): boolean;
+        /**
+         * Get a role.
+         *
+         * @param name Name, identifier of target {@link ExternalSystemRole role}.
+         *
+         * @return The specified role.
+         */
+        getRole(name: string): ExternalSystemRole;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * @param invoke An {@link Invoke} message to send.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle an {@Invoke} message have received.
+         *
+         * @param invoke An {@link Invoke} message have received.
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
+        /**
+         * Tag name of the {@link ExternalSytemArray} in {@link XML}.
+         *
+         * @return *systemArray*.
+         */
+        TAG(): string;
+        /**
+         * Tag name of {@link ExternalSystem children elements} belonged to the {@link ExternalSytemArray} in {@link XML}.
+         *
+         * @return *system*.
+         */
+        CHILD_TAG(): string;
+    }
+}
+/**
+ * A template for Parallel Processing System.
+ *
+ * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.parallel {
+    /**
+     * Master of Parallel Processing System.
+     *
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to **slave** systems and the
+     * children {@link ParallelSystem} objects represent the remote **slave** systems, who is being requested the
+     * *parallel processes*.
+     *
+     * You can specify this {@link ParallelSystemArray} class to be *a server accepting parallel clients* or
+     * *a client connecting to parallel servers*. Even both of them is possible. Extends one of them below and overrides
+     * abstract factory method(s) creating the child {@link ParallelSystem} object.
+     *
+     * - {@link ParallelClientArray}: A server accepting {@link ParallelSystem parallel clients}.
+     * - {@link ParallelServerArray}: A client connecting to {@link ParallelServer parallel servers}.
+     * - {@link ParallelServerClientArray}: Both of them. Accepts {@link ParallelSystem parallel clients} and connects to
+     *   {@link ParallelServer parallel servers} at the same time.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ParallelSystemArray<System extends ParallelSystem> extends external.ExternalSystemArray<System> {
+        /**
+         * @hidden
+         */
+        private history_sequence_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Send an {@link Invoke} message with segment size.
+         *
+         * Sends an {@link Invoke} message requesting a **parallel process** with its *segment size*. The {@link Invoke}
+         * message will be delivered to children {@link ParallelSystem} objects with the *piece size*, which is divided
+         * from the *segment size*, basis on their {@link ParallelSystem.getPerformance performance indices}.
+         *
+         * - If segment size is 100,
+         * - The segment will be allocated such below:
+         *
+         * Name    | Performance index | Number of pieces to be allocated | Formula
+         * --------|-------------------|----------------------------------|--------------
+         * Snail   |                 1 |                               10 | 100 / 10 * 1
+         * Cheetah |                 4 |                               40 | 100 / 10 * 4
+         * Rabbit  |                 3 |                               30 | 100 / 10 * 3
+         * Turtle  |                 2 |                               20 | 100 / 10 * 2
+         *
+         * When the **parallel process** has completed, then this {@link ParallelSystemArraY} will estimate
+         * {@link ParallelSystem.getPerformance performance indices} of {@link ParallelSystem} objects basis on their
+         * execution time.
+         *
+         * @param invoke An {@link Invoke} message requesting parallel process.
+         * @param size Number of pieces to segment.
+         *
+         * @return Number of {@link ParallelSystem slave systems} participating in the *Parallel Process*.
+         *
+         * @see {@link sendPieceData}, {@link ParallelSystem.getPerformacen}
+         */
+        sendSegmentData(invoke: protocol.Invoke, size: number): number;
+        /**
+         * Send an {@link Invoke} message with range of pieces.
+         *
+         * Sends an {@link Invoke} message requesting a **parallel process** with its *range of pieces [first, last)*.
+         * The {@link Invoke} will be delivered to children {@link ParallelSystem} objects with the newly computed
+         * *range of sub-pieces*, which is divided from the *range of pieces (first to last)*, basis on their
+         * {@link ParallelSystem.getPerformance performance indices}.
+         *
+         * - If indices of pieces are 0 to 50,
+         * - The sub-pieces will be allocated such below:
+         *
+         * Name    | Performance index | Range of sub-pieces to be allocated | Formula
+         * --------|-------------------|-------------------------------------|------------------------
+         * Snail   |                 1 |                            ( 0,  5] | (50 - 0) / 10 * 1
+         * Cheetah |                 4 |                            ( 5, 25] | (50 - 0) / 10 * 4 + 5
+         * Rabbit  |                 3 |                            (25, 40] | (50 - 0) / 10 * 3 + 25
+         * Turtle  |                 2 |                            (40, 50] | (50 - 0) / 10 * 2 + 40
+         *
+         * When the **parallel process** has completed, then this {@link ParallelSystemArraY} will estimate
+         * {@link ParallelSystem.getPerformance performance indices} of {@link ParallelSystem} objects basis on their
+         * execution time.
+         *
+         * @param invoke An {@link Invoke} message requesting parallel process.
+         * @param first Initial piece's index in a section.
+         * @param last Final piece's index in a section. The range used is [*first*, *last*), which contains
+         *			   all the pieces' indices between *first* and *last*, including the piece pointed by index
+         *			   *first*, but not the piece pointed by the index *last*.
+         *
+         * @return Number of {@link ParallelSystem slave systems} participating in the *Parallel Process*.
+         *
+         * @see {@link sendSegmentData}, {@link ParallelSystem.getPerformacen}
+         */
+        sendPieceData(invoke: protocol.Invoke, first: number, last: number): number;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: slave.InvokeHistory): boolean;
+        /**
+         * @hidden
+         */
+        protected _Normalize_performance(): void;
+    }
+}
+/**
+ * A template for Distributed Processing System.
+ *
+ * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.distributed {
+    /**
+     * Master of Distributed Processing System.
+     *
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * You can specify this {@link DistributedSystemArray} class to be *a server accepting distributed clients* or
+     * *a client connecting to distributed servers*. Even both of them is possible. Extends one of them below and overrides
+     * abstract factory method(s) creating the child {@link DistributedSystem} object.
+     *
+     * - {@link DistributedClientArray}: A server accepting {@link DistributedSystem distributed clients}.
+     * - {@link DistributedServerArray}: A client connecting to {@link DistributedServer distributed servers}.
+     * - {@link DistributedServerClientArray}: Both of them. Accepts {@link DistributedSystem distributed clients} and
+     *   connects to {@link DistributedServer distributed servers} at the same time.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasProcess}
+     * - {@link getProcess}
+     * - {@link insertProcess}
+     * - {@link eraseProcess}
+     * - {@link getProcessMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedSystemArray<System extends DistributedSystem> extends parallel.ParallelSystemArray<System> {
+        /**
+         * @hidden
+         */
+        private process_map_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Factory method creating a child {@link DistributedProcess process} object.
+         *
+         * @param xml {@link XML} represents the {@link DistributedProcess child} object.
+         * @return A new {@link DistributedProcess} object.
+         */
+        protected abstract createProcess(xml: library.XML): DistributedProcess;
+        /**
+         * Get process map.
+         *
+         * Gets an {@link HashMap} containing {@link DistributedProcess} objects with their *key*.
+         *
+         * @return An {@link HasmMap> containing pairs of string and {@link DistributedProcess} object.
+         */
+        getProcessMap(): std.HashMap<string, DistributedProcess>;
+        /**
+         * Test whether the process exists.
+         *
+         * @param name Name, identifier of target {@link DistributedProcess process}.
+         *
+         * @return Whether the process has or not.
+         */
+        hasProcess(name: string): boolean;
+        /**
+         * Get a process.
+         *
+         * @param name Name, identifier of target {@link DistributedProcess process}.
+         *
+         * @return The specified process.
+         */
+        getProcess(name: string): DistributedProcess;
+        /**
+         * Insert a process.
+         *
+         * @param process A process to be inserted.
+         * @return Success flag.
+         */
+        insertProcess(process: DistributedProcess): boolean;
+        /**
+         * Erase a process.
+         *
+         * @param name Name, identifier of target {@link DistributedProcess process}.
+         */
+        eraseProcess(name: string): boolean;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: slave.InvokeHistory): boolean;
+        /**
+         * @hidden
+         */
+        private estimate_process_resource(history);
+        /**
+         * @hidden
+         */
+        private estimate_system_performance(history);
+        /**
+         * @hidden
+         */
+        protected _Normalize_performance(): void;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System.
+     *
+     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
+     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
+     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
+     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlaveSystem} class.
+     *
+     * As a master, you can specify this {@link DistributedSystemArrayMediator} class to be <i>a master server accepting
+     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
+     * of them below and overrides abstract factory method(s) creating the child {@link DistributedSystem} object.
+     *
+     * - {@link DistributedClientArrayMediator}: A server accepting {@link DistributedSystem distributed clients}.
+     * - {@link DistributedServerArrayMediator}: A client connecting to {@link DistributedServer distributed servers}.
+     * - {@link DistributedServerClientArrayMediator}: Both of them. Accepts {@link DistributedSystem distributed clients} and
+     *   connects to {@link DistributedServer distributed servers} at the same time.
+     *
+     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
+     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorDedicatedWorkerServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * @copydoc DistributedSystemArray
+     */
+    abstract class DistributedSystemArrayMediator<System extends DistributedSystem> extends DistributedSystemArray<System> {
+        /**
+         * @hidden
+         */
+        private mediator_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating a {@link MediatorSystem} object.
+         *
+         * The {@link createMediator createMediator()} is an abstract method creating the {@link MediatorSystem} object.
+         *
+         * You know what? this {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a
+         * slave to its master system at the same time. The {@link MediatorSystem} object makes it possible; be a slave
+         * system. This {@link createMediator} determines specific type of the {@link MediatorSystem}.
+         *
+         * Overrides the {@link createMediator createMediator()} method to create and return one of them following which
+         * protocol and which type of remote connection (server or client) will be used:
+         *
+         * - A client slave connecting to master server:
+         *   - {@link MediatorClient}
+         *   - {@link MediatorWebClient}
+         *   - {@link MediatorSharedWorkerClient}
+         * - A server slave accepting master client:
+         *   - {@link MediatorServer}
+         *   - {@link MediatorWebServer}
+         *   - {@link MediatorDedicatedWorkerServer}
+         *   - {@link MediatorSharedWorkerServer}
+         *
+         * @return A newly created {@link MediatorSystem} object.
+         */
+        protected abstract createMediator(): parallel.MediatorSystem;
+        /**
+         * Start mediator.
+         *
+         * If the {@link getMediator mediator} is a type of server, then opens the server accepting master client.
+         * Otherwise, the {@link getMediator mediator} is a type of client, then connects the master server.
+         */
+        protected startMediator(): void;
+        /**
+         * Get {@link MediatorSystem} object.
+         *
+         * When you need to send an {@link Invoke} message to the master system of this
+         * {@link DistributedSystemArrayMediator}, then send to the {@link MediatorSystem} through this
+         * {@link getMediator}.
+         *
+         * ```typescript
+         * this.getMediator().sendData(...);
+         * ```
+         *
+         * @return The {@link MediatorSystem} object.
+         */
+        getMediator(): parallel.MediatorSystem;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: slave.InvokeHistory): boolean;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @hidden
+     */
+    namespace socket {
+        type socket = any;
+        type server = any;
+        type http_server = any;
+    }
+    /**
+     * @hidden
+     */
+    namespace websocket {
+        type connection = any;
+        type request = any;
+        type IMessage = any;
+        type ICookie = any;
+        type client = any;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @hidden
+     */
+    abstract class _CommunicatorBase implements ICommunicator {
+        /**
+         * @hidden
+         */
+        protected listener_: IProtocol;
+        /**
+         * @inheritdoc
+         */
+        onClose: Function;
+        /**
+         * @hidden
+         */
+        protected connected_: boolean;
+        /**
+         * @hidden
+         */
+        private binary_invoke_;
+        /**
+         * @hidden
+         */
+        private binary_parameters_;
+        /**
+         * @hidden
+         */
+        private unhandled_invokes_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener An {@link IProtocol} object to listen {@link Invoke} messages.
+         */
+        constructor(listener: IProtocol);
+        /**
+         * @inheritdoc
+         */
+        abstract close(): void;
+        /**
+         * @inheritdoc
+         */
+        isConnected(): boolean;
+        /**
+         * @hidden
+         */
+        protected _Is_binary_invoke(): boolean;
+        /**
+         * @inheritdoc
+         */
+        abstract sendData(invoke: Invoke): void;
+        /**
+         * @inheritdoc
+         */
+        replyData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_string(str: string): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_binary(binary: Uint8Array): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A communicator following Samchon Framework's own protocol.
+     *
+     * {@link Communicator} is an abstract class following Samchon Framework's own protocol. This {@link Communicator}
+     * class is specified to {@link ServerConnector} and {@link ClientDriver} whether the remote system is a server (that
+     * my system is connecting to) or a client (a client conneting to to my server).
+     *
+     * Note that, if one of this or remote system is web-browser based, then you don't have to use this
+     * {@link Communicator} class who follows Samchon Framework's own protocol. Web-browser supports only Web-socket
+     * protocol. Thus in that case, you have to use {@link WebCommunicator} instead.
+     *
+     * #### [Inherited] {@link ICommunicator}
+     * @copydoc ICommunicator
+     */
+    abstract class Communicator extends _CommunicatorBase {
+        /**
+         * @hidden
+         */
+        protected socket_: socket.socket;
+        /**
+         * @hidden
+         */
+        private header_bytes_;
+        /**
+         * @hidden
+         */
+        private data_;
+        /**
+         * @hidden
+         */
+        private data_index_;
+        /**
+         * @hidden
+         */
+        private listening_;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @hidden
+         */
+        protected _Start_listen(): void;
+        /**
+         * @hidden
+         */
+        private _Handle_error();
+        /**
+         * @hidden
+         */
+        private _Handle_close();
+        /**
+         * @inheritdoc
+         */
+        sendData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
+        private _Listen_piece(piece);
+        /**
+         * @hidden
+         */
+        private _Listen_header(piece, piece_index);
+        /**
+         * @hidden
+         */
+        private _Listen_data(piece, piece_index);
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * Communicator with remote client.
+     *
+     * {@link ClientDriver} is a class taking full charge of network communication with remote client who follows Samchon
+     * Framework's own protocol. This {@link ClientDriver} object is always created by {@link Server} class. When you got
+     * this {@link ClientDriver} object from the {@link Server.addClient Server.addClient()}, then specify
+     * {@link IProtocol listener} with the {@link ClientDriver.listen ClientDriver.listen()} method.
+     *
+     * #### [Inherited] {@link IClientDriver}
+     * @copydoc IClientDriver
+     */
+    class ClientDriver extends Communicator implements IClientDriver {
+        /**
+         * Construct from a socket.
+         */
+        constructor(socket: socket.socket);
+        /**
+         * @inheritdoc
+         */
+        listen(listener: IProtocol): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A communicator for shared worker.
+     *
+     * {@link DedicatedWorkerCommunicator} is an abstract class for communication between DedicatedWorker and Web-browser.
+     * This {@link DedicatedWorkerCommunicator} is specified to {@link DedicatedWorkerServerConnector} and
+     * {@link DedicatedWorkerClientDriver} whether the remote system is a server (that my system is connecting to) or a
+     * client (a client conneting to to my server).
+     *
+     * #### Why DedicatedWorker be a server?
+     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
+     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
+     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
+     * communication? Furthermore, there's not any difference between the worker communication and network communication.
+     * It's the reason why Samchon Framework considers the **Worker** as a network node.
+     *
+     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
+     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
+     * server and clients with this {@link DedicatedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link ICommunicator}
+     * @copydoc ICommunicator
+     */
+    abstract class DedicatedWorkerCommunicator extends _CommunicatorBase {
+        /**
+         * @hidden
+         */
+        protected _Handle_message(event: MessageEvent): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * Communicator with master web-browser.
+     *
+     * {@link DedicatedWorkerClientDriver} is a class taking full charge of network communication with web browsers. This
+     * {@link DedicatedWorkerClientDriver} object is always created by {@link DedicatedWorkerServer} class. When you got
+     * this {@link DedicatedWorkerClientDriver} object from
+     * {@link DedicatedWorkerServer.addClient DedicatedWorkerServer.addClient()}, then specify {@link IProtocol listener}
+     * with the {@link DedicatedWorkerClientDriver.listen DedicatedWorkerClientDriver.listen()} method.
+     *
+     * #### Why DedicatedWorker be a server?
+     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
+     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
+     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
+     * communication? Furthermore, there's not any difference between the worker communication and network communication.
+     * It's the reason why Samchon Framework considers the **Worker** as a network node.
+     *
+     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
+     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
+     * server and clients with this {@link DedicatedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IClientDriver}
+     * @copydoc IClientDriver
+     */
+    class DedicatedWorkerClientDriver extends DedicatedWorkerCommunicator implements IClientDriver {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        listen(listener: IProtocol): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @inheritdoc
+         */
+        sendData(invoke: Invoke): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A communicator for shared worker.
+     *
+     * {@link SharedWorkerCommunicator} is an abstract class for communication between SharedWorker and Web-browser. This
+     * {@link SharedWorkerCommunicator} is specified to {@link SharedWorkerServerConnector} and
+     * {@link SharedWorkerClientDriver} whether the remote system is a server (that my system is connecting to) or a client
+     * (a client conneting to to my server).
+     *
+     * Note that, SharedWorker is a conception only existed in web-browser. This {@link SharedWorkerCommunicator} is not
+     * supported in NodeJS. Only web-browser environment can utilize this {@link SharedWorkerCommunicator}.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link ICommunicator}
+     * @copydoc ICommunicator
+     */
+    abstract class SharedWorkerCommunicator extends _CommunicatorBase {
+        /**
+         * @hidden
+         */
+        protected port_: MessagePort;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @inheritdoc
+         */
+        sendData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_message(event: MessageEvent): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * Communicator with remote web-browser.
+     *
+     * {@link SharedWorkerClientDriver} is a class taking full charge of network communication with web browsers. This
+     * {@link SharedWorkerClientDriver} object is always created by {@link SharedWorkerServer} class. When you got this
+     * {@link SharedWorkerClientDriver} object from {@link SharedWorkerServer.addClient SharedWorkerServer.addClient()},
+     * then specify {@link IProtocol listener} with the
+     * {@link SharedWorkerClientDriver.listen SharedWorkerClientDriver.listen()} method.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IClientDriver}
+     * @copydoc IClientDriver
+     */
+    class SharedWorkerClientDriver extends SharedWorkerCommunicator implements IClientDriver {
+        /**
+         * @hidden
+         */
+        private listening_;
+        /**
+         * Construct from a MessagePort object.
+         */
+        constructor(port: MessagePort);
+        /**
+         * @inheritdoc
+         */
+        listen(listener: IProtocol): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A communicator following Web-socket protocol.
+     *
+     * {@link WebCommunicator} is an abstract class following Web-socket protocol. This {@link WebCommunicator} class is
+     * specified to {@link WebServerConnector} and {@link WebClientDriver} whether the remote system is a server (that my
+     * system is connecting to) or a client (a client conneting to to my server).
+     *
+     * Note that, one of this or remote system is web-browser based, then there's not any alternative choice. Web browser
+     * supports only Web-socket protocol. In that case, you've use this {@link WebCommunicator} class.
+     *
+     * #### [Inherited] {@link ICommunicator}
+     * @copydoc ICommunicator
+     */
+    abstract class WebCommunicator extends _CommunicatorBase {
+        /**
+         * @hidden
+         */
+        protected connection_: websocket.connection;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @inheritdoc
+         */
+        sendData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_message(message: websocket.IMessage): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_close(): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * Communicator with remote web-client.
+     *
+     * {@link WebClientDriver} is a class taking full charge of network communication with remote client who follows
+     * Web-socket protocol. This {@link WebClientDriver} object is always created by {@link WebServer} class. When you
+     * got this {@link WebClientDriver} object from the {@link WebServer.addClient WebServer.addClient()}, then specify
+     * {@link IProtocol listener} with the {@link WebClientDriver.listen WebClientDriver.listen()} method.
+     *
+     * Unlike other protocol, Web-socket protocol's clients notify two parameters on their connection;
+     * {@link getSessionID session-id} and {@link getPath path}. The {@link getSessionID session-id} can be used to
+     * identify *user* of each client, and the {@link getPath path} can be used which type of *service* that client wants.
+     * In {@link service} module, you can see the best utilization case of them.
+     * - {@link service.User}: utlization of the {@link getSessionID session-id}.
+     * - {@link service.Service}: utilization of the {@link getPath path}.
+     *
+     * #### [Inherited] {@link IClientDriver}
+     * @copydoc IClientDriver
+     */
+    class WebClientDriver extends WebCommunicator implements IClientDriver {
+        /**
+         * @hidden
+         */
+        private path_;
+        /**
+         * @hidden
+         */
+        private session_id_;
+        /**
+         * @hidden
+         */
+        private listening_;
+        /**
+         * Initialization Constructor.
+         *
+         * @param connection Connection driver, a socket for web-socket.
+         * @param path Requested path.
+         * @param session_id Session ID, an identifier of the remote client.
+         */
+        constructor(connection: websocket.connection, path: string, session_id: string);
+        /**
+         * @inheritdoc
+         */
+        listen(listener: IProtocol): void;
+        /**
+         * Get requested path.
+         */
+        getPath(): string;
+        /**
+         * Get session ID, an identifier of the remote client.
+         */
+        getSessionID(): string;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface for communicator with remote client.
+     *
+     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
+     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
+     *
+     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
+     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
+     * created by the matched {@link IServer} object.
+     *
+     * Protocol                | Derived Type                        | Created By
+     * ------------------------|-------------------------------------|----------------------------
+     * Samchon Framework's own | {@link ClientDriver}                | {@link Server}
+     * Web-socket protocol     | {@link WebClientDriver}             | {@link WebServer}
+     * DedicatedWorker         | {@link DedicatedWorkerClinetDriver} | {@link DedicatedWorkerServer}
+     * SharedWorker            | {@link SharedWorkerClientDriver}    | {@link SharedWorkerServer}
+     *
+     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
+     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
+     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
+     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
+     *
+     * - https://github.com/samchon/framework-examples/blob/master/calculator/calculator-server.ts
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link IServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IClientDriver extends ICommunicator {
+        /**
+         * Listen message from the newly connected client.
+         *
+         * Starts listening message from the newly connected client. Replied message from the connected client will be
+         * converted to {@link Invoke} classes and shifted to the *listener*'s {@link IProtocol.replyData replyData()}
+         * method.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
+        listen(listener: IProtocol): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface taking full charge of network communication.
+     *
+     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
+     * remote system, without reference to whether the remote system is a server or a client. Type of the
+     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
+     * is a server (that I've to connect) or a client (a client connected to my server).
+     *
+     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
+     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
+     * {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link IClientDriver}, {@link IServerConnector}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface ICommunicator extends IProtocol {
+        /**
+         * Callback function for connection closed.
+         */
+        onClose: Function;
+        /**
+         * Close connection.
+         */
+        close(): void;
+        /**
+         * Test connection.
+         *
+         * Test whether this {@link ICommunicator communicator} object is connected with the remote system. If the
+         * connection is alive, then returns ```true```. Otherwise, the connection is not alive or this
+         * {@link ICommunicator communicator has not connected with the remote system yet, then returns ```false```.
+         *
+         * @return true if connected, otherwise false.
+         */
+        isConnected(): boolean;
+        /**
+         * Send message.
+         *
+         * Send {@link Invoke} message to remote system.
+         *
+         * @param invoke An {@link Invoke} message to send.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle replied message.
+         *
+         * Handles replied {@link Invoke} message recived from remove system. The {@link Invoke} message will be shifted
+         * to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} by this method.
+         *
+         * @param invoke An {@link Invoke} message received from remote system.
+         */
+        replyData(invoke: protocol.Invoke): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface for server connector.
+     *
+     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
+     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
+     * charge of network communication with the remote server.
+     *
+     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
+     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
+     * be converted to an {@link Invoke} object and the {@link Invoke} object will be shifted to the
+     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method. Below code is an example
+     * connecting to remote server and interacting with it.
+     *
+     * - https://github.com/samchon/framework-examples/blob/master/calculator/calculator-application.ts
+     *
+     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
+     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
+     *
+     * Protocol                | Derived Type                           | Connect to
+     * ------------------------|----------------------------------------|-------------------------------
+     * Samchon Framework's own | {@link ServerConnector}                | {@link Server}
+     * Web-socket protocol     | {@link WebServerConnector}             | {@link WebServer}
+     * DedicatedWorker         | {@link DedicatedWorkerServerConnector} | {@link DedicatedWorkerServer}
+     * SharedWorker            | {@link SharedWorkerServerConnector}    | {@link SharedWorkerServer}
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
+     *
+     * @see {@link IServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IServerConnector extends ICommunicator {
+        /**
+         * Callback function for connection completed.
+         *
+         * When you call {@link connect connect()} and the connection has completed, then this call back function
+         * {@link onConnect} will be called. Note that, if the listener of this {@link onConnect} is a member method of
+         * some class, then you've use the ```bind```.
+         */
+        onConnect: Function;
+        /**
+         * Connect to a server.
+         *
+         * Connects to a server with specified *host* address and *port* number. After the connection has
+         * succeeded, callback function {@link onConnect} is called. Listening data from the connected server also begins.
+         * Replied messages from the connected server will be converted to {@link Invoke} classes and will be shifted to
+         * the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method.
+         *
+         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
+         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
+         * the status of the connection is reported by an event. If the socket is already connected, the existing
+         * connection is closed first.
+         *
+         * @param ip The name or IP address of the host to connect to.
+         *			 If no host is specified, the host that is contacted is the host where the calling file resides.
+         *			 If you do not specify a host, use an event listener to determine whether the connection was
+         *			 successful.
+         * @param port The port number to connect to.
+         */
+        connect(ip: string, port: number): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A server connector for DedicatedWorker.
+     *
+     * {@link DedicatedWorkerServerConnector} is a class connecting to SharedWorker and taking full charge of network
+     * communication with the SharedWorker. Create an {@link DedicatedWorkerServer} instance from the
+     * {@IProtocol listener} and call the {@link connect connect()} method.
+     *
+     * #### Why DedicatedWorker be a server?
+     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
+     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
+     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
+     * communication? Furthermore, there's not any difference between the worker communication and network communication.
+     * It's the reason why Samchon Framework considers the **Worker** as a network node.
+     *
+     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
+     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
+     * server and clients with this {@link DedicatedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IServerConnector}
+     * @copydoc IServerConnector
+     */
+    class DedicatedWorkerServerConnector extends DedicatedWorkerCommunicator implements IServerConnector {
+        /**
+         * @hidden
+         */
+        private worker_;
+        /**
+         * @inheritdoc
+         */
+        onConnect: Function;
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
+        constructor(listener: IProtocol);
+        /**
+         * @inheritdoc
+         */
+        connect(jsFile: string): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @inheritdoc
+         */
+        sendData(invoke: Invoke): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * Server connnector.
+     *
+     * {@link ServerConnector} is a class connecting to remote server who follows Samchon Framework's own protocol and
+     * taking full charge of network communication with the remote server. Create a {@link ServerConnector} instance from
+     * the {@IProtocol listener} and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link IServerConnector}
+     * @copydoc IServerConnector
+     */
+    class ServerConnector extends Communicator implements IServerConnector {
+        /**
+         * @inheritdoc
+         */
+        onConnect: Function;
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
+        constructor(listener: IProtocol);
+        /**
+         * @inheritdoc
+         */
+        connect(ip: string, port: number): void;
+        /**
+         * @hidden
+         */
+        private _Handle_connect(...arg);
+        /**
+         * @hidden
+         */
+        private _Send_dummy_packet_repeatedly();
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A server connector for SharedWorker.
+     *
+     * {@link SharedWorkerServerConnector} is a class connecting to SharedWorker and taking full charge of network
+     * communication with the SharedWorker. Create an {@link SharedWorkerServerConnector} instance from the
+     * {@IProtocol listener} and call the {@link connect connect()} method.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IServerConnector}
+     * @copydoc IServerConnector
+     */
+    class SharedWorkerServerConnector extends SharedWorkerCommunicator implements IServerConnector {
+        /**
+         * @inheritdoc
+         */
+        onConnect: Function;
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
+        constructor(listener: IProtocol);
+        /**
+         * Connect to a SharedWorker.
+         *
+         * Connects to a server with specified *jstFile* path. If a SharedWorker instance of the *jsFile* is not
+         * constructed yet, then the SharedWorker will be newly constructed. Otherwise the SharedWorker already exists,
+         * then connect to the SharedWorker. After those processes, callback function {@link onConnect} is called.
+         * Listening data from the connected server also begins. Replied messages from the connected server will be
+         * converted to {@link Invoke} classes and will be shifted to the {@link WebCommunicator.listener listener}'s
+         * {@link IProtocol.replyData replyData()} method.
+         *
+         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
+         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
+         * the status of the connection is reported by an event. If the socket is already connected, the existing
+         * connection is closed first.
+         *
+         * @param jsFile Path of JavaScript file to execute who defines SharedWorker.
+         */
+        connect(jsFile: string): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A server connector for web-socket protocol.
+     *
+     * {@link WebServerConnector} is a class connecting to remote server who follows Web-socket protocol and taking full
+     * charge of network communication with the remote server. Create an {@link WebServerConnector} instance from the
+     * {@IProtocol listener} and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link IServerConnector}
+     * @copydoc IServerConnector
+     */
+    class WebServerConnector extends WebCommunicator implements IServerConnector {
+        /**
+         * @hidden
+         */
+        private browser_socket_;
+        /**
+         * @hidden
+         */
+        private node_client_;
+        /**
+         * @inheritdoc
+         */
+        onConnect: Function;
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
+        constructor(listener: IProtocol);
+        /**
+         * Connect to a web server.
+         *
+         * Connects to a server with specified *host* address, *port* number and *path*. After the connection has
+         * succeeded, callback function {@link onConnect} is called. Listening data from the connected server also begins.
+         * Replied messages from the connected server will be converted to {@link Invoke} classes and will be shifted to
+         * the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method.
+         *
+         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
+         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
+         * the status of the connection is reported by an event. If the socket is already connected, the existing
+         * connection is closed first.
+         *
+         * @param ip The name or IP address of the host to connect to.
+         *			 If no host is specified, the host that is contacted is the host where the calling file resides.
+         *			 If you do not specify a host, use an event listener to determine whether the connection was
+         *			 successful.
+         * @param port The port number to connect to.
+         * @param path Path of service which you want.
+         */
+        connect(ip: string, port: number, path?: string): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @inheritdoc
+         */
+        sendData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
+        private _Handle_browser_connect(event);
+        /**
+         * @hidden
+         */
+        private _Handle_browser_message(event);
+        /**
+         * @hidden
+         */
+        private _Handle_node_connect(connection);
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A container of entity, and it's a type of entity, too.
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
+     * @handbook  [Protocol - Standard Message](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Standard_Message)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IEntityGroup<T extends IEntity> extends IEntity, std.base.Container<T> {
+        /**
+         * Construct data of the Entity from an XML object.
+         *
+         * Constructs the EntityArray's own member variables only from the input XML object.
+         *
+         * Do not consider about constructing children Entity objects' data in EntityArray::construct().
+         * Those children Entity objects' data will constructed by their own construct() method. Even insertion
+         * of XML objects representing children are done by abstract method of EntityArray::toXML().
+         *
+         * Constructs only data of EntityArray's own.
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Factory method of a child Entity.
+         *
+         * EntityArray::createChild() is a factory method creating a new child Entity which is belonged
+         * to the EntityArray. This method is called by EntityArray::construct(). The children construction
+         * methods Entity::construct() will be called by abstract method of the EntityArray::construct().
+         *
+         * @return A new child Entity belongs to EntityArray.
+         */
+        createChild(xml: library.XML): T;
+        /**
+         * Get iterator to element.
+         *
+         * Searches the container for an element with a identifier equivalent to *key* and returns an
+         * iterator to it if found, otherwise it returns an iterator to {@link end end()}.
+         *
+         * Two keys are considered equivalent if the container's comparison object returns false reflexively
+         * (i.e., no matter the order in which the elements are passed as arguments).
+         *
+         * Another member functions, {@link has has()} and {@link count count()}, can be used to just check
+         * whether a particular *key* exists.
+         *
+         * @param key Key to be searched for
+         * @return An iterator to the element, if an element with specified *key* is found, or
+         *		   {@link end end()} otherwise.
+         */
+        /**
+         * Whether have the item or not.
+         *
+         * Indicates whether a map has an item having the specified identifier.
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @return Whether the map has an item having the specified identifier.
+         */
+        has(key: any): boolean;
+        /**
+         * Count elements with a specific key.
+         *
+         * Searches the container for elements whose key is *key* and returns the number of elements found.
+         *
+         * @param key Key value to be searched for.
+         *
+         * @return The number of elements in the container with a *key*.
+         */
+        count(key: any): number;
+        /**
+         * Get an element
+         *
+         * Returns a reference to the mapped value of the element identified with *key*.
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @throw exception out of range
+         *
+         * @return A reference object of the mapped value (_Ty)
+         */
+        get(key: any): T;
+        /**
+         * A tag name of children objects.
+         */
+        CHILD_TAG(): string;
+        /**
+         * Get an XML object represents the EntityArray.
+         *
+         * Archives the EntityArray's own member variables only to the returned XML object.
+         *
+         * Do not consider about archiving children Entity objects' data in EntityArray::toXML().
+         * Those children Entity objects will converted to XML object by their own toXML() method. The
+         * insertion of XML objects representing children are done by abstract method of
+         * EntityArray::toXML().
+         *
+         * Archives only data of EntityArray's own.
+         */
+        toXML(): library.XML;
+    }
+    /**
+     * @hidden
+     */
+    namespace IEntityGroup {
+        /**
+         * @hidden
+         */
+        function construct<T extends IEntity>(entityGroup: IEntityGroup<T>, xml: library.XML, ...prohibited_names: string[]): void;
+        /**
+         * @hidden
+         */
+        function toXML<T extends IEntity>(group: IEntityGroup<T>, ...prohibited_names: string[]): library.XML;
+        function has<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): boolean;
+        function count<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): number;
+        function get<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): T;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityArray<T extends IEntity> extends std.Vector<T> implements IEntityGroup<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityList<T extends IEntity> extends std.List<T> implements IEntityGroup<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityDeque<T extends IEntity> extends std.Deque<T> implements IEntityGroup<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * Standard message of network I/O.
+     *
+     * {@link Invoke} is a class used in network I/O in protocol package of Samchon Framework.
+     *
+     * The Invoke message has an XML structure like the result screen of provided example in below.
+     * We can enjoy lots of benefits by the normalized and standardized message structure used in
+     * network I/O.
+     *
+     * The greatest advantage is that we can make any type of network system, even how the system
+     * is enourmously complicated. As network communication message is standardized, we only need to
+     * concentrate on logical relationships between network systems. We can handle each network system
+     * like a object (class) in OOD. And those relationships can be easily designed by using design
+     * pattern.
+     *
+     * In Samchon Framework, you can make any type of network system with basic componenets
+     * (IProtocol, IServer and ICommunicator) by implemens or inherits them, like designing
+     * classes of S/W architecture.
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
+     * @see {@link IProtocol}
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Invoke extends EntityArray<InvokeParameter> {
+        /**
+         * Listener, represent function's name.
+         */
+        private listener;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        constructor(listener: string);
+        /**
+         * Copy Constructor.
+         *
+         * @param invoke
+         */
+        constructor(invoke: Invoke);
+        /**
+         * Construct from listener and parametric values.
+         *
+         * @param listener
+         * @param parameters
+         */
+        constructor(listener: string, ...parameters: Array<boolean | number | string | library.XML | Uint8Array>);
+        /**
+         * @inheritdoc
+         */
+        createChild(xml: library.XML): InvokeParameter;
+        /**
+         * Get listener.
+         */
+        getListener(): string;
+        /**
+         * Get arguments for Function.apply().
+         *
+         * @return An array containing values of the contained parameters.
+         */
+        getArguments(): Array<any>;
+        /**
+         * Apply to a matched function.
+         *
+         * @param obj Target object to find matched function.
+         * @return Whether succeded to find matched function.
+         */
+        apply(obj: Object): boolean;
+        /**
+         * Apply to a function.
+         *
+         * @param thisArg Owner of the function.
+         * @param func Function to call.
+         */
+        apply(thisArg: Object, func: Function): void;
+        /**
+         * @inheritdoc
+         */
+        TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        CHILD_TAG(): string;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A parameter belongs to an Invoke.
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class InvokeParameter extends Entity {
+        /**
+         * Name of the parameter.
+         *
+         * @details Optional property, can be omitted.
+         */
+        protected name: string;
+        /**
+         * Type of the parameter.
+         */
+        protected type: string;
+        /**
+         * Value of the parameter.
+         */
+        protected value: boolean | number | string | library.XML | Uint8Array;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        constructor(val: boolean);
+        constructor(val: number);
+        constructor(val: string);
+        constructor(val: library.XML);
+        constructor(val: Uint8Array);
+        /**
+         * Construct from variable name and number value.
+         *
+         * @param name
+         * @param val
+         */
+        constructor(name: string, val: boolean);
+        constructor(name: string, val: number);
+        constructor(name: string, val: string);
+        constructor(name: string, val: library.XML);
+        constructor(name: string, val: Uint8Array);
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        setValue(value: boolean): void;
+        setValue(value: number): void;
+        setValue(value: string): void;
+        setValue(value: library.XML): void;
+        setValue(value: Uint8Array): void;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * Get name.
+         */
+        getName(): string;
+        /**
+         * Get type.
+         */
+        getType(): string;
+        /**
+         * Get value.
+         */
+        getValue(): any;
+        /**
+         * @inheritdoc
+         */
+        TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface for {@link Invoke} message chain.
+     *
+     * {@link IProtocol} is an interface for {@link Invoke} message, which is standard message of network I/O in
+     * *Samchon Framework*, chain. The {@link IProtocol} interface is used to network drivers and some classes which are
+     * in a relationship of *Chain of Responsibility Pattern* with those network drivers.
+     *
+     * Implements {@link IProtocol} if the class sends and handles {@link Invoke} messages. Looking around source codes of
+     * the *Samchon Framework*, especially *Templates*, you can find out that all the classes and modules handling
+     * {@link Invoke} messages are always implementing this {@link IProtocol}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link Invoke}
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iprotocol
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IProtocol {
+        /**
+         * Sending message.
+         *
+         * Sends message to related system or shifts the responsibility to chain.
+         *
+         * @param invoke Invoke message to send
+         */
+        replyData(invoke: Invoke): void;
+        /**
+         * Handling replied message.
+         *
+         * Handles replied message or shifts the responsibility to chain.
+         *
+         * @param invoke An {@link Invoke} message has received.
+         */
+        sendData(invoke: Invoke): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A DeidcatedWorker server.
+     *
+     * The {@link DedicatedWorkerServer} is an abstract class is realized to open a DedicatedWorker server and accept
+     * web-browser client (master). Extends this {@link DedicatedWorkerServer} class and overrides
+     * {@link addClient addClient()} method to define what to do with a newly connected
+     * {@link DedicatedWorkerClientDriver remote client}.
+     *
+     * #### Why DedicatedWorker be a server?
+     * In JavaScript environment, there's no way to implement multi-threading function. Instead, JavaScript supports the
+     * **Worker**, creating a new process. However, the **Worker** does not shares memory addresses. To integrate the
+     * **Worker** with its master, only communication with string or binary data is allowed. Doesn't it seem like a network
+     * communication? Furthermore, there's not any difference between the worker communication and network communication.
+     * It's the reason why Samchon Framework considers the **Worker** as a network node.
+     *
+     * The class {@link DedicatedWorkerCommunicator} is designed make such relationship. From now on, DedicatedWorker is a
+     * {@link DedicatedWorkerServer server} and {@link DedicatedWorkerServerConnector browser} is a client. Integrate the
+     * server and clients with this {@link DedicatedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IServer}
+     * @copydoc IServer
+     */
+    abstract class DedicatedWorkerServer implements IServer {
+        /**
+         * @inheritdoc
+         */
+        abstract addClient(driver: DedicatedWorkerClientDriver): void;
+        /**
+         * @inheritdoc
+         */
+        open(): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A substitute {@link DedicatedWorkerServer}.
+     *
+     * The {@link DedicatedWorkerServerBase} is a substitute class who subrogates {@link DedicatedWorkerServer}'s
+     * responsibility.
+     *
+     * #### [Inherited] {@link IServerBase}
+     * @copydoc IServerBase
+     */
+    class DedicatedWorkerServerBase extends DedicatedWorkerServer implements IServerBase {
+        /**
+         * @hidden
+         */
+        private hooker_;
+        /**
+         * Construct from a *hooker*.
+         *
+         * @param hooker A hooker throwing responsibility of server's role.
+         */
+        constructor(hooker: IServer);
+        /**
+         * @inheritdoc
+         */
+        addClient(driver: IClientDriver): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface for substitute server classes.
+     *
+     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
+     *
+     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
+     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
+     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
+     * the aggregated {@link IServerBase}.
+     *
+     * Protocol                | {@link IServer}               | {@link IServerBase}               | {@link IClientDriver}
+     * ------------------------|-------------------------------|-----------------------------------|-------------------------------------
+     * Samchon Framework's own | {@link Server}                | {@link ServerBase}                | {@link ClientDriver}
+     * Web-socket protocol     | {@link WebServer}             | {@link WebServerBase}             | {@link WebClientDriver}
+     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerServerBase} | {@link DedicatedWorkerClientDriver}
+     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerServerBase}    | {@link SharedWorkerClientDriver}
+     *
+     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
+     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
+     * specified port number.
+     *
+     * ```typescript
+     * class MyServer extends Something implements IServer
+     * {
+     * 	private server_base_: IServerBase = new WebServerBase(this);
+     *
+     * 	public addClient(driver: IClientDriver): void
+     * 	{
+     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
+     * 	}
+     *
+     * 	public open(port: number): void
+     * 	{
+     * 		this.server_base_.open();
+     * 	}
+     * 	public close(): void
+     * 	{
+     * 		this.server_base_.close();
+     * 	}
+     * }
+     * ```
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link IServer}, {@link IClientDriver}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IServerBase extends IServer {
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A server.
+     *
+     * The {@link Server} is an abstract class designed to open a server and accept clients who are following Samchon
+     * Framework's own protocol. Extends this {@link Server} class and overrides {@link addClient addClient()} method to
+     * define what to do with newly connected {@link ClientDriver remote clients}.
+     *
+     * #### [Inherited] {@link IServer}
+     * @copydoc Server
+     */
+    abstract class Server implements IServer {
+        /**
+         * @hidden
+         */
+        private net_driver_;
+        /**
+         * @inheritdoc
+         */
+        abstract addClient(driver: ClientDriver): void;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @hidden
+         */
+        private _Handle_connect(socket);
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A substitute {@link Server}.
+     *
+     * The {@link ServerBase} is a substitute class who subrogates {@link Server}'s responsibility.
+     *
+     * #### [Inherited] {@link IServerBase}
+     * @copydoc IServerBase
+     */
+    class ServerBase extends Server implements IServerBase {
+        /**
+         * @hidden
+         */
+        private hooker_;
+        /**
+         * Construct from a *hooker*.
+         *
+         * @param hooker A hooker throwing responsibility of server's role.
+         */
+        constructor(hooker: IServer);
+        /**
+         * @inheritdoc
+         */
+        addClient(driver: IClientDriver): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A SharedWorker server.
+     *
+     * The {@link SharedWorker} is an abstract class is realized to open a SharedWorker server and accept web-browser
+     * clients. Extends this {@link SharedWorkerServer} class and overrides {@link addClient addClient()} method to
+     * define what to do with newly connected {@link SharedWorkerClientDriver remote clients}.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IServer}
+     * @copydoc IServer
+     */
+    abstract class SharedWorkerServer implements IServer {
+        /**
+         * @inheritdoc
+         */
+        abstract addClient(driver: SharedWorkerClientDriver): void;
+        /**
+         * @inheritdoc
+         */
+        open(): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @hidden
+         */
+        private _Handle_connect(event);
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A substitute {@link SharedWorkerServer}.
+     *
+     * The {@link SharedWorkerServerBase} is a substitute class who subrogates {@link SharedWorkerServer}'s
+     * responsibility.
+     *
+     * #### [Inherited] {@link IServerBase}
+     * @copydoc IServerBase
+     */
+    class SharedWorkerServerBase extends SharedWorkerServer implements IServerBase {
+        /**
+         * @hidden
+         */
+        private hooker_;
+        /**
+         * Construct from a *hooker*.
+         *
+         * @param hooker A hooker throwing responsibility of server's role.
+         */
+        constructor(hooker: IServer);
+        /**
+         * @inheritdoc
+         */
+        addClient(driver: IClientDriver): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A web server.
+     *
+     * The {@link WebServer} is an abstract class designed to open a server and accept clients who are following
+     * web-socket protocol. Extends this {@link WebServer} class and overrides {@link addClient addClient()} method to
+     * define what to do with newly connected {@link WebClientDriver remote clients}.
+     *
+     * #### [Inherited] {@link IServer}
+     * @copydoc IServer
+     */
+    abstract class WebServer implements IServer {
+        /**
+         * @hidden
+         */
+        private http_server_;
+        /**
+         * @hidden
+         */
+        private sequence_;
+        /**
+         * @hidden
+         */
+        private my_port_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        abstract addClient(driver: WebClientDriver): void;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @hidden
+         */
+        private _Handle_request(request);
+        /**
+         * @hidden
+         */
+        private _Fetch_session_id(cookies);
+        /**
+         * @hidden
+         */
+        private _Issue_session_id();
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A substitute {@link WebServer}.
+     *
+     * The {@link WebServerBase} is a substitute class who subrogates {@link WebServer}'s responsibility.
+     *
+     * #### [Inherited] {@link IServerBase}
+     * @copydoc IServerBase
+     */
+    class WebServerBase extends WebServer implements IServerBase {
+        /**
+         * @hidden
+         */
+        private hooker_;
+        /**
+         * Construct from a *hooker*.
+         *
+         * @param hooker A hooker throwing responsibility of server's role.
+         */
+        constructor(hooker: IServer);
+        /**
+         * @inheritdoc
+         */
+        addClient(driver: IClientDriver): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface for a server.
+     *
+     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
+     * {@link IClientDriver accepting clients}.
+     *
+     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
+     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
+     * object. Then at last, call {@link open open()} method with specified port number.
+     *
+     * Protocol                | Derived Type                  | Related {@link IClientDriver}
+     * ------------------------|-------------------------------|-------------------------------------
+     * Samchon Framework's own | {@link Server}                | {@link ClientDriver}
+     * Web-socket protocol     | {@link WebServer}             | {@link WebClientDriver}
+     * DedicatedWorker         | {@link DedicatedWorkerServer} | {@link DedicatedWorkerClientDriver}
+     * SharedWorker            | {@link SharedWorkerServer}    | {@link SharedWorkerClientDriver}
+     *
+     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
+     * - https://github.com/samchon/framework-examples/blob/master/calculator/calculator-server.ts
+     * - https://github.com/samchon/framework-examples/blob/master/chat-server/server.ts
+     * - {@link service.Server}
+     * - {@link external.ExternalClientArray}
+     * - {@link slave.SlaveServer}
+     *
+     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link IClientDriver}, {@link IServerBase}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IServer {
+        /**
+         * Open server.
+         *
+         * @param port Port number to open.
+         */
+        open(port: number): void;
+        /**
+         * Close server.
+         *
+         * Close opened server. All remote clients, have connected with this server, are also closed and their call back
+         * functions, for closed connection, {@link IClientDriver.onClose} are also called.
+         */
+        close(): void;
+        /**
+         * Add a newly connected remote client.
+         *
+         * The {@link addClient addClient()} is an abstract method being called when a remote client is newly connected
+         * with {@link IClientDriver} object who communicates with the remote system. Overrides this method and defines
+         * what to do with the *driver*, a newly connected remote client.
+         *
+         * Below methods and example codes may be good for comprehending how to utilize this {@link addClient} method.
+         *
+         * - https://github.com/samchon/framework-examples/blob/master/calculator/calculator-server.ts
+         * - https://github.com/samchon/framework-examples/blob/master/chat-server/server.ts
+         * - {@link service.Server.addClient}
+         * - {@link external.ExternalClientArray.addClient}
+         * - {@link slave.SlaveServer.addClient}
+         *
+         * @param driver A {@link ICommunicator communicator} with (newly connected) remote client.
+         */
+        addClient(driver: IClientDriver): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Master of Distributed Processing System, a server accepting slave clients.
+     *
+     * The {@link DistributedClientArray} is an abstract class, derived from the {@link DistributedSystemArray} class,
+     * opening a server accepting {@link DistributedSystem distributed clients}.
+     *
+     * Extends this {@link DistributedClientArray}, overrides {@link createServerBase createServerBase()} to determine
+     * which protocol to follow and {@link createExternalClient createExternalClient()} creating child
+     * {@link DistributedSystem} object. After the extending and overridings, open this server using the
+     * {@link open open()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * @copydoc DistributedSystemArray
+     */
+    abstract class DistributedClientArray<System extends DistributedSystem> extends DistributedSystemArray<System> implements external.IExternalClientArray<System> {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
+         * may connect to {@link ExternalClientArray this server} must follow the specified protocol.
+         *
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
+         * then this {@link ParallelClientArray} creates a child {@link ParallelSystem parallel client} object through
+         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ParallelClientArray} is a server accepting {@link ParallelSystem parallel clients}.
+         * There's no way to creating the {@link ParallelSystem parallel clients} in advance before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
+         * @return ```null```
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating {@link DistributedSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link DistributedSystem} object with
+         * the *driver* that communicates with the parallel client. After the creation, returns the object. Then whenever
+         * a parallel client has connected, matched {@link DistributedSystem} object will be constructed and
+         * {@link insert inserted} into this {@link DistributedSystemArray} object.
+         *
+         * @param driver A communicator with the parallel client.
+         * @return A newly created {@link ParallelSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System, a server accepting slave clients.
+     *
+     * The {@link DistributedClientArrayMediator} is an abstract class, derived from {@link DistributedSystemArrayMediator}
+     * class, opening a server accepting {@link DistributedSystem distributed clients} as a **master**.
+     *
+     * Extends this {@link DistributedClientArrayMediator}, overrides {@link createServerBase createServerBase()} to
+     * determine which protocol to follow and {@link createExternalClient createExternalClient()} creating child
+     * {@link DistributedSystem} object. After the extending and overridings, open this server using the
+     * {@link open open()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArrayMediator}
+     * @copydoc DistributedSystemArrayMediator
+     */
+    abstract class DistributedClientArrayMediator<System extends DistributedSystem> extends DistributedSystemArrayMediator<System> implements external.IExternalClientArray<System> {
+        /**
+         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this
+         * {@link DistributedClientArrayMediator} object as a **master**. If the protocol is determined, then
+         * {@link DistributedSystem distributed clients} who may connect to {@link DistributedClientArrayMediator this
+         * server} must follow the specified protocol.
+         *
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *master server of distributed processing system*,
+         * then this {@link DistributedClientArrayMediator} creates a child {@link Distributed distributed client} object
+         * through the {@link createExternalClient createExternalClient()} method.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link DistributedClientArrayMediator} is a server accepting {@link DistributedSystem distributed
+         * clients} as a master. There's no way to creating the {@link DistributedSystem distributed clients} in advance
+         * before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link DistributedSystem} object.
+         * @return null
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating {@link DistributedSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link DistributedSystem} object, that is called whenever a distributed client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link DistributedSystem} object with
+         * the *driver* that communicates with the distributed client. After the creation, returns the object. Then whenever
+         * a distributed client has connected, matched {@link DistributedSystem} object will be constructed and
+         * {@link insert inserted} into this {@link DistributedClientArrayMediator} object.
+         *
+         * @param driver A communicator with the distributed client.
+         * @return A newly created {@link DistributedSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An external system driver.
+     *
+     * The {@link ExternalSystem} class represents an external system, connected and interact with this system.
+     * {@link ExternalSystem} takes full charge of network communication with the remote, external system have connected.
+     * Replied {@link Invoke} messages from the external system is shifted to and processed in, children elements of this
+     * class, {@link ExternalSystemRole} objects.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Bridge & Proxy Pattern
+     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
+     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalSystem extends protocol.EntityDequeCollection<ExternalSystemRole> implements protocol.IProtocol {
+        /**
+         * The name represents external system have connected.
+         */
+        protected name: string;
+        /**
+         * @hidden
+         */
+        private system_array_;
+        /**
+         * @hidden
+         */
+        private communicator_;
+        /**
+         * Construct from parent {@link ExternalSystemArray}.
+         *
+         * @param systemArray The parent {@link ExternalSystemArray} object.
+         */
+        constructor(systemArray: ExternalSystemArray<ExternalSystem>);
+        /**
+         * Constrct from parent {@link ExternalSystemArray} and communicator.
+         *
+         * @param systemArray The parent {@link ExternalSystemArray} object.
+         * @param communicator Communicator with the remote, external system.
+         */
+        constructor(systemArray: ExternalSystemArray<ExternalSystem>, communicator: protocol.IClientDriver);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link ExternalSystem} object is destructed and
+         * the {@link ExternalSystem} object is destructed when connection with the remote system is closed or this
+         * {@link ExternalSystem} object is {@link ExternalSystemArray.erase erased} from its parent
+         * {@link ExternalSystemArray} object.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link ExternalSystem} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class SomeSystem extends templates.external.ExternalSystem
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * @hidden
+         */
+        private _Handle_close();
+        /**
+         * Get parent {@link ExternalSystemArray} object.
+         */
+        getSystemArray(): ExternalSystemArray<ExternalSystem>;
+        /**
+         * Get parent {@link ExternalSystemArray} object.
+         */
+        getSystemArray<SystemArray extends ExternalSystemArray<ExternalSystem>>(): SystemArray;
+        /**
+         * Identifier of {@link ExternalSystem} is its {@link name}.
+         *
+         * @return name.
+         */
+        key(): string;
+        /**
+         * Get {@link name}.
+         */
+        getName(): string;
+        /**
+         * @hidden
+         */
+        /**
+         * @hidden
+         */
+        protected communicator: protocol.ICommunicator;
+        /**
+         * Close connection.
+         */
+        close(): void;
+        /**
+         * Send {@link Invoke} message to external system.
+         *
+         * @param invoke An {@link Invoke} message to send.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle an {@Invoke} message has received.
+         *
+         * @param invoke An {@link Invoke} message have received.
+         */
+        replyData(invoke: protocol.Invoke): void;
+        /**
+         * Tag name of the {@link ExternalSystem} in {@link XML}.
+         *
+         * @return *system*.
+         */
+        TAG(): string;
+        /**
+         * Tag name of {@link ExternalSystemRole children elements} belonged to the {@link ExternalSystem} in {@link XML}.
+         *
+         * @return *role*.
+         */
+        CHILD_TAG(): string;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A driver for a parallel slave system.
+     *
+     * The {@link ParallelSystem} is an abstract class represents a **slave** system in *Parallel Processing System*,
+     * connected with this **master** system. This {@link ParallelSystem} takes full charge of network communication with
+     * the remote, parallel **slave** system has connected.
+     *
+     * When a *parallel process* is requested (by {@link ParallelSystemArray.sendSegmentData} or
+     * {@link ParallelSystemArray.sendPieceData}), the number of pieces to be allocated to a {@link ParallelSystem} is
+     * turn on its {@link getPerformance performance index}. Higher {@link getPerformance performance index}, then
+     * more pieces are requested. The {@link getPerformance performance index} is revaluated whenever a *parallel process*
+     * has completed, basic on the execution time and number of pieces. You can sugguest or enforce the
+     * {@link getPerformance performance index} with {@link setPerformance} or {@link enforcePerformance}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Bridge & Proxy Pattern
+     * This class {@link ParallelSystem} is derived from the {@link ExternalSystem} class. Thus, you can take advantage
+     * of the *Bridge & Proxy Pattern* in this {@link ParallelSystem} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Bridge & Proxy Pattern*:
+     *
+     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
+     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ParallelSystem extends external.ExternalSystem {
+        /**
+         * @hidden
+         */
+        private progress_list_;
+        /**
+         * @hidden
+         */
+        private history_list_;
+        /**
+         * @hidden
+         */
+        private exclude_;
+        /**
+         * @hidden
+         */
+        private performance;
+        /**
+         * @hidden
+         */
+        private enforced_;
+        /**
+         * Construct from parent {@link ParallelSystemArray}.
+         *
+         * @param systemArray The parent {@link ParallelSystemArray} object.
+         */
+        constructor(systemArray: ParallelSystemArray<ParallelSystem>);
+        /**
+         * Construct from parent {@link ParallelSystemArray} and communicator.
+         *
+         * @param systemArray The parent {@link ParallelSystemArray} object.
+         * @param communicator A communicator communicates with remote, the external system.
+         */
+        constructor(systemArray: ParallelSystemArray<ParallelSystem>, communicator: protocol.IClientDriver);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link ParallelSystem} object is destructed and
+         * the {@link ParallelSystem} object is destructed when connection with the remote system is closed or this
+         * {@link ParallelSystem} object is {@link ParallelSystemArray.erase erased} from its parent
+         * {@link ParallelSystemArray} object.
+         *
+         * You may think if there're some *parallel processes* have requested but not completed yet, then it would be a
+         * critical problem because the *parallel processes* will not complete forever. Do not worry. The critical problem
+         * does not happen. After the destruction, the remained *parallel processes* will be shifted to and proceeded in
+         * other {@link ParallelSystem} objects.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link ParallelSystem} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class SomeSystem extends protocol.external.ExternalSystem
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * Get manager of this object.
+         *
+         * @return The parent {@link ParallelSystemArray} object.
+         */
+        getSystemArray(): ParallelSystemArray<ParallelSystem>;
+        /**
+         * Get manager of this object.
+         *
+         * @return The parent {@link ParallelSystemArray} object.
+         */
+        getSystemArray<SystemArray extends ParallelSystemArray<ParallelSystem>>(): SystemArray;
+        /**
+         * Get performance index.
+         *
+         * Get *performance index* that indicates how much fast the remote system is.
+         *
+         * If this {@link ParallelSystem parallel system} does not have any {@link Invoke} message had handled, then the
+         * *performance index* will be ```1.0```, which means default and average value between all {@link ParallelSystem}
+         * instances (that are belonged to a same {@link ParallelSystemArray} object).
+         *
+         * You can specify this *performance index* by yourself but notice that, if the *performance index* is higher
+         * than other {@link ParallelSystem} objects, then this {@link ParallelSystem parallel system} will be ordered to
+         * handle more processes than other {@link ParallelSystem} objects. Otherwise, the *performance index* is lower
+         * than others, of course, less processes will be delivered.
+         *
+         * - {@link setPerformance setPerformance()}
+         * - {@link enforcePerformance enforcePerformance()}
+         *
+         * Unless {@link enforcePerformance enforcePerformance()} is called, This *performance index* is **revaluated**
+         * whenever user calls one of them below.
+         *
+         * - {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()}
+         * - {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()}
+         * - {@link DistributedProcess.sendData DistributedProcess.sendData()}.
+         *
+         * @return Performance index.
+         */
+        getPerformance(): number;
+        /**
+         * Set performance index.
+         *
+         * Set *performance index* that indicates how much fast the remote system is. This *performance index* can be
+         * **revaulated**.
+         *
+         * Note that, initial and average *performance index* of {@link ParallelSystem} objects are ```1.0```. If the
+         * *performance index* is higher than other {@link ParallelSystem} objects, then this {@link ParallelSystem} will
+         * be ordered to handle more processes than other {@link ParallelSystem} objects. Otherwise, the
+         * *performance index* is lower than others, of course, less processes will be delivered.
+         *
+         * Unlike {@link enforcePerformance}, configuring *performance index* by this {@link setPerformance} allows
+         * **revaluation**. This **revaluation** prevents wrong valuation from user. For example, you *mis-valuated* the
+         * *performance index*. The remote system is much faster than any other, but you estimated it to the slowest one.
+         * It looks like a terrible case that causes {@link ParallelSystemArray entire parallel systems} to be slower,
+         * however, don't mind. The system will direct to the *propriate performance index* eventually with the
+         * **revaluation** by following methods.
+         *
+         * - {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()}
+         * - {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()}
+         * - {@link DistributedProcess.sendData DistributedProcess.sendData()}.
+         *
+         * @param val New performance index, but can be revaluated.
+         */
+        setPerformance(val: number): void;
+        /**
+         * Enforce performance index.
+         *
+         * Enforce *performance index* that indicates how much fast the remote system is. The *performance index* will be
+         * fixed, never be **revaluated**.
+         *
+         * Note that, initial and average *performance index* of {@link ParallelSystem} objects are ```1.0```. If the
+         * *performance index* is higher than other {@link ParallelSystem} objects, then this {@link ParallelSystem} will
+         * be ordered to handle more processes than other {@link ParallelSystem} objects. Otherwise, the
+         * *performance index* is lower than others, of course, less processes will be delivered.
+         *
+         * The difference between {@link setPerformance} and this {@link enforcePerformance} is allowing **revaluation**
+         * or not. This {@link enforcePerformance} does not allow the **revaluation**. The *performance index* is clearly
+         * fixed and never be changed by the **revaluation**. But you've to keep in mind that, you can't avoid the
+         * **mis-valuation** with this {@link enforcePerformance}.
+         *
+         * For example, there's a remote system much faster than any other, but you **mis-estimated** it to the slowest.
+         * In that case, there's no way. The {@link ParallelSystemArray entire parallel systems} will be slower by the
+         * **mis-valuation**. By the reason, using {@link enforcePerformance}, it's recommended only when you can clearly
+         * certain the *performance index*. If you can't certain the *performance index* but want to recommend, then use
+         * {@link setPerformance} instead.
+         *
+         * @param val New performance index to be fixed.
+         */
+        enforcePerformance(val: number): void;
+        /**
+         * @hidden
+         */
+        private _Send_piece_data(invoke, first, last);
+        /**
+         * @hidden
+         */
+        private _Reply_data(invoke);
+        /**
+         * @hidden
+         */
+        protected _Report_history(xml: library.XML): void;
+        /**
+         * @hidden
+         */
+        protected _Send_back_history(invoke: protocol.Invoke, history: slave.InvokeHistory): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * A driver for a distributed slave system.
+     *
+     * The {@link DistributedSystem} is an abstract class represents a **slave** system in *Distributed Processing System*,
+     * connected with this **master** system. This {@link DistributedSystem} takes full charge of network communication
+     * with the remote, distributed **slave** system has connected.
+     *
+     * This {@link DistributedSystem} has a {@link getPerformance performance index} that indicates how much the **slave**
+     * system is fast. The {@link getPerformance performance index} is referenced and revaluated whenever those methods
+     * are called:
+     *
+     * - Requesting a *parallel process*
+     *   - {@link DistributedSystemArray.sendSegmentData}
+     *   - {@link DistributedSystemArray.sendPieceData}
+     * - Requesting a *distributed process*: {@link DistributedProcess.sendData}
+     *
+     * Note that, this {@link DistributedSystem} class derived from the {@link ExternalSystem} class. Thus, this
+     * {@link DistributedSystem} can also have children {@link ExternalSystemRole} objects exclusively. However, the
+     * children {@link ExternalSystemRole roles} objects are different with the {@link DistributedProcess}. The
+     * domestic {@link ExternalSystemRole roles} are belonged to only a specific {@link DistributedSystem} object.
+     * Otherwise, the {@link DistributedProcess} objects are belonged to a {@link DistributedSystemArray} object.
+     * Furthermore, the relationship between this {@link DistributedSystem} and {@link DistributedProcess} classes are
+     * **M: N Associative**.
+     *
+     * Articles     | {@link DistributedProcess}     | {@link ExternalSystemRole}
+     * -------------|--------------------------------|----------------------------
+     * Belonged to  | {@link DistributedSystemArray} | {@link DistributedSystem}
+     * Relationship | M: N Associative               | 1: N Composite
+     * Ownership    | References                     | Exclusive possession
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedSystem extends parallel.ParallelSystem {
+        /**
+         * Construct from parent {@link DistributedSystemArray}.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         */
+        constructor(systemArray: DistributedSystemArray<DistributedSystem>);
+        /**
+         * Constrct from parent {@link DistributedSystemArray} and communicator.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         * @param communicator A communicator communicates with remote, the external system.
+         */
+        constructor(systemArray: DistributedSystemArray<DistributedSystem>, communicator: protocol.IClientDriver);
+        /**
+         * Factory method creating a {@link ExternalSystemRole child} object.
+         *
+         * In {@link distributed} module, the process class {@link DistributedProcess} is not belonged to a specific
+         * {@link DistributedSystem} object. It only belongs to a {@link DistributedSystemArray} object and has a
+         * **M: N Associative Relationship** between this {@link DistributedSystem} class.
+         *
+         * By that reason, it's the normal case that the {@link DistributedSystem} object does not have any children
+         * {@link ExternalSystemRole} object. Thus, default {@link createChild} returns ```null```.
+         *
+         * However, if you want a {@link DistributedSystem} to have its own domestic {@link ExternalSystemRole} objects
+         * without reference to the {@link DistributedProcess} objects, it is possible. Creates and returns the
+         * domestic {@link ExternalSystemRole} object.
+         *
+         * @param xml {@link XML} represents the {@link ExternalSystemRole child} object.
+         * @return A newly created {@link ExternalSystemRole} object or ```null```.
+         */
+        createChild(xml: library.XML): external.ExternalSystemRole;
+        /**
+         * Get manager of this object.
+         *
+         * @return The parent {@link DistributedSystemArray} object.
+         */
+        getSystemArray(): DistributedSystemArray<DistributedSystem>;
+        /**
+         * Get manager of this object.
+         *
+         * @return The parent {@link DistributedSystemArray} object.
+         */
+        getSystemArray<SystemArray extends DistributedSystemArray<DistributedSystem>>(): SystemArray;
+        /**
+         * @hidden
+         */
+        private _Compute_average_elapsed_time();
+        /**
+         * @inheritdoc
+         */
+        replyData(invoke: protocol.Invoke): void;
+        /**
+         * @hidden
+         */
+        protected _Report_history(xml: library.XML): void;
+        /**
+         * @hidden
+         */
+        protected _Send_back_history(invoke: protocol.Invoke, history: slave.InvokeHistory): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * A driver for distributed slave server.
+     *
+     * The {@link DistributedServer} is an abstract class, derived from the {@link DistributedSystem} class, connecting to
+     * remote, distributed **slave** server. Extends this {@link DistributedServer} class and overrides the
+     * {@link createServerConnector createServerConnector()} method following which protocol the **slave** server uses.
+     *
+     * #### [Inheritdoc] {@link DistributedSystem}
+     * @copydoc DistributedSystem
+     */
+    abstract class DistributedServer extends DistributedSystem implements external.IExternalServer {
+        /**
+         * IP address of target external system to connect.
+         */
+        protected ip: string;
+        /**
+         * Port number of target external system to connect.
+         */
+        protected port: number;
+        /**
+         * Construct from parent {@link DistributedSystemArray}.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         */
+        constructor(systemArray: DistributedSystemArray<DistributedSystem>);
+        /**
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the slave server
+         * follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link DedicatedWorkerServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
+         */
+        protected abstract createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Master of Distributed Processing System, a client connecting to slave servers.
+     *
+     * The {@link DistributedServerArray} is an abstract class, derived from the {@link DistributedSystemArray} class,
+     * connecting to {@link IDistributedServer distributed servers}.
+     *
+     * Extends this {@link DistributedServerArray} and overrides {@link createChild createChild()} method creating child
+     * {@link IDistributedServer} object. After the extending and overriding, construct children {@link IDistributedServer}
+     * objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * @copydoc DistributedSystemArray
+     */
+    abstract class DistributedServerArray<System extends IDistributedServer> extends DistributedSystemArray<System> implements external.IExternalServerArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System, a client connecting to slave servers.
+     *
+     * The {@link DistributedServerArrayMediator} is an abstract class, derived from {@link DistributedSystemArrayMediator}
+     * class, connecting to {@link IDistributedServer distributed servers}.
+     *
+     * Extends this {@link DistributedServerArrayMediator} and overrides {@link createChild createChild()} method creating
+     * child {@link IDistributedServer} object. After the extending and overriding, construct children
+     * {@link IDistributedServer} objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArrayMediator}
+     * @copydoc DistributedSystemArrayMediator
+     */
+    abstract class DistributedServerArrayMediator<System extends IDistributedServer> extends DistributedSystemArrayMediator<System> implements external.IExternalServerArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Master of Distributed Processing System, be a server and client at the same time.
+     *
+     * The {@link DistributedServerClientArray} is an abstract class, derived from the {@link DistributedSystemArray}
+     * class, opening a server accepting {@link Distributed distributed clients} and being a client connecting to
+     * {@link IDistributedServer distributed servers} at the same time.
+     *
+     * Extends this {@link DistributedServerClientArray} and overrides below methods. After the overridings, open server
+     * with {@link open open()} method and connect to {@link IDistributedServer distributed servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * @copydoc DistributedSystemArray
+     */
+    abstract class DistributedServerClientArray<System extends DistributedSystem> extends DistributedClientArray<System> implements external.IExternalServerClientArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating an {@link IDistributedServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IDistributedServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): System;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System, be a server and client at the same time as a **master**.
+     *
+     * The {@link DistributedServerClientArrayMediator} is an abstract class, derived from the
+     * {@link DistributedSystemArrayMediator} class, opening a server accepting {@link DistributedSystem distributed
+     * clients} and being a client connecting to {@link IDistributedServer distributed servers} at the same time.
+     *
+     * Extends this {@link DistributedServerClientArrayMediator} and overrides below methods. After the overridings, open
+     * server with {@link open open()} method and connect to {@link IDistributedServer distributed servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link DistributedSystemArrayMediator}
+     * @copydoc DistributedSystemArrayMediator
+     */
+    abstract class DistributedServerClientArrayMediator<System extends DistributedSystem> extends DistributedClientArrayMediator<System> implements external.IExternalServerClientArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating an {@link IDistributedServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IDistributedServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): System;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * A process of Distributed Processing System.
+     *
+     * The {@link DistributedProcess} is an abstract class who represents a **process**, *SOMETHING TO DISTRIBUTE* in a Distributed
+     * Processing System. Overrides the {@link DistributedProcess} and defines the *SOMETHING TO DISTRIBUTE*.
+     *
+     * Relationship between {@link DistributedSystem} and {@link DistributedProcess} objects are **M: N Associative**.
+     * Unlike {@link ExternalSystemRole}, the {@link DistributedProcess} objects are not belonged to a specific
+     * {@link DistributedSystem} object. The {@link DistributedProcess} objects are belonged to the
+     * {@link DistributedSystemArrayMediator} directly.
+     *
+     * When you need the **distributed process**, then call {@link sendData sendData()}. The {@link sendData} will find
+     * the most idle {@link DistributedSystem slave system} considering not only number of processes on progress, but also
+     * {@link DistributedSystem.getPerformance performance index} of each {@link DistributedSystem} object and
+     * {@link getResource resource index} of this {@link DistributedProcess} object. The {@link Invoke} message
+     * requesting the **distributed process** will be sent to the most idle {@link DistributedSystem slave system}.
+     *
+     * Those {@link DistributedSystem.getPerformance performance index} and {@link getResource resource index} are
+     * revaluated whenever the **distributed process** has completed basis on the execution time.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedProcess extends protocol.Entity implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        private system_array_;
+        /**
+         * A name, represents and identifies this {@link DistributedProcess process}.
+         *
+         * This {@link name} is an identifier represents this {@link DistributedProcess process}. This {@link name} is
+         * used in {@link DistributedSystemArray.getProcess} and {@link DistributedSystemArray.getProcess}, as a key elements.
+         * Thus, this {@link name} should be unique in its parent {@link DistributedSystemArray} object.
+         */
+        protected name: string;
+        /**
+         * @hidden
+         */
+        private progress_list_;
+        /**
+         * @hidden
+         */
+        private history_list_;
+        /**
+         * @hidden
+         */
+        private resource;
+        /**
+         * @hidden
+         */
+        private enforced_;
+        /**
+         * Constrct from parent {@link DistributedSystemArray} object.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         */
+        constructor(systemArray: DistributedSystemArray<DistributedSystem>);
+        /**
+         * Identifier of {@link ParallelProcess} is its {@link name}.
+         */
+        key(): string;
+        /**
+         * Get parent {@link DistributedSystemArray} object.
+         *
+         * @return The parent {@link DistributedSystemArray} object.
+         */
+        getSystemArray(): DistributedSystemArray<DistributedSystem>;
+        /**
+         * Get parent {@link DistributedSystemArray} object.
+         *
+         * @return The parent {@link DistributedSystemArray} object.
+         */
+        getSystemArray<SystemArray extends DistributedSystemArray<DistributedSystem>>(): SystemArray;
+        /**
+         * Get name, who represents and identifies this process.
+         */
+        getName(): string;
+        /**
+         * Get resource index.
+         *
+         * Get *resource index* that indicates how much this {@link DistributedProcess process} is heavy.
+         *
+         * If this {@link DistributedProcess process} does not have any	{@link Invoke} message had handled, then the
+         * *resource index* will be ```1.0```, which means default and average value between all
+         * {@link DistributedProcess} instances (that are belonged to a same {@link DistributedSystemArray} object).
+         *
+         * You can specify the *resource index* by yourself, but notice that, if the *resource index* is higher than
+         * other {@link DistributedProcess} objects, then this {@link DistributedProcess process} will be ordered to
+         * handle less processes than other {@link DistributedProcess} objects. Otherwise, the *resource index* is
+         * lower than others, of course, much processes will be requested.
+         *
+         * - {@link setResource setResource()}
+         * - {@link enforceResource enforceResource()}
+         *
+         * Unless {@link enforceResource enforceResource()} is called, This *resource index* is **revaluated** whenever
+         * {@link sendData sendData()} is called.
+         *
+         * @return Resource index.
+         */
+        getResource(): number;
+        /**
+         * Set resource index.
+         *
+         * Set *resource index* that indicates how much this {@link DistributedProcess process} is heavy. This
+         * *resource index* can be **revaulated**.
+         *
+         * Note that, initial and average *resource index* of {@link DistributedProcess} objects are ```1.0```. If the
+         * *resource index* is higher than other {@link DistributedProcess} objects, then this
+         * {@link DistributedProcess} will be ordered to handle more processes than other {@link DistributedProcess}
+         * objects. Otherwise, the *resource index* is lower than others, of course, less processes will be requested.
+         *
+         * Unlike {@link enforceResource}, configuring *resource index* by this {@link setResource} allows the
+         * **revaluation**. This **revaluation** prevents wrong valuation from user. For example, you *mis-valuated* the
+         * *resource index*. The {@link DistributedProcess process} is much heavier than any other, but you estimated it
+         * to the lightest one. It looks like a terrible case that causes
+         * {@link DistributedSystemArray entire distributed processing system} to be slower, however, don't mind. The
+         * {@link DistributedProcess process} will the direct to the *propriate resource index* eventually with the
+         * **revaluation**.
+         *
+         * - The **revaluation** is caused by the {@link sendData sendData()} method.
+         *
+         * @param val New resource index, but can be revaluated.
+         */
+        setResource(val: number): void;
+        /**
+         * Enforce resource index.
+         *
+         * Enforce *resource index* that indicates how much heavy the {@link DistributedProcess process is}. The
+         * *resource index* will be fixed, never be **revaluated**.
+         *
+         * Note that, initial and average *resource index* of {@link DistributedProcess} objects are ```1.0```. If the
+         * *resource index* is higher than other {@link DistributedProcess} objects, then this
+         * {@link DistributedProcess} will be ordered to handle more processes than other {@link DistributedProcess}
+         * objects. Otherwise, the *resource index* is lower than others, of course, less processes will be requested.
+         *
+         * The difference between {@link setResource} and this {@link enforceResource} is allowing **revaluation** or not.
+         * This {@link enforceResource} does not allow the **revaluation**. The *resource index* is clearly fixed and
+         * never be changed by the **revaluation**. But you've to keep in mind that, you can't avoid the **mis-valuation**
+         * with this {@link enforceResource}.
+         *
+         * For example, there's a {@link DistributedProcess process} much heavier than any other, but you
+         * **mis-estimated** it to the lightest. In that case, there's no way. The
+         * {@link DistributedSystemArray entire distributed processing system} will be slower by the **mis-valuation**.
+         * By the reason, using {@link enforceResource}, it's recommended only when you can clearly certain the
+         * *resource index*. If you can't certain the *resource index* but want to recommend, then use {@link setResource}
+         * instead.
+         *
+         * @param val New resource index to be fixed.
+         */
+        enforceResource(val: number): void;
+        /**
+         * @hidden
+         */
+        private _Compute_average_elapsed_time();
+        /**
+         * @inheritdoc
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message requesting a **distributed process**. The {@link Invoke} message will be sent
+         * to the most idle {@link DistributedSystem} object, which represents a slave system, and the most idle
+         * {@link DistributedSystem} object will be returned.
+         *
+         * When the **distributed process** has completed, then the {@link DistributedSystemArray} object will revaluate
+         * {@link getResource resource index} and {@link DistributedSystem.getPerformance performance index} of this
+         * {@link DistributedSystem} and the most idle {@link DistributedSystem} objects basis on the execution time.
+         *
+         * @param invoke An {@link Invoke} message requesting distributed process.
+         * @return The most idle {@link DistributedSystem} object who may send the {@link Invoke} message.
+         */
+        sendData(invoke: protocol.Invoke): DistributedSystem;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message requesting a **distributed process**. The {@link Invoke} message will be sent
+         * to the most idle {@link DistributedSystem} object, which represents a slave system, and the most idle
+         * {@link DistributedSystem} object will be returned.
+         *
+         * When the **distributed process** has completed, then the {@link DistributedSystemArray} object will revaluate
+         * {@link getResource resource index} and {@link DistributedSystem.getPerformance performance index} of this
+         * {@link DistributedSystem} and the most idle {@link DistributedSystem} objects basis on the execution time.
+         *
+         * @param invoke An {@link Invoke} message requesting distributed process.
+         * @param weight Weight of resource which indicates how heavy this {@link Invoke} message is. Default is 1.
+         *
+         * @return The most idle {@link DistributedSystem} object who may send the {@link Invoke} message.
+         */
+        sendData(invoke: protocol.Invoke, weight: number): DistributedSystem;
+        /**
+         * @hidden
+         */
+        private _Complete_history(history);
+        /**
+         * @inheritdoc
+         */
+        TAG(): string;
+    }
+}
+declare namespace samchon.templates.slave {
+    /**
+     * History of an {@link Invoke} message.
+     *
+     * The {@link InvokeHistory} is a class archiving history log of an {@link Invoke} message with elapsed time. This
+     * {@link InvokeHistory} class is used to report elapsed time of handling a requested process from **slave** to
+     * **master** system.
+     *
+     * The **master** system utilizes derived {@link InvokeHistory} objects to compute performance indices.
+     * - {@link ParallelSytem.getPerformance}
+     * - {@link DistributedProcess.getResource}
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class InvokeHistory extends protocol.Entity {
+        /**
+         * @hidden
+         */
+        private uid;
+        /**
+         * @hidden
+         */
+        private listener;
+        /**
+         * @hidden
+         */
+        private start_time_;
+        /**
+         * @hidden
+         */
+        private end_time_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from an {@link Invoke} message.
+         *
+         * @param invoke An {@link Invoke} message requesting a *parallel or distributed process*.
+         */
+        constructor(invoke: protocol.Invoke);
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Complete the history.
+         *
+         * Completes the history and determines the {@link getEndTime end time}.
+         */
+        complete(): void;
+        key(): number;
+        /**
+         * Get unique ID.
+         */
+        getUID(): number;
+        /**
+         * Get {@link Invoke.getListener listener} of the {@link Invoke} message.
+         */
+        getListener(): string;
+        /**
+         * Get start time.
+         */
+        getStartTime(): Date;
+        /**
+         * Get end time.
+         */
+        getEndTime(): Date;
+        /**
+         * Compute elapsed time.
+         *
+         * @return nanoseconds.
+         */
+        computeElapsedTime(): number;
+        /**
+         * @inheritdoc
+         */
+        TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+        /**
+         * Convert to an {@link Invoke} message.
+         *
+         * Creates and returns an {@link Invoke} message that is used to reporting to the **master**.
+         */
+        toInvoke(): protocol.Invoke;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * History of an {@link Invoke} message.
+     *
+     * The {@link PRInvokeHistory} is a class archiving history log of an {@link Invoke} message which requests the
+     * *distributed process*, created whenever {@link DistributedProcess.sendData} is called.
+     *
+     * When the *distributed process* has completed, then {@link complete complete()} is called and the *elapsed time* is
+     * determined. The elapsed time is utilized for computation of {@link DistributedSystem.getPerformance performance index}
+     * and {@link DistributedProcess.getResource resource index} of related objects.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DSInvokeHistory extends slave.InvokeHistory {
+        /**
+         * @hidden
+         */
+        private system_;
+        /**
+         * @hidden
+         */
+        private process_;
+        /**
+         * @hidden
+         */
+        private weight_;
+        /**
+         * Construct from a DistributedSystem.
+         *
+         * @param system The {@link DistributedSystem} object who sent the {@link Invoke} message.
+         */
+        constructor(system: DistributedSystem);
+        /**
+         * Initilizer Constructor.
+         *
+         * @param system The {@link DistributedSystem} object who sent the {@link Invoke} message.
+         * @param process The {@link DistributedProcess} object who sent the {@link Invoke} message.
+         * @param invoke An {@link Invoke} message requesting the *distributed process*.
+         * @param weight Weight of resource which indicates how heavy this {@link Invoke} message is.
+         */
+        constructor(system: DistributedSystem, process: DistributedProcess, invoke: protocol.Invoke, weight: number);
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Get the related {@link DistributedSystem} object.
+         */
+        getSystem(): DistributedSystem;
+        /**
+         * Get the related {@link DistributedProcess} object.
+         */
+        getProcess(): DistributedProcess;
+        /**
+         * Get weight.
+         *
+         * Gets weight of resource which indicates how heavy this {@link Invoke} message is. Default is 1.
+         */
+        getWeight(): number;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * An interface for a distributed slave server driver.
+     *
+     * The easiest way to defining a driver for distributed **slave** server is extending {@link DistributedServer} class.
+     * However, if you've to interact with a prallel **slave** system who can be both server and client, them make a class
+     * (let's name it **BaseSystem**) extending the {@link DistributedServer} class. At next, make a new class (now, I name
+     * it **BaseServer**) extending the **BaseSystem** and implements this interface {@link IParallelServer}. Define the
+     * **BaseServer** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IDistributedServer extends DistributedSystem {
+        /**
+         * Connect to external server.
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An array and manager of {@link ExternalSystem external clients} as a server.
+     *
+     * The {@link ExternalClientArray} is an abstract class, derived from the {@link ExternalSystemArray} class, opening
+     * a server accepting {@link ExternalSystem external clients}.
+     *
+     * Extends this {@link ExternalClientArray}, overrides {@link createServerBase createServerBase()} to determine which
+     * protocol to follow and {@link createExternalClient createExternalClient()} creating child {@link ExternalSystem}
+     * object. After the extending and overridings, open this server using the {@link open open()} method.
+     *
+     * #### [Inherited] {@link ExternalSystemArray}
+     * @copydoc ExternalSystemArray
+     */
+    abstract class ExternalClientArray<T extends ExternalSystem> extends ExternalSystemArray<T> implements IExternalClientArray<T> {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which templates is used in this server,
+         * {@link ExternalClientArray}. If the templates is determined, then {@link ExternalSystem external clients} who
+         * may connect to {@link ExternalClientArray this server} must follow the specified templates.
+         *
+         * Creates and returns one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *server* {@link ExternalClientArray} object,
+         * then this {@link ExternalClientArray} creates a child {@link ExternalSystem external client} object through
+         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ExternalClientArray} is a server accepting {@link ExternalSystem external clients}.
+         * There's no way to creating the {@link ExternalSystem external clients} in advance before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ExternalSystem} object.
+         * @return null
+         */
+        createChild(xml: library.XML): T;
+        /**
+         * Factory method creating a child {@link ExternalSystem} object.
+         *
+         * @param driver A communicator with connected client.
+         * @return A newly created {@link ExternalSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): T;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An external server driver.
+     *
+     * The {@link ExternalServer} is an abstract class, derived from the {@link ExternalSystem} class, connecting to
+     * remote, external server. Extends this {@link ExternalServer} class and overrides the
+     * {@link createServerConnector createServerConnector()} method following which protocol the external server uses.
+     *
+     * #### [Inherited] {@link ExternalSystem}
+     * @copydoc ExternalSystem
+     */
+    abstract class ExternalServer extends ExternalSystem implements IExternalServer {
+        /**
+         * IP address of target external system to connect.
+         */
+        protected ip: string;
+        /**
+         * Port number of target external system to connect.
+         */
+        protected port: number;
+        /**
+         * Construct from parent {@link ExternalSystemArray}.
+         *
+         * @param systemArray The parent {@link ExternalSystemArray} object.
+         */
+        constructor(systemArray: ExternalSystemArray<IExternalServer>);
+        /**
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which templates the external
+         * system follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link DedicatedWorkerServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
+         */
+        protected abstract createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An array and manager of {@link IExternalServer external servers}.
+     *
+     * The {@link ExternalServerArray} is an abstract class, derived from the {@link ExternalSystemArray} class,
+     * connecting to {@link IExternalServer external servers}.
+     *
+     * Extends this {@link ExternalServerArray} and overrides {@link createChild createChild()} method creating child
+     * {@link IExternalServer} object. After the extending and overriding, construct children {@link IExternalServer}
+     * objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link ExternalSystemArray}
+     * @copydoc ExternalSystemArray
+     */
+    abstract class ExternalServerArray<T extends IExternalServer> extends ExternalSystemArray<T> implements IExternalServerArray<T> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An array and manager of {@link IExternalServer external servers} and {@link ExternalSystem external clients}.
+     *
+     * The {@link ExternalServerClientArray} is an abstract class, derived from the {@link ExternalSystemArray} class,
+     * opening a server accepting {@link ExternalSystem external clients} and being a client connecting to
+     * {@link IExternalServer external servers} at the same time.
+     *
+     * Extends this {@link ExternalServerClientArray} and overrides below methods. After the overridings, open server
+     * with {@link open open()} method and connect to {@link IExternalServer external servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link ExternalSystemArray}
+     * @copydoc ExternalSystemArray
+     */
+    abstract class ExternalServerClientArray<T extends ExternalSystem> extends ExternalClientArray<T> implements IExternalServerClientArray<T> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): T;
+        /**
+         * Factory method creating an {@link IExternalServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IExternalServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * A role of an external system.
+     *
+     * The {@link ExternalSystemRole} class represents a role, *WHAT TO DO*. Extends the {@link ExternalSystemRole} class
+     * and overrides {@link replyData replyData()} to define the *WHAT TO DO*. And assign this {@link ExternalSystemRole}
+     * object to related {@link ExternalSystem} object.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * The {@link ExternalSystemRole} class can be an *logical proxy*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem} object, via {@link ExternalSystemArray.getRole ExternalSystemArray.getRole()}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalSystemRole extends protocol.Entity implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        private system;
+        /**
+         * A name, represents and identifies this {@link ExternalSystemRole role}.
+         *
+         * This {@link name} is an identifier represents this {@link ExternalSystemRole role}. This {@link name} is
+         * used in {@link ExternalSystemArray.getRole} and {@link ExternalSystem.get}, as a key elements. Thus, this
+         * {@link name} should be unique in an {@link ExternalSystemArray}.
+         */
+        protected name: string;
+        /**
+         * Constructor from a system.
+         *
+         * @param system An external system containing this role.
+         */
+        constructor(system: ExternalSystem);
+        /**
+         * Identifier of {@link ExternalSystemRole} is its {@link name}.
+         */
+        key(): string;
+        /**
+         * Get grandparent {@link ExternalSystemArray}.
+         *
+         * Get the grandparent {@link ExternalSystemArray} object through this parent {@link ExternalSystem},
+         * {@link ExternalSystem.getSystemArray ExternalSystem.getSystemArray()}.
+         *
+         * @return The grandparent {@link ExternalSystemArray} object.
+         */
+        getSystemArray(): ExternalSystemArray<ExternalSystem>;
+        /**
+         * Get parent {@link ExternalSystemRole} object.
+         */
+        getSystem(): ExternalSystem;
+        /**
+         * Get name, who represents and identifies this role.
+         */
+        getName(): string;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to remote system through the parent {@link ExternalSystem} object.
+         *
+         * @param invoke An {@link Invoke} message to send to the external system.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle replied {@link Invoke} message.
+         *
+         * {@link ExternalSystemRole.replyData ExternalSystemRole.replyData()} is an abstract method handling a replied
+         * {@link Invoke message} gotten from remote system via parent {@link ExternalSystem} object. Overrides this
+         * method and defines the *WHAT TO DO* with the {@link Invoke message}.
+         *
+         * @param invoke An {@link Invoke} message received from the {@link ExternalSystem external system}.
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
+        /**
+         * Tag name of the {@link ExternalSytemRole} in {@link XML}.
+         *
+         * @return *role*.
+         */
+        TAG(): string;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
+     * {@link IServer server}.
+     *
+     * The easiest way to defining an {@link ExternalSystemArray} who opens server and accepts
+     * {@link ExternalSystem external clients} is to extending one of below, who are derived from this interface
+     * {@link IExternalClientArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
+     * client, then make a class (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make
+     * a new class (now, I name it **BaseClientArray**) extending **BaseSystemArray** and implementing this
+     * interface {@link IExternalClientArray}. Define the **BaseClientArray** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalClientArray<System extends ExternalSystem> extends ExternalSystemArray<System>, protocol.IServer {
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an external server driver.
+     *
+     * The easiest way to defining an external server driver is to extending one of below, who are derived from this
+     * interface {@link IExternalServer}. However, if you've to interact with an external system who can be both server
+     * and client, then make a class (let's name it as **BaseSystem**) extending {@link ExternalSystem} and make a
+     * new class (now, I name it **BaseServer**) extending **BaseSystem** and implementing this interface
+     * {@link IExternalServer}. Define the **BaseServer** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalServer extends ExternalSystem {
+        /**
+         * Connect to the external server.
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an {@link ExternalSystemArray} connects to {@link IExternalServer external servers} as a
+     * **client**.
+     *
+     * The easiest way to defining an {@link ExternalSystemArray} who connects to
+     * {@link IExternalServer external servers} is to extending one of below, who are derived from this interface
+     * {@link IExternalServerArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
+     * client, then make a class (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make
+     * a new class (now, I name it **BaseServerArray**) extending **BaseSystemArray** and implementing this
+     * interface {@link IExternalServerArray}. Define the **BaseServerArray** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServerArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServerArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServerArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelServerArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServerArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedServerArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalServerArray<System extends IExternalServer> extends ExternalSystemArray<System> {
+        /**
+         * Connect to {@link IExternalServer external servers}.
+         *
+         * This method calls children elements' method {@link IExternalServer.connect} gradually.
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
+     * {@link IServer server} and connects to {@link IExternalServer} as **client**, at the same time.
+     *
+     * The easiest way to defining an {@link IExternalServerClientArray} who opens server, accepts
+     * {@link ExternalSystem external clients} and connects to {@link IExternalServer external servers} is to extending
+     * one of below, who are derived from this interface {@link IExternalServerClientArray}. However, if you can't
+     * specify an {@link ExternalSystemArray} to be whether server or client or even can both them, then make a class
+     * (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make a new class (now, I name
+     * it **BaseServerClientArray**) extending **BaseSystemArray** and implementing this interface
+     * {@link IExternalServerClientArray}. Define the **BaseServerClientArray** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServerClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServerClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServerClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelServerClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServerClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedServerClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalServerClientArray<System extends ExternalSystem> extends IExternalClientArray<System> {
+        /**
+         * Connect to {@link IExternalServer external servers}.
+         *
+         * This method calls children elements' method {@link IExternalServer.connect} gradually.
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.slave {
+    /**
+     * A slave system.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class SlaveSystem implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        protected communicator_: protocol.ICommunicator;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        sendData(invoke: protocol.Invoke): void;
+        abstract replyData(invoke: protocol.Invoke): void;
+        /**
+         * @hidden
+         */
+        protected _Reply_data(invoke: protocol.Invoke): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A mediator, the master driver.
+     *
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
+     *
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorDedicatedWorkerServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MediatorSystem extends slave.SlaveSystem {
+        /**
+         * @hidden
+         */
+        private system_array_;
+        /**
+         * @hidden
+         */
+        private progress_list_;
+        /**
+         * Construct from parent {@link ParallelSystemArrayMediator} object.
+         *
+         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
+         */
+        constructor(systemArray: ParallelSystemArrayMediator<ParallelSystem>);
+        /**
+         * Construct from parent {@link DistributedSystemArrayMediator} object.
+         *
+         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
+         */
+        constructor(systemArray: distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>);
+        /**
+         * Start interaction.
+         *
+         * The {@link start start()} is an abstract method starting interaction with the **master** system. If the
+         * **master** is a server, then connects to the **master**. Otherwise, the **master** is client, then this
+         * {@link MediatorSystem} object wil open a server accepting the **master**.
+         */
+        abstract start(): void;
+        /**
+         * Get parent {@link ParallelSystemArrayMediator} or {@link DistributedSystemArrayMediator} object.
+         */
+        getSystemArray(): ParallelSystemArrayMediator<ParallelSystem> | distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>;
+        /**
+         * Get parent {@link ParallelSystemArrayMediator} object.
+         */
+        getSystemArray<SystemArray extends ParallelSystemArray<ParallelSystem>>(): SystemArray;
+        /**
+         * Get parent {@link DistributedSystemArrayMediator} object.
+         */
+        getSystemArray<SystemArray extends distributed.DistributedSystemArray<distributed.DistributedSystem>>(): SystemArray;
+        /**
+         * @hidden
+         */
+        private _Complete_history(uid);
+        /**
+         * @hidden
+         */
+        protected _Reply_data(invoke: protocol.Invoke): void;
+        /**
+         * @inheritdoc
+         */
+        replyData(invoke: protocol.Invoke): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A mediator client, driver for the master server.
+     *
+     * The {@link MediatorServer} is a class being a client connecting to the **master** server, following the protocol
+     * of Samchon Framework's own.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * @copydoc MediatorSystem
+     */
+    class MediatorClient extends MediatorSystem implements slave.ISlaveClient {
+        /**
+         * @hidden
+         */
+        private ip;
+        /**
+         * @hidden
+         */
+        private port;
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
+         * @param ip IP address to connect.
+         * @param port Port number to connect.
+         */
+        constructor(systemArray: ParallelSystemArrayMediator<ParallelSystem>, ip: string, port: number);
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
+         * @param ip IP address to connect.
+         * @param port Port number to connect.
+         */
+        constructor(systemArray: distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>, ip: string, port: number);
+        /**
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the **master**
+         * server follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
+         */
+        protected createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        start(): void;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+    /**
+     * A mediator client, driver for the master server.
+     *
+     * The {@link MediatorWebClient} is a class being a client connecting to the **master** server, following the
+     * web-socket protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * @copydoc MediatorSystem
+     */
+    class MediatorWebClient extends MediatorClient {
+        /**
+         * @inheritdoc
+         */
+        protected createServerConnector(): protocol.IServerConnector;
+    }
+    /**
+     * A mediator client, driver for the master server.
+     *
+     * The {@link MediatorSharedWorkerClient} is a class being a client connecting to the **master** server, following
+     * the SharedWorker's protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * @copydoc MediatorSystem
+     */
+    class MediatorSharedWorkerClient extends MediatorClient {
+        /**
+         * @inheritdoc
+         */
+        protected createServerConnector(): protocol.IServerConnector;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A mediator server, driver for the master client.
+     *
+     * The {@link MediatorServer} is a class opening a server accepting the **master** client, following the protocol of
+     * Samchon Framework's own.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * @copydoc MediatorSystem
+     */
+    class MediatorServer extends MediatorSystem implements slave.ISlaveServer {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * @hidden
+         */
+        private port;
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
+         * @param port Port number of server to open.
+         */
+        constructor(systemArray: ParallelSystemArrayMediator<ParallelSystem>, port: number);
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
+         * @param port Port number of server to open.
+         */
+        constructor(systemArray: distributed.DistributedSystemArrayMediator<distributed.DistributedSystem>, port: number);
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * {@link MediatorServer}. Note that, **slave** (this {@link MediatorServer} object) must follow the **master**'s
+         * protocol.
+         *
+         * Overrides and return one of them considering the which protocol to follow:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         */
+        protected createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * {@link MediatorServer} represents a **slave** dedicating to its **master**. In that reason, the
+         * {@link MediatorServer} does not accept multiple **master** clients. It accepts only one. Thus, *listener* of
+         * the *communicator* is {@link MediatorSystem} object, itself.
+         *
+         * @param driver A communicator with remote client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * @inheritdoc
+         */
+        start(): void;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+    /**
+     * A mediator server, driver for the master client.
+     *
+     * The {@link MediatorWebServer} is a class opening a server accepting the **master** client, following the
+     * web-socket protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * @copydoc MediatorSystem
+     */
+    class MediatorWebServer extends MediatorServer {
+        /**
+         * @inheritdoc
+         */
+        protected createServerBase(): protocol.IServerBase;
+    }
+    /**
+     * A mediator server, driver for the master client.
+     *
+     * The {@link MediatorDedicatedWorkerServer} is a class opening a server accepting the **master** client, following
+     * the DedicatedWorker's protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * @copydoc MediatorSystem
+     */
+    class MediatorDedicatedWorkerServer extends MediatorServer {
+        /**
+         * @inheritdoc
+         */
+        protected createServerBase(): protocol.IServerBase;
+    }
+    /**
+     * A mediator server, driver for the master client.
+     *
+     * The {@link MediatorSharedWorkerServer} is a class opening a server accepting the **master** client, following the
+     * SharedWorker's protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * @copydoc MediatorSystem
+     */
+    class MediatorSharedWorkerServer extends MediatorServer {
+        /**
+         * @inheritdoc
+         */
+        protected createServerBase(): protocol.IServerBase;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Master of Parallel Processing System, a server accepting slave clients.
+     *
+     * The {@link ParallelClientArray} is an abstract class, derived from the {@link ParallelSystemArray} class, opening
+     * a server accepting {@link ParallelSystem parallel clients}.
+     *
+     * Extends this {@link ParallelClientArray}, overrides {@link createServerBase createServerBase()} to determine which
+     * protocol to follow and {@link createExternalClient createExternalClient()} creating child {@link ParallelSystem}
+     * object. After the extending and overridings, open this server using the {@link open open()} method.
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * @copydoc ParallelSystemArray
+     */
+    abstract class ParallelClientArray<System extends ParallelSystem> extends ParallelSystemArray<System> implements external.IExternalClientArray<System> {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
+         * may connect to {@link ExternalClientArray this server} must follow the specified protocol.
+         *
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
+         * then this {@link ParallelClientArray} creates a child {@link ParallelSystem parallel client} object through
+         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ParallelClientArray} is a server accepting {@link ParallelSystem parallel clients}.
+         * There's no way to creating the {@link ParallelSystem parallel clients} in advance before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
+         * @return ```null```
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating {@link ParallelSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link ParallelSystem} object with
+         * the *driver* that communicates with the parallel client. After the creation, returns the {@link ParallelSystem}
+         * object. Then whenever a parallel client has connected, matched {@link ParallelSystem} object will be
+         * constructed and {@link insert inserted} into this {@link ParallelClientArray} object.
+         *
+         * @param driver A communicator with the parallel client.
+         * @return A newly created {@link ParallelSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Mediator of Parallel Processing System.
+     *
+     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
+     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
+     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
+     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlaveSystem} class.
+     *
+     * As a **master**, you can specify this {@link ParallelSystemArrayMediator} class to be <i>a master server accepting
+     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
+     * of them below and overrides abstract factory method(s) creating the child {@link ParallelSystem} object.
+     *
+     * - {@link ParallelClientArrayMediator}: A server accepting {@link ParallelSystem parallel clients}.
+     * - {@link ParallelServerArrayMediator}: A client connecting to {@link ParallelServer parallel servers}.
+     * - {@link ParallelServerClientArrayMediator}: Both of them. Accepts {@link ParallelSystem parallel clients} and
+     *   connects to {@link ParallelServer parallel servers} at the same time.
+     *
+     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
+     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorDedicatedWorkerServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * @copydoc ParallelSystemArray
+     */
+    abstract class ParallelSystemArrayMediator<System extends ParallelSystem> extends ParallelSystemArray<System> {
+        /**
+         * @hidden
+         */
+        private mediator_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating a {@link MediatorSystem} object.
+         *
+         * The {@link createMediator createMediator()} is an abstract method creating the {@link MediatorSystem} object.
+         *
+         * You know what? this {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a
+         * **slave** to its master system at the same time. The {@link MediatorSystem} object makes it possible; be a
+         * **slave** system. This {@link createMediator} determines specific type of the {@link MediatorSystem}.
+         *
+         * Overrides the {@link createMediator createMediator()} method to create and return one of them following which
+         * protocol and which type of remote connection (server or client) will be used:
+         *
+         * - A client slave connecting to master server:
+         *   - {@link MediatorClient}
+         *   - {@link MediatorWebClient}
+         *   - {@link MediatorSharedWorkerClient}
+         * - A server slave accepting master client:
+         *   - {@link MediatorServer}
+         *   - {@link MediatorWebServer}
+         *   - {@link MediatorDedicatedWorkerServer}
+         *   - {@link MediatorSharedWorkerServer}
+         *
+         * @return A newly created {@link MediatorSystem} object.
+         */
+        protected abstract createMediator(): MediatorSystem;
+        /**
+         * Start mediator.
+         *
+         * If the {@link getMediator mediator} is a type of server, then opens the server accepting master client.
+         * Otherwise, the {@link getMediator mediator} is a type of client, then connects the master server.
+         */
+        protected startMediator(): void;
+        /**
+         * Get {@link MediatorSystem} object.
+         *
+         * When you need to send an {@link Invoke} message to the master system of this
+         * {@link ParallelSystemArrayMediator}, then send to the {@link MediatorSystem} through this {@link getMediator}.
+         *
+         * ```typescript
+         * this.getMediator().sendData(...);
+         * ```
+         *
+         * @return The {@link MediatorSystem} object.
+         */
+        getMediator(): MediatorSystem;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: slave.InvokeHistory): boolean;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Mediator of Parallel Processing System, a server accepting slave clients.
+     *
+     * The {@link ParallelClientArrayMediator} is an abstract class, derived from the {@link ParallelSystemArrayMediator}
+     * class, opening a server accepting {@link ParallelSystem parallel clients} as a **master**.
+     *
+     * Extends this {@link ParallelClientArrayMediator}, overrides {@link createServerBase createServerBase()} to
+     * determine which protocol to follow and {@link createExternalClient createExternalClient()} creating child
+     * {@link ParallelSystem} object. After the extending and overridings, open this server using the
+     * {@link open open()} method.
+     *
+     * #### [Inherited] {@link ParallelSystemArrayMediator}
+     * @copydoc ParallelSystemArrayMediator
+     */
+    abstract class ParallelClientArrayMediator<System extends ParallelSystem> extends ParallelSystemArrayMediator<System> implements external.IExternalClientArray<System> {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * {@link ParallelClientArrayMediator}. If the protocol is determined, then
+         * {@link ParallelSystem parallel clients} who may connect to {@link ParallelClientArrayMediator this server}
+         * must follow the specified protocol.
+         *
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
+         * then this {@link ParallelClientArrayMediator} creates a child {@link ParallelSystem parallel client} object
+         * through the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for parallel client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ParallelClientArrayMediator} is a server accepting {@link ParallelSystem parallel
+         * clients} as a master. There's no way to creating the {@link ParallelSystem parallel clients} in advance before
+         * opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
+         * @return null
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating {@link ParallelSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link ParallelSystem} object with
+         * the *driver* that communicates with the parallel client. After the creation, returns the {@link ParallelSystem}
+         * object. Then whenever a parallel client has connected, matched {@link ParallelSystem} object will be
+         * constructed and {@link insert inserted} into this {@link ParallelClientArrayMediator} object.
+         *
+         * @param driver A communicator with the parallel client.
+         * @return A newly created {@link ParallelSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): System;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A driver for parallel slave server.
+     *
+     * The {@link ParallelServer} is an abstract class, derived from the {@link ParallelSystem} class, connecting to
+     * remote, parallel **slave** server. Extends this {@link ParallelServer} class and overrides the
+     * {@link createServerConnector createServerConnector()} method following which protocol the **slave** server uses.
+     *
+     * #### [Inherited] {@link ParallelSystem}
+     * @copydoc ParallelSystem
+     */
+    abstract class ParallelServer extends ParallelSystem implements IParallelServer {
+        /**
+         * IP address of target external system to connect.
+         */
+        protected ip: string;
+        /**
+         * Port number of target external system to connect.
+         */
+        protected port: number;
+        /**
+         * Construct from parent {@link ParallelSystemArray}.
+         *
+         * @param systemArray The parent {@link ParallelSystemArray} object.
+         */
+        constructor(systemArray: ParallelSystemArray<IParallelServer>);
+        /**
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the slave server
+         * follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link DedicatedWorkerServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
+         */
+        protected abstract createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Master of Parallel Processing System, a client connecting to slave servers.
+     *
+     * The {@link ParallelServerArray} is an abstract class, derived from the {@link ParallelSystemArray} class,
+     * connecting to {@link IParallelServer parallel servers}.
+     *
+     * Extends this {@link ParallelServerArray} and overrides {@link createChild createChild()} method creating child
+     * {@link IParallelServer} object. After the extending and overriding, construct children {@link IParallelServer}
+     * objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * @copydoc ParallelSystemArray
+     */
+    abstract class ParallelServerArray<System extends IParallelServer> extends ParallelSystemArray<System> implements external.IExternalServerArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Mediator of Parallel Processing System, a client connecting to slave servers.
+     *
+     * The {@link ParallelServerArrayMediator} is an abstract class, derived from the {@link ParallelSystemArrayMediator}
+     * class, connecting to {@link IParallelServer parallel servers}.
+     *
+     * Extends this {@link ParallelServerArrayMediator} and overrides {@link createChild createChild()} method creating
+     * child {@link IParallelServer} object. After the extending and overriding, construct children
+     * {@link IParallelServer} objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link ParallelSystemArrayMediator}
+     * @copydoc ParallelSystemArrayMediator
+     */
+    abstract class ParallelServerArrayMediator<System extends IParallelServer> extends ParallelSystemArrayMediator<System> implements external.IExternalServerArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Master of Parallel Processing System, be a server and client at the same time.
+     *
+     * The {@link ParallelServerClientArray} is an abstract class, derived from the {@link ParallelSystemArray} class,
+     * opening a server accepting {@link ParallelSystem parallel clients} and being a client connecting to
+     * {@link IParallelServer parallel servers} at the same time.
+     *
+     * Extends this {@link ParallelServerClientArray} and overrides below methods. After the overridings, open server
+     * with {@link open open()} method and connect to {@link IParallelServer parallel servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * @copydoc ParallelClientArray
+     */
+    abstract class ParallelServerClientArray<System extends ParallelSystem> extends ParallelClientArray<System> implements external.IExternalServerClientArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating an {@link IParallelServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IParallelServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): System;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Mediator of Parallel Processing System, be a server and client at the same time as a **master**.
+     *
+     * The {@link ParallelServerClientArrayMediator} is an abstract class, derived from the
+     * {@link ParallelSystemArrayMediator} class, opening a server accepting {@link ParallelSystem parallel clients} and
+     * being a client connecting to {@link IParallelServer parallel servers} at the same time.
+     *
+     * Extends this {@link ParallelServerClientArrayMediator} and overrides below methods. After the overridings, open
+     * server with {@link open open()} method and connect to {@link IParallelServer parallel servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link ParallelSystemArrayMediator}
+     * @copydoc ParallelClientArrayMediator
+     */
+    abstract class ParallelServerClientArrayMediator<System extends ParallelSystem> extends ParallelClientArrayMediator<System> implements external.IExternalServerClientArray<System> {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): System;
+        /**
+         * Factory method creating an {@link IParallelServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IParallelServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): System;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * An interface for a parallel slave server driver.
+     *
+     * The easiest way to defining a driver for parallel **slave** server is extending {@link ParallelServer} class.
+     * However, if you've to interact with a prallel **slave** system who can be both server and client, them make a class
+     * (let's name it **BaseSystem**) extending the {@link ParallelSystem} class. At next, make a new class (now, I name it
+     * **BaseServer**) extending the **BaseSystem** and implements this interface {@link IParallelServer}. Define the
+     * **BaseServer** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IParallelServer extends ParallelSystem {
+        /**
+         * Connect to slave server.
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * History of an {@link Invoke} message.
+     *
+     * The {@link PRInvokeHistory} is a class archiving history log of an {@link Invoke} message which requests the
+     * *parallel process*, created whenever {@link ParallelSystemArray.sendSegmentData} or
+     * {@link ParallelSystemArray.sendSegmentData} is called.
+     *
+     * When the *parallel process* has completed, then {@link complete complete()} is called and the *elapsed time* is
+     * determined. The elapsed time is utilized for computation of {@link ParallelSystem.getPerformance performance index}
+     * of each {@link ParallelSystem parallel slave system}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class PRInvokeHistory extends slave.InvokeHistory {
+        /**
+         * @hidden
+         */
+        private first;
+        /**
+         * @hidden
+         */
+        private last;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from an {@link Invoke} message.
+         *
+         * @param invoke An {@link Invoke} message requesting a *parallel process*.
+         */
+        constructor(invoke: protocol.Invoke);
+        /**
+         * Get initial piece's index.
+         *
+         * Returns initial piece's index in the section of requested *parallel process*.
+         *
+         * @return The initial index.
+         */
+        getFirst(): number;
+        /**
+         * Get final piece's index.
+         *
+         * Returns initial piece's index in the section of requested *parallel process*. The range used is
+         * [*first*, *last*), which contains all the pieces' indices between *first* and *last*, including the piece
+         * pointed by index *first*, but not the piece pointed by the index *last*.
+         *
+         * @return The final index.
+         */
+        getLast(): number;
+        /**
+         * Compute number of allocated pieces.
+         */
+        computeSize(): number;
+    }
+}
+declare namespace samchon.templates.service {
+    /**
+     * A driver of remote client.
+     *
+     * The {@link Client} is an abstract class representing and interacting with a remote client. It deals the network
+     * communication with the remote client and shifts {@link Invoke} message to related {@link User} and {@link Service}
+     * objects.
+     *
+     * Extends this {@link Client} class and override the {@link createService} method, a factory method creating a child
+     * {@link Service} object. Note that, {@link Client} represents a remote client, not *an user*, a specific *web page*
+     * or *service*. Do not define logics about user or account information. It must be declared in the parent
+     * {@link User} class. Also, don't define processes of a specific a web page or service. Defines them in the child
+     * {@link Service} class.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Client implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        private user_;
+        /**
+         * @hidden
+         */
+        private no_;
+        /**
+         * @hidden
+         */
+        private communicator_;
+        /**
+         * @hidden
+         */
+        private service_;
+        /**
+         * Construct from parent {@link User} and communicator.
+         *
+         * @param user Parent {@link User} object.
+         * @param driver Communicator with remote client.
+         */
+        constructor(user: User, driver: protocol.WebClientDriver);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link Client} object is destructed and this
+         * {@link Client} object is destructed when connection with the remote client is closed or this {@link Client}
+         * object is {@link User.erase erased} from its parent {@link User} object.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link Client} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class MyUser extends protocol.service.Client
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * Factory method creating {@link Service} object.
+         *
+         * @param path Requested path.
+         * @return A newly created {@link Service} object or ```null```.
+         */
+        protected abstract createService(path: string): Service;
+        /**
+         * Close connection.
+         */
+        close(): void;
+        /**
+         * Get parent {@link User} object.
+         *
+         * Get the parent {@link User} object, who is groupping {@link Client} objects with same session id.
+         *
+         * @return The parent {@link User} object.
+         */
+        getUser(): User;
+        /**
+         * Get child {@link Service} object.
+         *
+         * @return The child {@link Service} object.
+         */
+        getService(): Service;
+        /**
+         * Get sequence number.
+         *
+         * Get sequence number of this {@link Client} object in the parent {@link User} object. This sequence number also
+         * be a *key* in the parent {@link User} object, who extended the ```std.HashMap<number, Client>```.
+         *
+         * @return Sequence number.
+         */
+        getNo(): number;
+        /**
+         * Change related {@link Service} object.
+         *
+         * @param path Requested, identifier path.
+         */
+        protected changeService(path: string): void;
+        /**
+         * Change {@link Service} to another.
+         *
+         * @param service {@link service} object to newly assigned.
+         */
+        protected changeService(service: Service): void;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to remote client.
+         *
+         * @param invoke An {@link Invoke} messgae to send to remote client.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle a replied {@link Invoke} message.
+         *
+         * The default {@link Client.replyData Client.replyData()} shifts chain to its parent {@link User} and belonged
+         * {@link Service} objects, by calling the the {@link User.replyData User.replyData()} and
+         * {@link Service.replyData Service.replyData()} methods.
+         *
+         * Note that, {@link Client} represents a remote client, not *an user*, a specific *web page* or *service*. Do not
+         * define logics about user or account information. It must be declared in the parent {@link User} class. Also,
+         * don't define processes of a specific a web page or service. Defines them in the child {@link Service} class.
+         *
+         * ```typescript
+         * class protocol.service.Client
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *         // SHIFT TO PARENT USER
+         *         // THE PARENT USER ALSO MAY SHIFT TO ITS PARENT SERVER
+         *         this.getUser().replyData(invoke);
+         *
+         *         // SHIFT TO BELOGED SERVICE
+         *         if (this.getService() != null)
+         *             this.getService().replyData(invoke);
+         *     }
+         * }
+         *
+         * class MyClient extends protocol.service.Client
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *         if (invoke.getListener() == "do_something_in_client_level")
+         *             this.do_something_in_client_level();
+         *         else
+         *             super.replyData(invoke);
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke An {@link Invoke invoke} message to be handled in {@link Client} level.
+         */
+        replyData(invoke: protocol.Invoke): void;
+    }
+}
+/**
+ * A system template for Cloud Service.
+ *
+ * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.service {
+    /**
+     * A cloud server.
+     *
+     * The {@link Server} is an abstract server class, who can build a real-time cloud server, that is following the
+     * web-socket protocol. Extends this {@link Server} and related classes and overrides abstract methods under below.
+     * After the overridings, open this {@link Server cloud server} using the {@link open open()} method.
+     *
+     * - Objects in composite relationship and their factory methods
+     *   - {@link User}: {@link Server.createUser Server.createUser()}
+     *   - {@link Client}: {@link User.createClient User.createClient()}
+     *   - {@link Service}: {@link Client.createService Client.createService()}
+     * - {@link Invoke} message chains; {@link IProtocol.replyData replyData}
+     *   - {@link Server.replyData}
+     *   - {@link User.replyData}
+     *   - {@link Client.replyData}
+     *   - {@link Service.replyData}
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Server extends protocol.WebServer implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        private session_map_;
+        /**
+         * @hidden
+         */
+        private account_map_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link User} object.
+         *
+         * @return A newly created {@link User} object.
+         */
+        protected abstract createUser(): User;
+        /**
+         * Test wheter an {@link User} exists with the *accountID*.
+         *
+         * @param accountID Account id of {@link User} to find.
+         * @return Exists or not.
+         */
+        has(accountID: string): boolean;
+        /**
+         * Get an {@link User} object by its *accountID*.
+         *
+         * @param accountID Account id of {@link User} to get.
+         * @return An {@link User} object.
+         */
+        get(accountID: string): User;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to all remote clients through the belonged {@link User} and {@link Client}
+         * objects. Sending the {@link Invoke} message to all remote clients, it's came true by passing through
+         * {@link User.sendData User.sendData()}. And the {@link User.sendData} also pass through the
+         * {@link Client.sendData Client.sendData()}.
+         *
+         * ```typescript
+         * class protocol.service.Server
+         * {
+         *     public sendData(invoke: Invoke): void
+         *     {
+         *         for (user: User in this)
+         *             for (client: Client in user)
+         *                 client.sendData(invoke);
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke {@link Invoke} message to send to all remote clients.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle a replied {@link Invoke} message.
+         *
+         * The {@link Server.replyData Server.replyData()} is an abstract method that handling {@link Invoke} message
+         * that should be handled in the {@link Server} level. Overrides this {@link replyData replyData()} method and
+         * defines what to do with the {@link Invoke} message in this {@link Server} level.
+         *
+         * @param invoke An {@link Invoke invoke} message to be handled in {@link Server} level.
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link WebClientDriver remote client} connects to this cloud server, then {@link Server} queries the
+         * {WebClientDriver.getSessionID session id} of the {@link WebClientDriver remote client}. If the
+         * {WebClientDriver.getSessionID session id} is new one, then creates a new {@link User} object.
+         *
+         * At next, creates a {@link Client} object who represents the newly connected remote client and insert the
+         * {@link Client} object to the matched {@link User} object which is new or ordinary one following the
+         * {WebClientDriver.getSessionID session id}. At last, a {@link Service} object can be created with referencing
+         * the {@link WebClientDriver.getPath path}.
+         *
+         * List of objects can be created by this method.
+         * - {@link User} by {@link createUser createUser()}.
+         * - {@link Client} by {@link User.createClient User.createClient()}.
+         * - {@link Service} by {@link Client.createService Client.createService()}.
+         *
+         * @param driver A web communicator for remote client.
+         */
+        addClient(driver: protocol.WebClientDriver): void;
+        /**
+         * @hidden
+         */
+        private _Erase_user(user);
+    }
+}
+declare namespace samchon.templates.service {
+    /**
+     * A service.
+     *
+     * The {@link Service} is an abstract class who represents a service, that is providing functions a specific page.
+     *
+     * Extends the {@link Service} class and defines its own service, which to be provided for the specific weg page,
+     * by overriding the {@link replyData replyData()} method. Note that, the service, functions for the specific page
+     * should be defined in this {@link Service} class, not its parent {@link Client} class who represents a remote client
+     * and takes communication responsibility.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Service implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        private client_;
+        /**
+         * @hidden
+         */
+        private path_;
+        /**
+         * Construct from parent {@link Client} and requested path.
+         *
+         * @param client Driver of remote client.
+         * @param path Requested path that identifies this {@link Service}.
+         */
+        constructor(client: Client, path: string);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is call when the {@link Service} object is destructed and the
+         * {@link Service} object is destructed when its parent {@link Client} object has
+         * {@link Client.destructor destructed} or the {@link Client} object {@link Client.changeService changed} its
+         * child {@link Service service} object to another one.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link Service} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         */
+        protected destructor(): void;
+        /**
+         * Get client.
+         */
+        getClient(): Client;
+        /**
+         * Get requested path.
+         */
+        getPath(): string;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to remote system through parent {@link Client} object ({@link Client.sendData}).
+         *
+         * @param invoke An {@link Invoke} message to send to the remte system.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * @inheritdoc
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
+    }
+}
+declare namespace samchon.templates.service {
+    /**
+     * An user.
+     *
+     * The {@link User} is an abstract class groupping {@link Client} objects, who communicates with remote client, with
+     * same *session id*. This {@link User} represents a *remote user* literally. Within framework of remote system,
+     * an {@link User} corresponds to a web-browser and a {@link Client} represents a window in the web-browser.
+     *
+     * Extends this {@link User} class and override the {@link createClient} method, a factory method creating a child
+     * {@link Client} object. I repeat, the {@link User} class represents a *remote user*, groupping {@link Client}
+     * objects with same *session id*. If your cloud server has some processes to be handled in the **user level**, then
+     * defines method in this {@link User} class. Methods managing **account** under below are some of them:
+     *
+     * - {@link setAccount setAccount()}
+     * - {@link getAccountID getAccountID()}
+     * - {@link getAuthority getAuthority()}
+     *
+     * The children {@link Client} objects, they're contained with their key, the {@link Client.getNo sequence number}.
+     * If you {@link User.erase erase} the children {@link Client} object by yourself, then their connection with the
+     * remote clients will be {@link Client.close closed} and their {@link Client.destructor destruction method} will be
+     * called. If you remove {@link clear all children}, then this {@link User} object will be also
+     * {@link destructor destructed} and erased from the parent {@link Server} object.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class User extends collections.HashMapCollection<number, Client> implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        private server_;
+        /**
+         * @hidden
+         */
+        private session_id_;
+        /**
+         * @hidden
+         */
+        private sequence_;
+        /**
+         * @hidden
+         */
+        private account_id_;
+        /**
+         * @hidden
+         */
+        private authority_;
+        /**
+         * Construct from its parent {@link Server}.
+         *
+         * @param server The parent {@link Server} object.
+         */
+        constructor(server: Server);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link User} object is destructed. The
+         * {@link User} object is destructed when connections with the remote clients are all closed, that is all the
+         * children {@link Client} objects are all removed, and 30 seconds has left. If some remote client connects
+         * within the 30 seconds, then the {@link User} object doesn't be destructed.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link User} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class MyUser extends protocol.service.User
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * Factory method creating a {@link Client} object.
+         *
+         * @param driver A web communicator for remote client.
+         * @return A newly created {@link Client} object.
+         */
+        protected abstract createClient(driver: protocol.WebClientDriver): Client;
+        /**
+         * @hidden
+         */
+        private _Handle_erase_client(event);
+        /**
+         * Get parent {@lin Server} object.
+         *
+         * @return Parent {@link Server} object.
+         */
+        getServer(): Server;
+        /**
+         * Get account id.
+         *
+         * @return Account ID.
+         */
+        getAccountID(): string;
+        /**
+         * Get authority.
+         *
+         * @return Authority
+         */
+        getAuthority(): number;
+        /**
+         * Set *account id* and *authority*.
+         *
+         * The {@link setAccount setAccount()} is a method configuring *account id* and *authority* of this {@link User}.
+         *
+         * After the configuring, the {@link getAccountID account id} is enrolled into the parent {@link Server} as a
+         * **key** for this {@link User} object. You can test existence and access this {@link User} object from
+         * {@link Server.has Server.has()} and {@link Server.get Server.get()} with the {@link getAccountID account id}.
+         * Of course, if ordinary {@link getAccountID account id} had existed, then the ordinary **key** will be
+         * replaced.
+         *
+         * As you suggest, this {@link setAccount setAccount()} is something like a **log-in** function. If what you want
+         * is not **logging-in**, but **logging-out**, then configure the *account id* to empty string ``""```` or call
+         * the {@link lgout logout()} method.
+         *
+         * @param id To be account id.
+         * @param authority To be authority.
+         */
+        setAccount(id: string, authority: number): void;
+        /**
+         * Log-out.
+         *
+         * This {@link logout logout()} method configures {@link getAccountID account id} to empty string and
+         * {@link getAuthority authority} to zero.
+         *
+         * The ordinary {@link getAccountID account id} will be also erased from the parent {@link Server} object. You
+         * can't access this {@link User} object from {@link Server.has Server.has()} and {@link Server.get Server.get()}
+         * with the ordinary {@link getAccountID account id} more.
+         */
+        logout(): void;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to all remote clients through the belonged {@link Client} objects. Sending the
+         * {@link Invoke} message to all remote clients, it's came true by passing through the
+         * {@link Client.sendData Client.sendData()} methods.
+         *
+         * ```typescript
+         * class protocol.service.User
+         * {
+         *     public sendData(invoke: Invoke): void
+         *     {
+         *         for (let it = this.begin(); !it.equals(this.end()); it = it.next())
+         *             it.second.sendData(invoke);
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke {@link Invoke} message to send to all remote clients.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle a replied {@link Invoke} message.
+         *
+         * The default {@link User.replyData User.replyData()} shifts chain to its parent {@link Server} object, by
+         * calling the {@link Server.replyData Server.replyData()} method. If there're some {@link Invoke} message to be
+         * handled in this {@link User} level, then override this method and defines what to do with the {@link Invoke}
+         * message in this {@link User} level.
+         *
+         * ```typescript
+         * class protocol.service.User
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *         this.getServer().replyData(invoke);
+         *     }
+         * }
+         *
+         * class MyUser extends protocol.service.User
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *          if (invoke.apply(this) == false) // IS TARGET TO BE HANDLED IN THIS USER LEVEL
+         *              super.replyData(invoke); // SHIFT TO SERVER
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke An {@link Invoke invoke} message to be handled in {@link User} level.
+         */
+        replyData(invoke: protocol.Invoke): void;
+    }
+}
+declare namespace samchon.templates.slave {
+    /**
+     * An {@link Invoke} message which represents a **process**.
+     *
+     *
+     *
+     * #### [Inherited] {@link Invoke}
+     * @copydoc Invoke
+     */
+    class PInvoke extends protocol.Invoke {
+        /**
+         * @hidden
+         */
+        private history_;
+        /**
+         * @hidden
+         */
+        private slave_system_;
+        /**
+         * @hidden
+         */
+        private hold_;
+        /**
+         * Initializer Constructor.
+         *
+         * @param invoke Original {@link Invoke} message.
+         * @param history {@link InvokeHistory} object archiving execution time.
+         * @param slaveSystem Related {@link SlaveSystem} object who gets those processes from its master.
+         */
+        constructor(invoke: protocol.Invoke, history: InvokeHistory, slaveSystem: SlaveSystem);
+        /**
+         * Get history object.
+         *
+         * Get {@link InvokeHistory} object who is archiving execution time of this process.
+         */
+        getHistory(): InvokeHistory;
+        /**
+         * Is the reporting hold?
+         */
+        isHold(): boolean;
+        /**
+         * Hold reporting completion to master.
+         */
+        hold(): void;
+        /**
+         * Report completion.
+         */
+        complete(): void;
+    }
+}
+declare namespace samchon.templates.slave {
+    interface ISlaveClient extends SlaveSystem {
+        connect(ip: string, port: number): void;
+    }
+    abstract class SlaveClient extends SlaveSystem implements ISlaveClient {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        protected abstract createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        connect(ip: string, port: number): void;
+    }
+}
+declare namespace samchon.templates.slave {
+    interface ISlaveServer extends SlaveSystem, protocol.IServer {
+    }
+    abstract class SlaveServer extends SlaveSystem implements ISlaveServer {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+        /**
+         * @inheritdoc
+         */
+        addClient(driver: protocol.IClientDriver): void;
+    }
+}
diff --git a/samchon/samchon-tests.ts b/samchon/samchon-tests.ts
new file mode 100644
index 0000000000..3c805025ac
--- /dev/null
+++ b/samchon/samchon-tests.ts
@@ -0,0 +1,2 @@
+import samchon = require("samchon");
+console.log(samchon);
\ No newline at end of file
diff --git a/samchon/tsconfig.json b/samchon/tsconfig.json
new file mode 100644
index 0000000000..ec6c511b01
--- /dev/null
+++ b/samchon/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": false,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "samchon-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/tstl/index.d.ts b/tstl/index.d.ts
new file mode 100644
index 0000000000..c1bd7d7aeb
--- /dev/null
+++ b/tstl/index.d.ts
@@ -0,0 +1,11136 @@
+// Type definitions for TSTL v1.3.10
+// Project: https://github.com/samchon/tstl
+// Definitions by: Jeongho Nam <http://samchon.org>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module "tstl"
+{
+	export = std;
+}
+
+/**
+ * # <u>T</u>ypeScript-<u>STL</u>
+ *
+ * <a href="https://nodei.co/npm/tstl">
+ *	<img src="https://nodei.co/npm/tstl.png?downloads=true&downloadRank=true&stars=true"> </a>
+ *
+ * STL (Standard Template Library) Containers and Algorithms for TypeScript.
+ *
+ * **T**ypeScript-**STL** is a TypeScript's <b>Standard Template Library</b> who is migrated from C++ STL. Most of classes
+ * and functions of STL have implemented. Just enjoy it.
+ *
+ * @git https://github.com/samchon/tstl
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace std {
+}
+/**
+ * Base classes composing STL in background.
+ *
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace std.base {
+}
+declare namespace std {
+    /**
+     * Apply function to range.
+     *
+     * Applies function <i>fn</i> to each of the elements in the range [<i>first</i>, <i>last</i>).
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param fn Unary function that accepts an element in the range as argument. This can either be a function p
+     *			 ointer or a move constructible function object. Its return value, if any, is ignored.
+     */
+    function for_each<T, InputIterator extends Iterator<T>, Func extends (val: T) => any>(first: InputIterator, last: InputIterator, fn: Func): Func;
+    /**
+     * Apply function to range.
+     *
+     * Applies function *fn* to each of the elements in the range [*first*, *first + n*).
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param n the number of elements to apply the function to
+     * @param fn Unary function that accepts an element in the range as argument. This can either be a function p
+     *			 ointer or a move constructible function object. Its return value, if any, is ignored.
+     *
+     * @return first + n
+     */
+    function for_each_n<T, InputIterator extends Iterator<T>>(first: InputIterator, n: number, fn: (val: T) => any): InputIterator;
+    /**
+     * Test condition on all elements in range.
+     *
+     * Returns <code>true</code> if <i>pred</i> returns <code>true</code> for all the elements in the range
+     * [<i>first</i>, <i>last</i>) or if the range is {@link Container.empty empty}, and <code>false</code> otherwise.
+     *
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
+     *			   <code>boolean</code>. The value returned indicates whether the element fulfills the condition
+     *			   checked by this function. The function shall not modify its argument.
+     *
+     * @return <code>true</code> if pred returns true for all the elements in the range or if the range is
+     *		   {@link Container.empty empty}, and <code>false</code> otherwise.
+     */
+    function all_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean;
+    /**
+     * Test if any element in range fulfills condition.
+     *
+     * Returns <code>true</code> if <i>pred</i> returns true for any of the elements in the range
+     * [<i>first</i>, <i>last</i>), and <code>false</code> otherwise.
+     *
+     * If [<i>first</i>, <i>last</i>) is an {@link Container.empty empty} range, the function returns
+     * <code>false</code>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
+     *			   <code>boolean</code>. The value returned indicates whether the element fulfills the condition
+     *			   checked by this function. The function shall not modify its argument.
+     *
+     * @return <code>true</code> if <i>pred</i> returns <code>true</code> for any of the elements in the range
+     *		   [<i>first</i>, <i>last</i>), and <code>false</code> otherwise. If [<i>first</i>, <i>last</i>) is an
+     *		   {@link Container.empty empty} range, the function returns <code>false</code>.
+     */
+    function any_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean;
+    /**
+     * Test if no elements fulfill condition.
+     *
+     * Returns <code>true</code> if <i>pred</i> returns false for all the elements in the range
+     * [<i>first</i>, <i>last</i>) or if the range is {@link Container.empty empty}, and <code>false</code> otherwise.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
+     *			   <code>boolean</code>. The value returned indicates whether the element fulfills the condition
+     *			   checked by this function. The function shall not modify its argument.
+     *
+     * @return <code>true</code> if <i>pred</i> returns <code>false</code> for all the elements in the range
+     *		   [<i>first</i>, <i>last</i>) or if the range is {@link Container.empty empty}, and <code>false</code>
+     *		   otherwise.
+     */
+    function none_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean;
+    /**
+     * Test whether the elements in two ranges are equal.
+     *
+     * Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
+     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
+     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
+     *
+     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
+     *		   of the range starting at <i>first2</i>, and <code>false</code> otherwise.
+     */
+    function equal<T, InputIterator extends Iterator<T>>(first1: InputIterator, last1: InputIterator, first2: Iterator<T>): boolean;
+    /**
+     * Test whether the elements in two ranges are equal.
+     *
+     * Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
+     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
+     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
+     * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same
+     *			   order), and returns a value convertible to <code>bool</code>. The value returned indicates whether
+     *			   the elements are considered to match in the context of this function.
+     *
+     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
+     *		   of the range starting at <i>first2</i>, and <code>false</code> otherwise.
+     */
+    function equal<T, InputIterator extends Iterator<T>>(first1: InputIterator, last1: InputIterator, first2: Iterator<T>, pred: (x: T, y: T) => boolean): boolean;
+    /**
+     * Lexicographical less-than comparison.
+     *
+     * Returns <code>true</code> if the range [<i>first1</i>, <i>last1</i>) compares <i>lexicographically less</i>
+     * than the range [<i>first2</i>, <i>last2</i>).
+     *
+     * A <i>lexicographical comparison</i> is the kind of comparison generally used to sort words alphabetically in
+     * dictionaries; It involves comparing sequentially the elements that have the same position in both ranges against
+     * each other until one element is not equivalent to the other. The result of comparing these first non-matching
+     * elements is the result of the lexicographical comparison.
+     *
+     * If both sequences compare equal until one of them ends, the shorter sequence is <i>lexicographically less</i>
+     * than the longer one.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence.
+     * @param last2 An {@link Iterator} to the final position of the second sequence. The ranged used is
+     *				[<i>first2</i>, <i>last2</i>).
+     *
+     * @return <code>true</code> if the first range compares <i>lexicographically less</i> than than the second.
+     *		   <code>false</code> otherwise (including when all the elements of both ranges are equivalent).
+     */
+    function lexicographical_compare<T, T1 extends T, T2 extends T, Iterator1 extends Iterator<T1>, Iterator2 extends Iterator<T2>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): boolean;
+    /**
+     * Lexicographical comparison.
+     *
+     * Returns <code>true</code> if the range [<i>first1</i>, <i>last1</i>) compares <i>lexicographically
+     * relationship</i> than the range [<i>first2</i>, <i>last2</i>).
+     *
+     * A <i>lexicographical comparison</i> is the kind of comparison generally used to sort words alphabetically in
+     * dictionaries; It involves comparing sequentially the elements that have the same position in both ranges against
+     * each other until one element is not equivalent to the other. The result of comparing these first non-matching
+     * elements is the result of the lexicographical comparison.
+     *
+     * If both sequences compare equal until one of them ends, the shorter sequence is <i>lexicographically
+     * relationship</i> than the longer one.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence.
+     * @param last2 An {@link Iterator} to the final position of the second sequence. The ranged used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param compare Binary function that accepts two arguments of the types pointed by the iterators, and returns a
+     *		  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *		  considered to go before the second in the specific <i>strict weak ordering</i> it defines.
+     *
+     * @return <code>true</code> if the first range compares <i>lexicographically relationship</i> than than the
+     *		   second. <code>false</code> otherwise (including when all the elements of both ranges are equivalent).
+     */
+    function lexicographical_compare<T, T1 extends T, T2 extends T, Iterator1 extends Iterator<T1>, Iterator2 extends Iterator<T2>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, compare: (x: T, y: T) => boolean): boolean;
+    /**
+     * Find value in range.
+     *
+     * Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) that compares equal to
+     * <i>val</i>. If no such element is found, the function returns <i>last</i>.
+     *
+     * The function uses {@link equal_to equal_to} to compare the individual elements to <i>val</i>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value to search for in the range.
+     *
+     * @return An {@link Iterator} to the first element in the range that compares equal to <i>val</i>. If no elements
+     *		   match, the function returns <i>last</i>.
+     */
+    function find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): InputIterator;
+    /**
+     * Find element in range.
+     *
+     * Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) for which pred returns
+     * <code>true</code>. If no such element is found, the function returns <i>last</i>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible
+     *			   to <code>bool</code>. The value returned indicates whether the element is considered a match in
+     *			   the context of this function. The function shall not modify its argument.
+     *
+     * @return An {@link Iterator} to the first element in the range for which <i>pred</i> does not return
+     *		   <code>false</code>. If <i>pred</i> is <code>false</code> for all elements, the function returns
+     *		   <i>last</i>.
+     */
+    function find_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): InputIterator;
+    /**
+     * Find element in range.
+     *
+     * Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) for which pred returns
+     * <code>true</code>. If no such element is found, the function returns <i>last</i>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible
+     *			   to <code>bool</code>. The value returned indicates whether the element is considered a match in
+     *			   the context of this function. The function shall not modify its argument.
+     *
+     * @return An {@link Iterator} to the first element in the range for which <i>pred</i> returns <code>false</code>.
+     *		   If <i>pred</i> is <code>true</code> for all elements, the function returns <i>last</i>.
+     */
+    function find_if_not<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): InputIterator;
+    /**
+     * Find last subsequence in range.
+     *
+     * Searches the range [<i>first1</i>, <i>last1</i>) for the last occurrence of the sequence defined by
+     * [<i>first2</i>, <i>last2</i>), and returns an {@link Iterator} to its first element, or <i>last1,/i> if no
+     * occurrences are found.
+     *
+     * The elements in both ranges are compared sequentially using {@link equal_to}: A subsequence of
+     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is <code>true</code> for all the elements of
+     * [<i>first2</i>, <i>last2</i>).
+     *
+     * This function returns the last of such occurrences. For an algorithm that returns the first instead, see
+     * {@link search}.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
+     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
+     *				is [<i>first2</i>, <i>last2</i>).
+     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the
+     *			   same order), and returns a value convertible to <code>bool</code>. The value returned indicates
+     *			   whether the elements are considered to match in the context of this function.
+     *
+     * @return An {@link Iterator} to the first element of the last occurrence of [<i>first2</i>, <i>last2</i>) in
+     *		   [<i>first1</i>, <i>last1</i>). If the sequence is not found, the function returns ,i>last1</i>. Otherwise
+     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>last1</i>.
+     */
+    function find_end<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): Iterator1;
+    /**
+     * Find last subsequence in range.
+     *
+     * Searches the range [<i>first1</i>, <i>last1</i>) for the last occurrence of the sequence defined by
+     * [<i>first2</i>, <i>last2</i>), and returns an {@link Iterator} to its first element, or <i>last1,/i> if no
+     * occurrences are found.
+     *
+     * The elements in both ranges are compared sequentially using <i>pred</i>: A subsequence of
+     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is <code>true</code> for all the elements of
+     * [<i>first2</i>, <i>last2</i>).
+     *
+     * This function returns the last of such occurrences. For an algorithm that returns the first instead, see
+     * {@link search}.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
+     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
+     *				is [<i>first2</i>, <i>last2</i>).
+     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the
+     *			   same order), and returns a value convertible to <code>bool</code>. The value returned indicates
+     *			   whether the elements are considered to match in the context of this function.
+     *
+     * @return An {@link Iterator} to the first element of the last occurrence of [<i>first2</i>, <i>last2</i>) in
+     *		   [<i>first1</i>, <i>last1</i>). If the sequence is not found, the function returns ,i>last1</i>. Otherwise
+     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>last1</i>.
+     */
+    function find_end<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, pred: (x: T, y: T) => boolean): Iterator1;
+    /**
+     * Find element from set in range.
+     *
+     * Returns an iterator to the first element in the range [<i>first1</i>, <i>last1</i>) that matches any of the
+     * elements in [<i>first2</i>, <i>last2</i>). If no such element is found, the function returns <i>last1</i>.
+     *
+     * The elements in [<i>first1</i>, <i>last1</i>) are sequentially compared to each of the values in
+     * [<i>first2</i>, <i>last2</i>) using {@link equal_to}, until a pair matches.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
+     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
+     *				is [<i>first2</i>, <i>last2</i>).
+     *
+     * @return An {@link Iterator} to the first element in [<i>first1</i>, <i>last1</i>) that is part of
+     *		   [<i>first2</i>, <i>last2</i>). If no matches are found, the function returns <i>last1</i>.
+     */
+    function find_first_of<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): Iterator1;
+    /**
+     * Find element from set in range.
+     *
+     * Returns an iterator to the first element in the range [<i>first1</i>, <i>last1</i>) that matches any of the
+     * elements in [<i>first2</i>, <i>last2</i>). If no such element is found, the function returns <i>last1</i>.
+     *
+     * The elements in [<i>first1</i>, <i>last1</i>) are sequentially compared to each of the values in
+     * [<i>first2</i>, <i>last2</i>) using <i>pred</i>, until a pair matches.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
+     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
+     *				is [<i>first2</i>, <i>last2</i>).
+     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the
+     *			   same order), and returns a value convertible to <code>bool</code>. The value returned indicates
+     *			   whether the elements are considered to match in the context of this function.
+     *
+     * @return An {@link Iterator} to the first element in [<i>first1</i>, <i>last1</i>) that is part of
+     *		   [<i>first2</i>, <i>last2</i>). If no matches are found, the function returns <i>last1</i>.
+     */
+    function find_first_of<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, pred: (x: T, y: T) => boolean): Iterator1;
+    /**
+     * Find equal adjacent elements in range.
+     *
+     * Searches the range [<i>first</i>, <i>last</i>) for the first occurrence of two consecutive elements that match,
+     * and returns an {@link Iterator} to the first of these two elements, or <i>last</i> if no such pair is found.
+     *
+     * Two elements match if they compare equal using {@link equal_to}.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     *
+     * @return An {@link Iterator} to the first element of the first pair of matching consecutive elements in the range
+     *		   [<i>first</i>, <i>last</i>). If no such pair is found, the function returns <i>last</i>.
+     */
+    function adjacent_find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): InputIterator;
+    /**
+     * Find equal adjacent elements in range.
+     *
+     * Searches the range [<i>first</i>, <i>last</i>) for the first occurrence of two consecutive elements that match,
+     * and returns an {@link Iterator} to the first of these two elements, or <i>last</i> if no such pair is found.
+     *
+     * Two elements match if they compare equal using <i>pred</i>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element is considered a match in the
+     *			   context of this function. The function shall not modify its argument.
+     *
+     * @return An {@link Iterator} to the first element of the first pair of matching consecutive elements in the range
+     *		   [<i>first</i>, <i>last</i>). If no such pair is found, the function returns <i>last</i>.
+     */
+    function adjacent_find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (x: T, y: T) => boolean): InputIterator;
+    /**
+     * Search range for subsequence.
+     *
+     * Searches the range [<i>first1</i>, <i>last1</i>) for the first occurrence of the sequence defined by
+     * [<i>first2</i>, <i>last2</i>), and returns an iterator to its first element, or <i>last1</i> if no occurrences are
+     * found.
+     *
+     * The elements in both ranges are compared sequentially using {@link equal_to}: A subsequence of
+     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is true for <b>all</b> the elements of
+     * [<i>first2</i>, <i>last2</i>).
+     *
+     * This function returns the first of such occurrences. For an algorithm that returns the last instead, see
+     * {@link find_end}.
+     *
+     * @param first1 {@link Iterator Forward iterator} to the initial position of the searched sequence.
+     * @param last1 {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Forward iterator} to the initial position of the sequence to be searched for.
+     * @param last2 {@link Iterator Forward iterator} to the final position of the sequence to be searched for. The range
+     *				used is [<i>first2</i>, <i>last2</i>).
+     *
+     * @return An iterator to the first element of the first occurrence of [<i>first2</i>, <i>last2</i>) in <i>first1</i>
+     *		   and <i>last1</i>. If the sequence is not found, the function returns <i>last1</i>. Otherwise
+     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>first1</i>.
+     */
+    function search<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2, last2: ForwardIterator2): ForwardIterator1;
+    /**
+     * Search range for subsequence.
+     *
+     * Searches the range [<i>first1</i>, <i>last1</i>) for the first occurrence of the sequence defined by
+     * [<i>first2</i>, <i>last2</i>), and returns an iterator to its first element, or <i>last1</i> if no occurrences are
+     * found.
+     *
+     * The elements in both ranges are compared sequentially using <i>pred</i>: A subsequence of
+     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is true for <b>all</b> the elements of
+     * [<i>first2</i>, <i>last2</i>).
+     *
+     * This function returns the first of such occurrences. For an algorithm that returns the last instead, see
+     * {@link find_end}.
+     *
+     * @param first1 {@link Iterator Forward iterator} to the initial position of the searched sequence.
+     * @param last1 {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Forward iterator} to the initial position of the sequence to be searched for.
+     * @param last2 {@link Iterator Forward iterator} to the final position of the sequence to be searched for. The range
+     *				used is [<i>first2</i>, <i>last2</i>).
+     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the same
+     *			   order), and returns a value convertible to bool. The returned value indicates whether the elements are
+     *			   considered to match in the context of this function. The function shall not modify any of its
+     *			   arguments.
+     *
+     * @return An iterator to the first element of the first occurrence of [<i>first2</i>, <i>last2</i>) in
+     *		   [<i>first1</i>, <i>last1</i>). If the sequence is not found, the function returns last1. Otherwise
+     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>first1</i>.
+     */
+    function search<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2, last2: ForwardIterator2, pred: (x: T, y: T) => boolean): ForwardIterator1;
+    /**
+     * Search range for elements.
+     *
+     * Searches the range [<i>first</i>, <i>last</i>) for a sequence of <i>count</i> elements, each comparing equal to
+     * <i>val</i>.
+     *
+     * The function returns an iterator to the first of such elements, or <i>last</i> if no such sequence is found.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the searched sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param count Minimum number of successive elements to match.
+     * @param val Individual value to be compared, or to be used as argument for {@link equal_to}.
+     *
+     * @return An iterator to the first element of the sequence. If no such sequence is found, the function returns
+     *		   <i>last</i>.
+     */
+    function search_n<T, ForwardIterator extends base.IArrayIterator<T>>(first: ForwardIterator, last: ForwardIterator, count: number, val: T): ForwardIterator;
+    /**
+     * Search range for elements.
+     *
+     * Searches the range [<i>first</i>, <i>last</i>) for a sequence of <i>count</i> elements, each comparing equal to
+     * <i>val</i>.
+     *
+     * The function returns an iterator to the first of such elements, or <i>last</i> if no such sequence is found.
+     *
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the searched sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param count Minimum number of successive elements to match.
+     * @param val Individual value to be compared, or to be used as argument for <i>pred</i>.
+     * @param pred Binary function that accepts two arguments (one element from the sequence as first, and <i>val</i> as
+     *			   second), and returns a value convertible to <code>bool</code>. The value returned indicates whether the
+     *			   element is considered a match in the context of this function. The function shall not modify any of its
+     *			   arguments.
+     *
+     * @return An {@link Iterator} to the first element of the sequence. If no such sequence is found, the function
+     *		   returns <i>last</i>.
+     */
+    function search_n<T, ForwardIterator extends base.IArrayIterator<T>>(first: ForwardIterator, last: ForwardIterator, count: number, val: T, pred: (x: T, y: T) => boolean): ForwardIterator;
+    /**
+     * Return first position where two ranges differ.
+     *
+     * Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
+     * <i>first2</i>, and returns the first element of both sequences that does not match.
+     *
+     * The function returns a {@link Pair} of {@link iterators Iterator} to the first element in each range that
+     * does not match.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
+     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
+     *
+     * @return A {@link Pair}, where its members {@link Pair.first first} and {@link Pair.second second} point to the
+     *		   first element in both sequences that did not compare equal to each other. If the elements compared in
+     *		   both sequences have all matched, the function returns a {@link Pair} with {@link Pair.first first} set
+     *		   to <i>last1</i> and {@link Pair.second second} set to the element in that same relative position in the
+     *		   second sequence. If none matched, it returns {@link make_pair}(<i>first1</i>, <i>first2</i>).
+     */
+    function mismatch<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2): Pair<Iterator1, Iterator2>;
+    /**
+     * Return first position where two ranges differ.
+     *
+     * Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
+     * <i>first2</i>, and returns the first element of both sequences that does not match.
+     *
+     * The function returns a {@link Pair} of {@link iterators Iterator} to the first element in each range that
+     * does not match.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
+     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
+     * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same
+     *			   order), and returns a value convertible to <code>bool</code>. The value returned indicates whether
+     *			   the elements are considered to match in the context of this function.
+     *
+     * @return A {@link Pair}, where its members {@link Pair.first first} and {@link Pair.second second} point to the
+     *		   first element in both sequences that did not compare equal to each other. If the elements compared in
+     *		   both sequences have all matched, the function returns a {@link Pair} with {@link Pair.first first} set
+     *		   to <i>last1</i> and {@link Pair.second second} set to the element in that same relative position in the
+     *		   second sequence. If none matched, it returns {@link make_pair}(<i>first1</i>, <i>first2</i>).
+     */
+    function mismatch<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, compare: (x: T, y: T) => boolean): Pair<Iterator1, Iterator2>;
+    /**
+     * Count appearances of value in range.
+     *
+     * Returns the number of elements in the range [<i>first</i>, <i>last</i>) that compare equal to <i>val</i>.
+     *
+     * The function uses {@link equal_to} to compare the individual elements to <i>val</i>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value to match.
+     *
+     * @return The number of elements in the range [<i>first</i>, <i>last</i>) that compare equal to <i>val</i>.
+     */
+    function count<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): number;
+    /**
+     * Return number of elements in range satisfying condition.
+     *
+     * Returns the number of elements in the range [<i>first</i>, <i>last</i>) for which pred is <code>true</code>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible
+     *			   to <code>bool</code>. The value returned indicates whether the element is counted by this function.
+     *			   The function shall not modify its argument. This can either be a function pointer or a function
+     *			   object.
+     */
+    function count_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): number;
+}
+declare namespace std {
+    /**
+     * Copy range of elements.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) into the range beginning at <i>result</i>.
+     *
+     * The function returns an iterator to the end of the destination range (which points to the element following the
+     * last element copied).
+     *
+     * The ranges shall not overlap in such a way that result points to an element in the range
+     * [<i>first</i>, <i>last</i>). For such cases, see {@link copy_backward}.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position in a sequence to be copied.
+     * @param last {@link Iterator Input iterator} to the initial position in a sequence to be copied. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output iterator} to the initial position in the destination sequence. This shall not
+     *				 point to any element in the range [<i>first</i>, <i>last</i>).
+     *
+     * @return An iterator to the end of the destination range where elements have been copied.
+     */
+    function copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
+    /**
+     * Copy elements.
+     *
+     * Copies the first <i>n</i> elements from the range beginning at <i>first</i> into the range beginning at
+     * <i>result</i>.
+     *
+     * The function returns an iterator to the end of the destination range (which points to one past the last element
+     * copied).
+     *
+     * If <i>n</i> is negative, the function does nothing.
+     *
+     * If the ranges overlap, some of the elements in the range pointed by result may have undefined but valid values.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position in a sequence of at least <i>n</i> elements to
+     *				be copied. <i>InputIterator</i> shall point to a type assignable to the elements pointed by
+     *				<i>OutputIterator</i>.
+     * @param n Number of elements to copy. If this value is negative, the function does nothing.
+     * @param result {@link Iterator Output iterator} to the initial position in the destination sequence of at least
+     *				 <i>n</i> elements. This shall not point to any element in the range [<i>first</i>, last].
+     *
+     * @return An iterator to the end of the destination range where elements have been copied.
+     */
+    function copy_n<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, n: number, result: OutputIterator): OutputIterator;
+    /**
+     * Copy certain elements of range.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) for which pred returns <code>true</code> to the
+     * range beginning at <i>result</i>.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position in a sequence to be copied.
+     * @param last {@link Iterator Input iterator} to the initial position in a sequence to be copied. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output iterator} to the initial position in the destination sequence. This shall not
+     *				 point to any element in the range [<i>first</i>, <i>last</i>).
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element is to be copied (if
+     *			   <code>true</code>, it is copied). The function shall not modify any of its arguments.
+     *
+     * @return An iterator to the end of the destination range where elements have been copied.
+     */
+    function copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T) => boolean): OutputIterator;
+    /**
+     * Copy range of elements backward.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) starting from the end into the range terminating
+     * at <i>result</i>.
+     *
+     * The function returns an iterator to the first element in the destination range.
+     *
+     * The resulting range has the elements in the exact same order as [<i>first</i>, <i>last</i>). To reverse their
+     * order, see {@link reverse_copy}.
+     *
+     * The function begins by copying <code>*(last-1)</code> into <code>*(result-1)</code>, and then follows backward
+     * by the elements preceding these, until <i>first</i> is reached (and including it).
+     *
+     * The ranges shall not overlap in such a way that <i>result</i> (which is the <i>past-the-end element</i> in the
+     * destination range) points to an element in the range (first,last]. For such cases, see {@link copy}.
+     *
+     * @param first {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied.
+     * @param last {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied. The range
+     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Bidirectional iterator} to the initial position in the destination sequence. This
+     *				 shall not point to any element in the range [<i>first</i>, <i>last</i>).
+     *
+     * @return An iterator to the first element of the destination sequence where elements have been copied.
+     */
+    function copy_backward<T, BidirectionalIterator1 extends Iterator<T>, BidirectionalIterator2 extends base.ILinearIterator<T>>(first: BidirectionalIterator1, last: BidirectionalIterator1, result: BidirectionalIterator2): BidirectionalIterator2;
+    /**
+     * Fill range with value.
+     *
+     * Assigns val to all the elements in the range [<i>first</i>, <i>last</i>).
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position in a sequence of elements that support being
+     *				assigned a value of type <i>T</i>.
+     * @param last {@link Iterator Forward iterator} to the final position in a sequence of elements that support being
+     *				assigned a value of type <i>T</i>.. The range filled is [<i>first</i>, <i>last</i>), which contains
+     *				all the elements between <i>first</i> and <i>last</i>, including the element pointed by <i>first</i>
+     *				but not the element pointed by <i>last</i>.
+     * @param val Value to assign to the elements in the filled range.
+     */
+    function fill<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): void;
+    /**
+     * Fill sequence with value.
+     *
+     * Assigns <i>val</i> to the first <i>n</i> elements of the sequence pointed by <i>first</i>.
+     *
+     * @param first {@link Iterator Output iterator} to the initial position in a sequence of elements that support being
+     *				assigned a value of type <i>T</i>.
+     * @param n Number of elements to fill. If negative, the function does nothing.
+     * @param val Value to be used to fill the range.
+     *
+     * @return An iterator pointing to the element that follows the last element filled.
+     */
+    function fill_n<T, OutputIterator extends base.ILinearIterator<T>>(first: OutputIterator, n: number, val: T): OutputIterator;
+    /**
+     * Transform range.
+     *
+     * Applies <i>op</i> to each of the elements in the range [<i>first</i>, <i>last</i>) and stores the value returned
+     * by each operation in the range that begins at <i>result</i>.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position in a sequence to be transformed.
+     * @param last {@link Iterator Input iterator} to the initial position in a sequence to be transformed. The range
+     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output} iterator to the initial position of the range where the operation results are
+     *				 stored. The range includes as many elements as [<i>first</i>, <i>last</i>).
+     * @param op Unary function that accepts one element of the type pointed to by <i>InputIterator</i> as argument, and
+     *			 returns some result value convertible to the type pointed to by <i>OutputIterator</i>.
+     *
+     * @return An iterator pointing to the element that follows the last element written in the <i>result</i> sequence.
+     */
+    function transform<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, op: (val: T) => T): OutputIterator;
+    /**
+     * Transform range.
+     *
+     * Calls <i>binary_op</i> using each of the elements in the range [<i>first1</i>, <i>last1</i>) as first argument,
+     * and the respective argument in the range that begins at <i>first2</i> as second argument. The value returned by
+     * each call is stored in the range that begins at <i>result</i>.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second range. The range includes as
+     *				 many elements as [<i>first1</i>, <i>last1</i>).
+     * @param result {@link Iterator Output} iterator to the initial position of the range where the operation results are
+     *				 stored. The range includes as many elements as [<i>first1</i>, <i>last1</i>).
+     * @param binary_op Binary function that accepts two elements as argument (one of each of the two sequences), and
+     *					returns some result value convertible to the type pointed to by <i>OutputIterator</i>.
+     *
+     * @return An iterator pointing to the element that follows the last element written in the <i>result</i> sequence.
+     */
+    function transform<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, result: OutputIterator, binary_op: (x: T, y: T) => T): OutputIterator;
+    /**
+     * Generate values for range with function.
+     *
+     * Assigns the value returned by successive calls to gen to the elements in the range [<i>first</i>, <i>last</i>).
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position in a sequence.
+     * @param last {@link Iterator Forward iterator} to the final position in a sequence. The range affected is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param gen Generator function that is called with no arguments and returns some value of a type convertible to
+     *			  those pointed by the iterators.
+     */
+    function generate<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, last: ForwardIterator, gen: () => T): void;
+    /**
+     * Generate values for sequence with function.
+     *
+     * Assigns the value returned by successive calls to <i>gen</i> to the first <i>n</i> elements of the sequence
+     * pointed by <i>first</i>.
+     *
+     * @param first {@link Iterator Output iterator} to the initial position in a sequence of at least <i>n</i> elements
+     *				that support being assigned a value of the type returned by <i>gen</i>.
+     * @param n Number of values to generate. If negative, the function does nothing.
+     * @param gen Generator function that is called with no arguments and returns some value of a type convertible to
+     *			  those pointed by the iterators.
+     *
+     * @return An iterator pointing to the element that follows the last element whose value has been generated.
+     */
+    function generate_n<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, n: number, gen: () => T): ForwardIterator;
+    /**
+     * Remove consecutive duplicates in range.
+     *
+     * Removes all but the first element from every consecutive group of equivalent elements in the range
+     * [<i>first</i>, <i>last</i>).
+     *
+     * The function cannot alter the properties of the object containing the range of elements (i.e., it cannot
+     * alter the size of an array or a container): The removal is done by replacing the duplicate elements by the next
+     * element that is not a duplicate, and signaling the new size of the shortened range by returning an iterator to
+     * the element that should be considered its new past-the-last element.
+     *
+     * The relative order of the elements not removed is preserved, while the elements between the returned
+     * iterator and last are left in a valid but unspecified state.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     *
+     * @return An iterator to the element that follows the last element not removed. The range between <i>first</i> and
+     *		   this iterator includes all the elements in the sequence that were not considered duplicates.
+     */
+    function unique<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): InputIterator;
+    /**
+     * Remove consecutive duplicates in range.
+     *
+     * Removes all but the first element from every consecutive group of equivalent elements in the range
+     * [<i>first</i>, <i>last</i>).
+     *
+     * The function cannot alter the properties of the object containing the range of elements (i.e., it cannot
+     * alter the size of an array or a container): The removal is done by replacing the duplicate elements by the next
+     * element that is not a duplicate, and signaling the new size of the shortened range by returning an iterator to
+     * the element that should be considered its new past-the-last element.
+     *
+     * The relative order of the elements not removed is preserved, while the elements between the returned
+     * iterator and last are left in a valid but unspecified state.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Binary function that accepts two elements in the range as argument, and returns a value convertible
+     *			   to <code>bool</code>. The value returned indicates whether both arguments are considered equivalent
+     *			  (if <code>true</code>, they are equivalent and one of them is removed). The function shall not modify
+     *			  any of its arguments.
+     *
+     * @return An iterator to the element that follows the last element not removed. The range between <i>first</i> and
+     *		   this iterator includes all the elements in the sequence that were not considered duplicates.
+     */
+    function unique<t, InputIterator extends Iterator<t>>(first: InputIterator, last: InputIterator, pred: (left: t, right: t) => boolean): InputIterator;
+    /**
+     * Copy range removing duplicates.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
+     * consecutive duplicates (elements that compare equal to the element preceding).
+     *
+     * Only the first element from every consecutive group of equivalent elements in the range
+     * [<i>first</i>, <i>last</i>) is copied.
+     *
+     * The comparison between elements is performed by applying {@lnk equal_to}.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position in a sequence.
+     * @param last {@link Iterator Forward iterator} to the final position in a sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result Output iterator to the initial position of the range where the resulting range of values is stored.
+     *				 The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     *
+     * @return An iterator pointing to the end of the copied range, which contains no consecutive duplicates.
+     */
+    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
+    /**
+     * Copy range removing duplicates.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
+     * consecutive duplicates (elements that compare equal to the element preceding).
+     *
+     * Only the first element from every consecutive group of equivalent elements in the range
+     * [<i>first</i>, <i>last</i>) is copied.
+     *
+     * The comparison between elements is performed by applying <i>pred</i>.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position in a sequence.
+     * @param last {@link Iterator Forward iterator} to the final position in a sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result Output iterator to the initial position of the range where the resulting range of values is stored.
+     *				 The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     * @param pred Binary function that accepts two elements in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether both arguments are considered equivalent (if
+     *			   <code>true</code>, they are equivalent and one of them is removed). The function shall not modify any
+     *			   of its arguments.
+     *
+     * @return An iterator pointing to the end of the copied range, which contains no consecutive duplicates.
+     */
+    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T, y: T) => boolean): OutputIterator;
+    /**
+     * Remove value from range.
+     *
+     * Transforms the range [<i>first</i>, <i>last</i>) into a range with all the elements that compare equal to
+     * <i>val</i> removed, and returns an iterator to the new last of that range.
+     *
+     * The function cannot alter the properties of the object containing the range of elements (i.e., it cannot alter
+     * the size of an array or a container): The removal is done by replacing the elements that compare equal to
+     * <i>val</i> by the next element that does not, and signaling the new size of the shortened range by returning an
+     * iterator to the element that should be considered its new past-the-last element.
+     *
+     * The relative order of the elements not removed is preserved, while the elements between the returned iterator
+     * and last are left in a valid but unspecified state.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value to be removed.
+     */
+    function remove<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): InputIterator;
+    /**
+     * Remove elements from range.
+     *
+     * Transforms the range [<i>first</i>, <i>last</i>) into a range with all the elements for which pred returns
+     * <code>true</code> removed, and returns an iterator to the new last of that range.
+     *
+     * The function cannot alter the properties of the object containing the range of elements (i.e., it cannot
+     * alter the size of an array or a container): The removal is done by replacing the elements for which pred returns
+     * <code>true</code> by the next element for which it does not, and signaling the new size of the shortened range
+     * by returning an iterator to the element that should be considered its new past-the-last element.
+     *
+     * The relative order of the elements not removed is preserved, while the elements between the returned
+     * iterator and last are left in a valid but unspecified state.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element is to be removed (if
+     *			   <code>true</code>, it is removed). The function shall not modify its argument.
+     */
+    function remove_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (left: T) => boolean): InputIterator;
+    /**
+     * Copy range removing value.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
+     * those elements that compare equal to <i>val</i>.
+     *
+     * The resulting range is shorter than [<i>first</i>, <i>last</i>) by as many elements as matches in the sequence,
+     * which are "removed".
+     *
+     * The function uses {@link equal_to} to compare the individual elements to <i>val</i>.
+     *
+     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
+     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     * @param val Value to be removed.
+     *
+     * @return An iterator pointing to the end of the copied range, which includes all the elements in
+     *		   [<i>first</i>, <i>last</i>) except those that compare equal to <i>val</i>.
+     */
+    function remove_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, val: T): OutputIterator;
+    /**
+     * Copy range removing values.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
+     * those elements for which <i>pred</i> returns <code>true</code>.
+     *
+     * The resulting range is shorter than [<i>first</i>, <i>last</i>) by as many elements as matches, which are
+     * "removed".
+     *
+     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
+     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element is to be removed from the copy (if
+     *			   <code>true</code>, it is not copied). The function shall not modify its argument.
+     *
+     * @return An iterator pointing to the end of the copied range, which includes all the elements in
+     *		   [<i>first</i>, <i>last</i>) except those for which <i>pred</i> returns <code>true</code>.
+     */
+    function remove_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean): OutputIterator;
+    /**
+     * Replace value in range.
+     *
+     * Assigns <i>new_val</i> to all the elements in the range [<i>first</i>, <i>last</i>) that compare equal to
+     * <i>old_val</i>.
+     *
+     * The function uses {@link equal_to} to compare the individual elements to old_val.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param old_val Value to be replaced.
+     * @param new_val Replacement value.
+     */
+    function replace<T, InputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, old_val: T, new_val: T): void;
+    /**
+     * Replace value in range.
+     *
+     * Assigns <i>new_val</i> to all the elements in the range [<i>first</i>, <i>last</i>) for which pred returns
+     * <code>true</code>.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element is to be replaced (if
+     *			   <code>true</code>, it is replaced). The function shall not modify its argument.
+     * @param new_val Value to assign to replaced elements.
+     */
+    function replace_if<T, InputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean, new_val: T): void;
+    /**
+     * Copy range replacing value.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, replacing
+     * the appearances of <i>old_value</i> by <i>new_value</i>.
+     *
+     * The function uses {@link equal_to} to compare the individual elements to <i>old_value</i>.
+     *
+     * The ranges shall not overlap in such a way that result points to an element in the range
+     * [<i>first</i>, <i>last</i>).
+     *
+     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
+     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     * @param old_val Value to be replaced.
+     * @param new_val Replacement value.
+     *
+     * @return An iterator pointing to the element that follows the last element written in the result sequence.
+     */
+    function replace_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, old_val: T, new_val: T): OutputIterator;
+    /**
+     * Copy range replacing value.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, replacing
+     * those for which <i>pred</i> returns <code>true</code> by <i>new_value</i>.
+     *
+     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
+     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element is to be removed from the copy (if
+     *			   <code>true</code>, it is not copied). The function shall not modify its argument.
+     * @param new_val Value to assign to replaced values.
+     *
+     * @return An iterator pointing to the element that follows the last element written in the result sequence.
+     */
+    function replace_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean, new_val: T): OutputIterator;
+    /**
+     * Exchange values of objects pointed to by two iterators.
+     *
+     * Swaps the elements pointed to by <i>x</i> and <i>y</i>.
+     *
+     * The function calls {@link Iterator.swap} to exchange the elements.
+     *
+     * @param x {@link Iterator Forward iterator} to the objects to swap.
+     * @param y {@link Iterator Forward iterator} to the objects to swap.
+     */
+    function iter_swap<T>(x: Iterator<T>, y: Iterator<T>): void;
+    /**
+     * Exchange values of two ranges.
+     *
+     * Exchanges the values of each of the elements in the range [<i>first1</i>, <i>last1</i>) with those of their
+     * respective elements in the range beginning at <i>first2</i>.
+     *
+     * The function calls {@link Iterator.swap} to exchange the elements.
+     *
+     * @param first1 {@link Iterator Forward iterator} to the initial position of the first sequence.
+     * @param last1 {@link Iterator Forward iterator} to the final position of the first sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Forward iterator} to the initial position of the second range. The range includes as
+     *				 many elements as [<i>first1</i>, <i>last1</i>). The two ranges shall not overlap.
+     *
+     * @return An iterator to the last element swapped in the second sequence.
+     */
+    function swap_ranges<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2): ForwardIterator2;
+    /**
+     * Reverse range.
+     *
+     * Reverses the order of the elements in the range [<i>first</i>, <i>last</i>).
+     *
+     * The function calls {@link iter_swap} to swap the elements to their new locations.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     */
+    function reverse<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): void;
+    /**
+     * Copy range reversed.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, but in
+     * reverse order.
+     *
+     * @param first {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied.
+     * @param last {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied. The range
+     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the reserved range is
+     *				 stored. The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     *
+     * @return An output iterator pointing to the end of the copied range, which contains the same elements in reverse
+     *		   order.
+     */
+    function reverse_copy<T, BidirectionalIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, result: OutputIterator): OutputIterator;
+    /**
+     * Rotate left the elements in range.
+     *
+     * Rotates the order of the elements in the range [<i>first</i>, <i>last</i>), in such a way that the element
+     * pointed by middle becomes the new first element.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param middle An {@link Iterator} pointing to the element within the range [<i>first</i>, <i>last</i>) that is
+     *				 moved to the first position in the range.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     *
+     * @return An iterator pointing to the element that now contains the value previously pointed by <i>first</i>.
+     */
+    function rotate<T, InputIterator extends Iterator<T>>(first: InputIterator, middle: InputIterator, last: InputIterator): InputIterator;
+    /**
+     * Copy range rotated left.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, but
+     * rotating the order of the elements in such a way that the element pointed by <i>middle</i> becomes the first
+     * element in the resulting range.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the range to be copy-rotated.
+     * @param middle Forward iterator pointing to the element within the range [<i>first</i>, <i>last</i>) that is copied as the first element in the resulting range.
+     * @param last {@link Iterator Forward iterator} to the final positions of the range to be copy-rotated. The range
+     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   Notice that in this function, these are not consecutive parameters, but the first and <b>third</b> ones.
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the reserved range is
+     *				 stored. The pointed type shall support being assigned the value of an element in the range
+     *				 [<i>first</i>, <i>last</i>).
+     *
+     * @return An output iterator pointing to the end of the copied range.
+     */
+    function rotate_copy<T, ForwardIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: ForwardIterator, middle: ForwardIterator, last: ForwardIterator, result: OutputIterator): OutputIterator;
+    /**
+     * Randomly rearrange elements in range.
+     *
+     * Rearranges the elements in the range [<i>first</i>, <i>last</i>) randomly.
+     *
+     * The function swaps the value of each element with that of some other randomly picked element. When provided,
+     * the function gen determines which element is picked in every case. Otherwise, the function uses some unspecified
+     * source of randomness.
+     *
+     * To specify a uniform random generator, see {@link shuffle}.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     */
+    function random_shuffle<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
+    /**
+     * Randomly rearrange elements in range using generator.
+     *
+     * Rearranges the elements in the range [<i>first</i>, <i>last</i>) randomly, using <i>g</i> as uniform random
+     * number generator.
+     *
+     * The function swaps the value of each element with that of some other randomly picked element. The function
+     * determines the element picked by calling <i>g()</i>.
+     *
+     * To shuffle the elements of the range without such a generator, see {@link random_shuffle} instead.
+     *
+     * <h5> Note </h5>
+     * Using random generator engine is not implemented yet.
+     *
+     * @param first An {@link Iterator} to the initial position in a sequence.
+     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
+     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			  <i>first</i> but not the element pointed by <i>last</i>.
+     */
+    function shuffle<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
+}
+declare namespace std {
+    /**
+     * Sort elements in range.
+     *
+     * Sorts the elements in the range [<i>first</i>, <i>last</i>) into ascending order. The elements are compared
+     * using {@link less}.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
+     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
+     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
+     *			  <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
+     *			  {@link Iterator.swap swap} is properly defined.
+     */
+    function sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
+    /**
+     * Sort elements in range.
+     *
+     * Sorts the elements in the range [<i>first</i>, <i>last</i>) into specific order. The elements are compared
+     * using <i>compare</i>.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
+     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
+     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
+     *			  <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
+     *			  {@link Iterator.swap swap} is properly defined.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *		  convertible to <code>boolean</code>. The value returned indicates whether the element passed as first
+     *		  argument is considered to go before the second in the specific strict weak ordering it defines. The
+     *		  function shall not modify any of its arguments. This can either be a function pointer or a function
+     *		  object.
+     */
+    function sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (left: T, right: T) => boolean): void;
+    /**
+     * Partially sort elements in range.
+     *
+     * Rearranges the elements in the range [<i>first</i>, <i>last</i>), in such a way that the elements before
+     * <i>middle</i> are the smallest elements in the entire range and are sorted in ascending order, while the remaining
+     * elements are left without any specific order.
+     *
+     * The elements are compared using {@link less}.
+     *
+     * @param last {@link IArrayIterator Random-access iterator} to the first position of the sequence to be sorted.
+     * @param middle {@link IArrayIterator Random-access iterator} pointing to the element within the range [<i>first</i>, <i>last</i>) that is used as the upper boundary of the elements that are fully sorted.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
+     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
+     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
+     *			  <i>last</i>.
+     */
+    function partial_sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, middle: RandomAccessIterator, last: RandomAccessIterator): void;
+    /**
+     * Partially sort elements in range.
+     *
+     * Rearranges the elements in the range [<i>first</i>, <i>last</i>), in such a way that the elements before
+     * <i>middle</i> are the smallest elements in the entire range and are sorted in ascending order, while the remaining
+     * elements are left without any specific order.
+     *
+     * The elements are compared using <i>comp</i>.
+     *
+     * @param last {@link IArrayIterator Random-access iterator} to the first position of the sequence to be sorted.
+     * @param middle {@link IArrayIterator Random-access iterator} pointing to the element within the range [<i>first</i>, <i>last</i>) that is used as the upper boundary of the elements that are fully sorted.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
+     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
+     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
+     *			  <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
+     *				  first argument is considered to go before the second in the specific strict weak ordering it
+     *				  defines. The function shall not modify any of its arguments.
+     */
+    function partial_sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, middle: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
+    /**
+     * Copy and partially sort range.
+     *
+     * Copies the smallest  elements in the range [<i>first</i>, <i>last</i>) to
+     * [<i>result_first</i>, <i>result_last</i>), sorting the elements copied. The number of elements copied is the same
+     * as the {@link distance} between <i>result_first</i> and <i>result_last</i> (unless this is more than the amount of
+     * elements in [<i>first</i>, <i>last</i>)).
+     *
+     * The range [<i>first</i>, <i>last</i>) is not modified.
+     *
+     * The elements are compared using {@link less}.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position of the sequence to copy from.
+     * @param last {@link Iterator Input iterator} to the final position of the sequence to copy from. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   <i>InputIterator</i> shall point to a type assignable to the elements pointed by
+     *			   <i>RandomAccessIterator</i>.
+     * @param result_first {@link Iterator Random-access iterator} to the initial position of the destination sequence.
+     * @param result_last {@link Iterator Random-access iterator} to the final position of the destination sequence.
+     *					  The range used is [<i>result_first</i>, <i>result_last</i>).
+     * @param compare Binary function that accepts two elements in the result range as arguments, and returns a value
+     *				  convertible to <code>bool</code>. The value returned indicates whether the element passed as first
+     *				  argument is considered to go before the second in the specific <i>strict weak ordering</i> it
+     *				  defines. The function shall not modify any of its arguments.
+     *
+     * @return An iterator pointing to the element that follows the last element written in the result sequence.
+     */
+    function partial_sort_copy<T, InputIterator extends Iterator<T>, RandomAccessIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result_first: RandomAccessIterator, result_last: RandomAccessIterator): RandomAccessIterator;
+    /**
+     * Copy and partially sort range.
+     *
+     * Copies the smallest (or largest) elements in the range [<i>first</i>, <i>last</i>) to
+     * [<i>result_first</i>, <i>result_last</i>), sorting the elements copied. The number of elements copied is the same
+     * as the {@link distance} between <i>result_first</i> and <i>result_last</i> (unless this is more than the amount of
+     * elements in [<i>first</i>, <i>last</i>)).
+     *
+     * The range [<i>first</i>, <i>last</i>) is not modified.
+     *
+     * The elements are compared using <i>compare</i>.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position of the sequence to copy from.
+     * @param last {@link Iterator Input iterator} to the final position of the sequence to copy from. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   <i>InputIterator</i> shall point to a type assignable to the elements pointed by
+     *			   <i>RandomAccessIterator</i>.
+     * @param result_first {@link Iterator Random-access iterator} to the initial position of the destination sequence.
+     * @param result_last {@link Iterator Random-access iterator} to the final position of the destination sequence.
+     *					  The range used is [<i>result_first</i>, <i>result_last</i>).
+     * @param compare Binary function that accepts two elements in the result range as arguments, and returns a value
+     *				  convertible to <code>bool</code>. The value returned indicates whether the element passed as first
+     *				  argument is considered to go before the second in the specific <i>strict weak ordering</i> it
+     *				  defines. The function shall not modify any of its arguments.
+     *
+     * @return An iterator pointing to the element that follows the last element written in the result sequence.
+     */
+    function partial_sort_copy<T, InputIterator extends Iterator<T>, RandomAccessIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result_first: RandomAccessIterator, result_last: RandomAccessIterator, compare: (x: T, y: T) => boolean): RandomAccessIterator;
+    /**
+     * Check whether range is sorted.
+     *
+     * Returns <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order.
+     *
+     * The elements are compared using {@link less}.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *
+     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order,
+     *		   <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less than two elements,
+     *		   the function always returns <code>true</code>.
+     */
+    function is_sorted<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): boolean;
+    /**
+     * Check whether range is sorted.
+     *
+     * Returns <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order.
+     *
+     * The elements are compared using <i>compare</i>.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
+     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
+     *				  considered to go before the second in the specific strict weak ordering it defines. The function
+     *				  shall not modify any of its arguments.
+     *
+     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order,
+     *		   <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less than two elements,
+     *		   the function always returns <code>true</code>.
+     */
+    function is_sorted<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): boolean;
+    /**
+     * Find first unsorted element in range.
+     *
+     * Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which does not follow an
+     * ascending order.
+     *
+     * The range between <i>first</i> and the iterator returned {@link is_sorted is sorted}.
+     *
+     * If the entire range is sorted, the function returns <i>last</i>.
+     *
+     * The elements are compared using {@link equal_to}.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
+     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
+     *				  considered to go before the second in the specific strict weak ordering it defines. The function
+     *				  shall not modify any of its arguments.
+     *
+     * @return An iterator to the first element in the range which does not follow an ascending order, or <i>last</i> if
+     *		   all elements are sorted or if the range contains less than two elements.
+     */
+    function is_sorted_until<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): ForwardIterator;
+    /**
+     * Find first unsorted element in range.
+     *
+     * Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which does not follow an
+     * ascending order.
+     *
+     * The range between <i>first</i> and the iterator returned {@link is_sorted is sorted}.
+     *
+     * If the entire range is sorted, the function returns <i>last</i>.
+     *
+     * The elements are compared using <i>compare</i>.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
+     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
+     *				  considered to go before the second in the specific strict weak ordering it defines. The function
+     *				  shall not modify any of its arguments.
+     *
+     * @return An iterator to the first element in the range which does not follow an ascending order, or <i>last</i> if
+     *		   all elements are sorted or if the range contains less than two elements.
+     */
+    function is_sorted_until<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): ForwardIterator;
+}
+declare namespace std {
+    /**
+     * Make heap from range.
+     *
+     * Rearranges the elements in the range [<i>first</i>, <i>last</i>) in such a way that they form a heap.
+     *
+     * A heap is a way to organize the elements of a range that allows for fast retrieval of the element with the
+     * highest value at any moment (with {@link pop_heap}), even repeatedly, while allowing for fast insertion of new
+     * elements (with {@link push_heap}).
+     *
+     * The element with the highest value is always pointed by first. The order of the other elements depends on the
+     * particular implementation, but it is consistent throughout all heap-related functions of this header.
+     *
+     * The elements are compared using {@link less}: The element with the highest value is an element for which this
+     * would return false when compared to every other element in the range.
+     *
+     * The standard container adaptor {@link PriorityQueue} calls {@link make_heap}, {@link push_heap} and
+     * {@link pop_heap} automatically to maintain heap properties for a container.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be
+     *				transformed into a heap.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be transformed
+     *			   into a heap. The range used is [<i>first</i>, <i>last</i>), which contains all the elements between
+     *			   <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed
+     *			   by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
+     *			   {@link Iterator.swap swap} is properly defined.
+     */
+    function make_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
+    /**
+     * Make heap from range.
+     *
+     * Rearranges the elements in the range [<i>first</i>, <i>last</i>) in such a way that they form a heap.
+     *
+     * A heap is a way to organize the elements of a range that allows for fast retrieval of the element with the
+     * highest value at any moment (with {@link pop_heap}), even repeatedly, while allowing for fast insertion of new
+     * elements (with {@link push_heap}).
+     *
+     * The element with the highest value is always pointed by first. The order of the other elements depends on the
+     * particular implementation, but it is consistent throughout all heap-related functions of this header.
+     *
+     * The elements are compared using <i>compare</i>: The element with the highest value is an element for which this
+     * would return false when compared to every other element in the range.
+     *
+     * The standard container adaptor {@link PriorityQueue} calls {@link make_heap}, {@link push_heap} and
+     * {@link pop_heap} automatically to maintain heap properties for a container.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be
+     *				transformed into a heap.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be transformed
+     *			   into a heap. The range used is [<i>first</i>, <i>last</i>), which contains all the elements between
+     *			   <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed
+     *			   by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
+     *			   {@link Iterator.swap swap} is properly defined.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
+     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
+     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
+     *				  function object.
+     */
+    function make_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
+    /**
+     * Push element into heap range.
+     *
+     * Given a heap in the range [<i>first</i>, <i>last</i> - 1), this function extends the range considered a heap to
+     * [<i>first</i>, <i>last</i>) by placing the value in (<i>last</i> - 1) into its corresponding location within it.
+     *
+     *
+     * A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
+     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
+     *
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the new heap range, including
+     *				the pushed element.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the new heap range, including
+     *			   the pushed element.  The range used is [<i>first</i>, <i>last</i>), which contains all the elements
+     *			   between <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element
+     *			   pointed by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
+     *			   {@link Iterator.swap swap} is properly defined.
+     */
+    function push_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
+    /**
+     * Push element into heap range.
+     *
+     * Given a heap in the range [<i>first</i>, <i>last</i> - 1), this function extends the range considered a heap to
+     * [<i>first</i>, <i>last</i>) by placing the value in (<i>last</i> - 1) into its corresponding location within it.
+     *
+     * A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
+     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
+     *
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the new heap range, including
+     *				the pushed element.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the new heap range, including
+     *			   the pushed element.  The range used is [<i>first</i>, <i>last</i>), which contains all the elements
+     *			   between <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element
+     *			   pointed by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
+     *			   {@link Iterator.swap swap} is properly defined.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
+     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
+     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
+     *				  function object.
+     */
+    function push_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
+    /**
+     * Pop element from heap range.
+     *
+     * Rearranges the elements in the heap range [<i>first</i>, <i>last</i>) in such a way that the part considered a
+     * heap is shortened by one: The element with the highest value is moved to (<i>last</i> - 1).
+     *
+     * While the element with the highest value is moved from first to (<i>last</i> - 1) (which now is out of the
+     * heap), the other elements are reorganized in such a way that the range [<i>first</i>, <i>last</i> - 1) preserves
+     * the properties of a heap.
+     *
+     * A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
+     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the heap to be shrank by one.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the heap to be shrank by one.
+     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     */
+    function pop_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
+    /**
+     * Pop element from heap range.
+     *
+     * Rearranges the elements in the heap range [<i>first</i>, <i>last</i>) in such a way that the part considered a
+     * heap is shortened by one: The element with the highest value is moved to (<i>last</i> - 1).
+     *
+     * While the element with the highest value is moved from first to (<i>last</i> - 1) (which now is out of the
+     * heap), the other elements are reorganized in such a way that the range [<i>first</i>, <i>last</i> - 1) preserves
+     * the properties of a heap.
+     *
+     * A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
+     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the heap to be shrank by one.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the heap to be shrank by one.
+     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
+     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
+     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
+     *				  function object.
+     */
+    function pop_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
+    /**
+     * Test if range is heap.
+     *
+     * Returns true if the range [<i>first</i>, <i>last</i>) forms a heap, as if constructed with {@link make_heap}.
+     *
+     * The elements are compared using {@link less}.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     *
+     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is a heap (as if constructed with
+     *		   {@link make_heap}), <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less
+     *		   than two elements, the function always returns <code>true</code>.
+     */
+    function is_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): boolean;
+    /**
+     * Test if range is heap.
+     *
+     * Returns true if the range [<i>first</i>, <i>last</i>) forms a heap, as if constructed with {@link make_heap}.
+     *
+     * The elements are compared using <i>compare</i>.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
+     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
+     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
+     *				  function object.
+     *
+     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is a heap (as if constructed with
+     *		   {@link make_heap}), <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less
+     *		   than two elements, the function always returns <code>true</code>.
+     */
+    function is_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): boolean;
+    /**
+     * Find first element not in heap order.
+     *
+     * Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which is not in a valid
+     * position if the range is considered a heap (as if constructed with {@link make_heap}).
+     *
+     * The range between first and the iterator returned is a heap.
+     *
+     * If the entire range is a valid heap, the function returns <i>last</i>.
+     *
+     * The elements are compared using {@link less}.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     */
+    function is_heap_until<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): RandomAccessIterator;
+    /**
+     * Find first element not in heap order.
+     *
+     * Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which is not in a valid
+     * position if the range is considered a heap (as if constructed with {@link make_heap}).
+     *
+     * The range between first and the iterator returned is a heap.
+     *
+     * If the entire range is a valid heap, the function returns <i>last</i>.
+     *
+     * The elements are compared using {@link less}.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
+     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
+     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
+     *				  function object.
+     */
+    function is_heap_until<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): RandomAccessIterator;
+    /**
+     * Sort elements of heap.
+     *
+     * Sorts the elements in the heap range [<i>first</i>, <i>last</i>) into ascending order.
+     *
+     * The elements are compared using {@link less}, which shall be the same as used to construct the heap.
+     *
+     * The range loses its properties as a heap.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
+     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     */
+    function sort_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
+    /**
+     * Sort elements of heap.
+     *
+     * Sorts the elements in the heap range [<i>first</i>, <i>last</i>) into ascending order.
+     *
+     * The elements are compared using <i>compare</i>, which shall be the same as used to construct the heap.
+     *
+     * The range loses its properties as a heap.
+     *
+     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
+     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
+     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
+     *			   is properly defined.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
+     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
+     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
+     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
+     *				  function object.
+     */
+    function sort_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
+}
+declare namespace std {
+    /**
+     * Return iterator to lower bound.
+     *
+     * Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which does not
+     * compare less than <i>val</i>.
+     *
+     * The elements are compared using {@link less}. The elements in the range shall already be {@link is_sorted sorted}
+     * according to this same criterion ({@link less}), or at least {@link is_partitioned partitioned} with respect to
+     * <i>val</i>.
+     *
+     * The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
+     * range, which is specially efficient for {@link IArrayIterator random-access iterators}.
+     *
+     * Unlike {@link upper_bound}, the value pointed by the iterator returned by this function may also be equivalent
+     * to <i>val</i>, and not only greater.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
+     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
+     *
+     * @return An iterator to the lower bound of <i>val</i> in the range. If all the element in the range compare less than
+     *		   <i>val</i>, the function returns <i>last</i>.
+     */
+    function lower_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): ForwardIterator;
+    /**
+     * Return iterator to lower bound.
+     *
+     * Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which does not
+     * compare less than <i>val</i>.
+     *
+     * The elements are compared using <i>compare</i>. The elements in the range shall already be
+     * {@link is_sorted sorted} according to this same criterion (<i>compare</i>), or at least
+     * {@link is_partitioned partitioned} with respect to <i>val</i>.
+     *
+     * The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
+     * range, which is specially efficient for {@link IArrayIterator random-access iterators}.
+     *
+     * Unlike {@link upper_bound}, the value pointed by the iterator returned by this function may also be equivalent
+     * to <i>val</i>, and not only greater.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range.
+     * @param compare Binary function that accepts two arguments (the first of the type pointed by <i>ForwardIterator</i>,
+     *				  and the second, always <i>val</i>), and returns a value convertible to <code>bool</code>. The value
+     *				  returned indicates whether the first argument is considered to go before the second. The function
+     *				  shall not modify any of its arguments.
+     *
+     * @return An iterator to the lower bound of <i>val</i> in the range. If all the element in the range compare less than
+     *		   <i>val</i>, the function returns <i>last</i>.
+     */
+    function lower_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): ForwardIterator;
+    /**
+     * Return iterator to upper bound.
+     *
+     * Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which compares
+     * greater than <i>val</i>.
+     *
+     * The elements are compared using {@link less}. The elements in the range shall already be {@link is_sorted sorted}
+     * according to this same criterion ({@link less}), or at least {@link is_partitioned partitioned} with respect to
+     * <i>val</i>.
+     *
+     * The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
+     * range, which is specially efficient for {@link IArrayIterator random-access iterators}.
+     *
+     * Unlike {@link lower_bound}, the value pointed by the iterator returned by this function cannot be equivalent to
+     * <i>val</i>, only greater.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
+     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
+     *
+     * @return An iterator to the upper bound of <i>val</i> in the range. If no element in the range comparse greater than
+     *		   <i>val</i>, the function returns <i>last</i>.
+     */
+    function upper_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): ForwardIterator;
+    /**
+     * Return iterator to upper bound.
+     *
+     * Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which compares
+     * greater than <i>val</i>.
+     *
+     * The elements are compared using <i>compare</i>. The elements in the range shall already be
+     * {@link is_sorted sorted} according to this same criterion (<i>compare</i>), or at least
+     * {@link is_partitioned partitioned} with respect to <i>val</i>.
+     *
+     * The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
+     * range, which is specially efficient for {@link IArrayIterator random-access iterators}.
+     *
+     * Unlike {@link lower_bound}, the value pointed by the iterator returned by this function cannot be equivalent to
+     * <i>val</i>, only greater.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range.
+     * @param compare Binary function that accepts two arguments (the first of the type pointed by <i>ForwardIterator</i>,
+     *				  and the second, always <i>val</i>), and returns a value convertible to <code>bool</code>. The value
+     *				  returned indicates whether the first argument is considered to go before the second. The function
+     *				  shall not modify any of its arguments.
+     *
+     * @return An iterator to the upper bound of <i>val</i> in the range. If no element in the range comparse greater than
+     *		   <i>val</i>, the function returns <i>last</i>.
+     */
+    function upper_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): ForwardIterator;
+    /**
+     * Get subrange of equal elements.
+     *
+     * Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
+     * values equivalent to <i>val</i>.
+     *
+     * The elements are compared using {@link less}. Two elements, <i>ax/i> and <i>y</i> are considered equivalent
+     * <code>if (!less(x, y) && !less(y, x))</code>.
+     *
+     * The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
+     * ({@link less}), or at least {@link is_partitioned partitioned} with respect to <i>val</i>.
+     *
+     * If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
+     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
+     * greater than all the elements in the range.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
+     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
+     *
+     * @return A {@link Pair} object, whose member {@link Pair.first} is an iterator to the lower bound of the subrange of
+     *		   equivalent values, and {@link Pair.second} its upper bound. The values are the same as those that would be
+     *		   returned by functions {@link lower_bound} and {@link upper_bound} respectively.
+     */
+    function equal_range<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): Pair<ForwardIterator, ForwardIterator>;
+    /**
+     * Get subrange of equal elements.
+     *
+     * Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
+     * values equivalent to <i>val</i>.
+     *
+     * The elements are compared using <i>compare</i>. Two elements, <i>ax/i> and <i>y</i> are considered equivalent
+     * <code>if (!compare(x, y) && !compare(y, x))</code>.
+     *
+     * The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
+     * (<i>compare</i>), or at least {@link is_partitioned partitioned} with respect to <i>val</i>.
+     *
+     * If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
+     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
+     * greater than all the elements in the range.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range.
+     * @param compare Binary function that accepts two arguments of the type pointed by <i>ForwardIterator</i> (and of type
+     *				  <i>T</i>), and returns a value convertible to <code>bool</code>. The value returned indicates whether
+     *				  the first argument is considered to go before the second. The function shall not modify any of its
+     *				  arguments.
+     *
+     * @return A {@link Pair} object, whose member {@link Pair.first} is an iterator to the lower bound of the subrange of
+     *		   equivalent values, and {@link Pair.second} its upper bound. The values are the same as those that would be
+     *		   returned by functions {@link lower_bound} and {@link upper_bound} respectively.
+     */
+    function equal_range<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): Pair<ForwardIterator, ForwardIterator>;
+    /**
+     * Get subrange of equal elements.
+     *
+     * Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
+     * values equivalent to <i>val</i>.
+     *
+     * The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!less(x, y) && !less(y, x))</code>.
+     *
+     * The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
+     * ({@link less}), or at least {@link is_partitioned partitioned} with respect to <i>val</i>.
+     *
+     * If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
+     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
+     * greater than all the elements in the range.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
+     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
+     *
+     * @return <code>true</code> if an element equivalent to <i>val</i> is found, and <code>false</code> otherwise.
+     */
+    function binary_search<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): boolean;
+    /**
+     * Get subrange of equal elements.
+     *
+     * Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
+     * values equivalent to <i>val</i>.
+     *
+     * The elements are compared using {<i>compare</i>}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!compare(x, y) && !compare(y, x))</code>.
+     *
+     * The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
+     * (<i>compare</i>), or at least {@link is_partitioned partitioned} with respect to <i>val</i>.
+     *
+     * If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
+     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
+     * greater than all the elements in the range.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
+     *				{@link is_partitioned partitioned}) sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
+     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
+     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
+     *			   <i>first</i> but not the element pointed by <i>last</i>.
+     * @param val Value of the lower bound to search for in the range.
+     * @param compare Binary function that accepts two arguments of the type pointed by <i>ForwardIterator</i> (and of type
+     *				  <i>T</i>), and returns a value convertible to <code>bool</code>. The value returned indicates whether
+     *				  the first argument is considered to go before the second. The function shall not modify any of its
+     *				  arguments.
+     *
+     * @return <code>true</code> if an element equivalent to <i>val</i> is found, and <code>false</code> otherwise.
+     */
+    function binary_search<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): boolean;
+}
+declare namespace std {
+    /**
+     * Test whether range is partitioned.
+     *
+     * Returns <code>true</code> if all the elements in the range [<i>first</i>, <i>last</i>) for which <i>pred</i>
+     * returns <code>true</code> precede those for which it returns <code>false</code>.
+     *
+     * If the range is {@link Container.empty empty}, the function returns <code>true</code>.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position of the sequence.
+     * @param last {@link Iterator Input iterator} to the final position of the sequence. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element belongs to the first group (if
+     *			   <code>true</code>, the element is expected before all the elements for which it returns
+     *			   <code>false</code>). The function shall not modify its argument.
+     *
+     * @return <code>true</code> if all the elements in the range [<i>first</i>, <i>last</i>) for which <i>pred</i> returns
+     *		   <code>true</code> precede those for which it returns <code>false</code>. Otherwise it returns
+     *		   <code>false</code>. If the range is {@link Container.empty empty}, the function returns <code>true</code>.
+     */
+    function is_partitioned<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (x: T) => boolean): boolean;
+    /**
+     * Partition range in two.
+     *
+     * Rearranges the elements from the range [<i>first</i>, <i>last</i>), in such a way that all the elements for
+     * which <i>pred</i> returns <code>true</code> precede all those for which it returns <code>false</code>. The iterator
+     * returned points to the first element of the second group.
+     *
+     * The relative ordering within each group is not necessarily the same as before the call. See
+     * {@link stable_partition} for a function with a similar behavior but with stable ordering within each group.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the sequence to partition.
+     * @param last {@link Iterator Forward iterator} to the final position of the sequence to partition. The range used is
+     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element belongs to the first group (if
+     *			   <code>true</code>, the element is expected before all the elements for which it returns
+     *			   <code>false</code>). The function shall not modify its argument.
+     *
+     * @return An iterator that points to the first element of the second group of elements (those for which <i>pred</i>
+     *		   returns <code>false</code>), or <i>last</i> if this group is {@link Container.empty empty}.
+     */
+    function partition<T, BidirectionalIterator extends Iterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, pred: (x: T) => boolean): BidirectionalIterator;
+    /**
+     * Partition range in two - stable ordering.
+     *
+     * Rearranges the elements in the range [<i>first</i>, <i>last</i>), in such a way that all the elements for which
+     * <i>pred</i> returns <code>true</code> precede all those for which it returns <code>false</code>, and, unlike
+     * function {@link partition}, the relative order of elements within each group is preserved.
+     *
+     * This is generally implemented using an internal temporary buffer.
+     *
+     * @param first {@link Iterator Bidirectional iterator} to the initial position of the sequence to partition.
+     * @param last {@link Iterator Bidirectional iterator} to the final position of the sequence to partition. The range
+     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element belongs to the first group (if
+     *			   <code>true</code>, the element is expected before all the elements for which it returns
+     *			   <code>false</code>). The function shall not modify its argument.
+     *
+     * @return An iterator that points to the first element of the second group of elements (those for which <i>pred</i>
+     *		   returns <code>false</code>), or <i>last</i> if this group is {@link Container.empty empty}.
+     */
+    function stable_partition<T, BidirectionalIterator extends Iterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, pred: (x: T) => boolean): BidirectionalIterator;
+    /**
+     * Partition range into two.
+     *
+     * Copies the elements in the range [<i>first</i>, <i>last</i>) for which <i>pred</i> returns <code>true</code>
+     * into the range pointed by <i>result_true</i>, and those for which it does not into the range pointed by
+     * <i>result_false</i>.
+     *
+     * @param first {@link Iterator Input iterator} to the initial position of the range to be copy-partitioned.
+     * @param last {@link Iterator Input iterator} to the final position of the range to be copy-partitioned. The range
+     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
+     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param result_true {@link Iterator Output iterator} to the initial position of the range where the elements for
+     *					  which <i>pred</i> returns <code>true</code> are stored.
+     * @param result_false {@link Iterator Output iterator} to the initial position of the range where the elements for
+     *					   which <i>pred</i> returns <code>false</code> are stored.
+     * @param pred Unary function that accepts an element pointed by <i>InputIterator</i> as argument, and returns a value
+     *			   convertible to <code>bool</code>. The value returned indicates on which result range the element is
+     *			   copied. The function shall not modify its argument.
+     *
+     * @return A {@link Pair} of iterators with the end of the generated sequences pointed by <i>result_true</i> and
+     *		   <i>result_false</i>, respectivelly. Its member {@link Pair.first first} points to the element that follows
+     *		   the last element copied to the sequence of elements for which <i>pred</i> returned <code>true</code>. Its
+     *		   member {@link Pair.second second} points to the element that follows the last element copied to the sequence
+     *		   of elements for which <i>pred</i> returned <code>false</code>.
+     */
+    function partition_copy<T, InputIterator extends Iterator<T>, OutputIterator1 extends base.ILinearIterator<T>, OutputIterator2 extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result_true: OutputIterator1, result_false: OutputIterator2, pred: (val: T) => T): Pair<OutputIterator1, OutputIterator2>;
+    /**
+     * Get partition point.
+     *
+     * Returns an iterator to the first element in the partitioned range [<i>first</i>, <i>last</i>) for which
+     * <i>pred</i> is not <code>true</code>, indicating its partition point.
+     *
+     * The elements in the range shall already {@link is_partitioned be partitioned}, as if {@link partition} had been
+     * called with the same arguments.
+     *
+     * The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
+     * range, which is specially efficient for {@link Iteartor random-access iterators}.
+     *
+     * @param first {@link Iterator Forward iterator} to the initial position of the partitioned sequence.
+     * @param last {@link Iterator Forward iterator} to the final position of the partitioned sequence. The range checked
+     *		  is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> an <i>last</i>,
+     *		  including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
+     *			   <code>bool</code>. The value returned indicates whether the element goes before the partition point (if
+     *			   <code>true</code>, it goes before; if <code>false</code> goes at or after it). The function shall not
+     *			   modify its argument.
+     *
+     * @return An iterator to the first element in the partitioned range [<i>first</i>, <i>last</i>) for which <i>pred</i>
+     *		   is not <code>true</code>, or <i>last</i> if it is not <code>true</code> for any element.
+     */
+    function partition_point<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, pred: (x: T) => boolean): ForwardIterator;
+}
+declare namespace std {
+    /**
+     * Merge sorted ranges.
+     *
+     * Combines the elements in the sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>), into
+     * a new range beginning at <i>result</i> with all its elements sorted.
+     *
+     * The elements are compared using {@link less}. The elements in both ranges shall already be ordered according to
+     * this same criterion ({@link less}). The resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting combined
+     *				 range is stored. Its size is equal to the sum of both ranges above.
+     *
+     * @return An iterator pointing to the past-the-end element in the resulting sequence.
+     */
+    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    /**
+     * Merge sorted ranges.
+     *
+     * Combines the elements in the sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>), into
+     * a new range beginning at <i>result</i> with all its elements sorted.
+     *
+     * The elements are compared using {@link less}. The elements in both ranges shall already be ordered according to
+     * this same criterion (<i>compare</i>). The resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting combined
+     *				 range is stored. Its size is equal to the sum of both ranges above.
+     * @param compare Binary function that accepts two arguments of the types pointed by the iterators, and returns a value
+     *				  convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
+     *				  function shall not modify any of its arguments.
+     *
+     * @return An iterator pointing to the past-the-end element in the resulting sequence.
+     */
+    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    /**
+     * Merge consecutive sorted ranges.
+     *
+     * Merges two consecutive sorted ranges: [<i>first</i>, <i>middle</i>) and [<i>middle</i>, <i>last</i>), putting
+     * the result into the combined sorted range [<i>first</i>, <i>last</i>).
+     *
+     * The elements are compared using {@link less}. The elements in both ranges shall already be ordered according to
+     * this same criterion ({@link less}). The resulting range is also sorted according to this.
+     *
+     * The function preserves the relative order of elements with equivalent values, with the elements in the first
+     * range preceding those equivalent in the second.
+     *
+     * @param first {@link Iterator Bidirectional iterator} to the initial position in the first sorted sequence to merge.
+     *				This is also the initial position where the resulting merged range is stored.
+     * @param middle {@link Iterator Bidirectional iterator} to the initial position of the second sorted sequence, which
+     *				 because both sequences must be consecutive, matches the <i>past-the-end</i> position of the first
+     *				 sequence.
+     * @param last {@link Iterator Bidirectional iterator} to the <i>past-the-end</i> position of the second sorted
+     *			   sequence. This is also the <i>past-the-end</i> position of the range where the resulting merged range is
+     *			   stored.
+     */
+    function inplace_merge<T, BidirectionalIterator extends Iterator<T>>(first: BidirectionalIterator, middle: BidirectionalIterator, last: BidirectionalIterator): void;
+    /**
+     * Merge consecutive sorted ranges.
+     *
+     * Merges two consecutive sorted ranges: [<i>first</i>, <i>middle</i>) and [<i>middle</i>, <i>last</i>), putting
+     * the result into the combined sorted range [<i>first</i>, <i>last</i>).
+     *
+     * The elements are compared using <i>compare</i>. The elements in both ranges shall already be ordered according
+     * to this same criterion (<i>compare</i>). The resulting range is also sorted according to this.
+     *
+     * The function preserves the relative order of elements with equivalent values, with the elements in the first
+     * range preceding those equivalent in the second.
+     *
+     * @param first {@link Iterator Bidirectional iterator} to the initial position in the first sorted sequence to merge.
+     *				This is also the initial position where the resulting merged range is stored.
+     * @param middle {@link Iterator Bidirectional iterator} to the initial position of the second sorted sequence, which
+     *				 because both sequences must be consecutive, matches the <i>past-the-end</i> position of the first
+     *				 sequence.
+     * @param last {@link Iterator Bidirectional iterator} to the <i>past-the-end</i> position of the second sorted
+     *			   sequence. This is also the <i>past-the-end</i> position of the range where the resulting merged range is
+     *			   stored.
+     * @param compare Binary function that accepts two arguments of the types pointed by the iterators, and returns a value
+     *				  convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
+     *				  function shall not modify any of its arguments.
+     */
+    function inplace_merge<T, BidirectionalIterator extends base.ILinearIterator<T>>(first: BidirectionalIterator, middle: BidirectionalIterator, last: BidirectionalIterator, compare: (x: T, y: T) => boolean): void;
+    /**
+     * Test whether sorted range includes another sorted range.
+     *
+     * Returns <code>true</code> if the sorted range [<i>first1</i>, <i>last1</i>) contains all the elements in the
+     * sorted range [<i>first2</i>, <i>last2</i>).
+     *
+     * The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!less(x, y) && !less(y, x))</code>.
+     *
+     * The elements in the range shall already be ordered according to this same criterion ({@link less}).
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence (which is tested on
+     *				whether it contains the second sequence). The range used is [<i>first1</i>, <i>last1</i>), which
+     *				contains all the elements between <i>first1</i> and <i>last1</i>, including the element pointed by
+     *				<i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. (which is tested
+     *				on whether it is contained in the first sequence). The range used is [<i>first2</i>, <i>last2</i>).
+     *
+     * @return <code>true</code> if every element in the range [<i>first2</i>, <i>last2</i>) is contained in the range
+     *		   [<i>first1</i>, <i>last1</i>), <code>false</code> otherwise. If [<i>first2</i>, <i>last2</i>) is an empty
+     *		   range, the function returns <code>true</code>.
+     */
+    function includes<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2): boolean;
+    /**
+     * Test whether sorted range includes another sorted range.
+     *
+     * Returns <code>true</code> if the sorted range [<i>first1</i>, <i>last1</i>) contains all the elements in the
+     * sorted range [<i>first2</i>, <i>last2</i>).
+     *
+     * The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!compare(x, y) && !compare(y, x))</code>.
+     *
+     * The elements in the range shall already be ordered according to this same criterion (<i>compare</i>).
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence (which is tested on
+     *				whether it contains the second sequence). The range used is [<i>first1</i>, <i>last1</i>), which
+     *				contains all the elements between <i>first1</i> and <i>last1</i>, including the element pointed by
+     *				<i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. (which is tested
+     *				on whether it is contained in the first sequence). The range used is [<i>first2</i>, <i>last2</i>).
+     * @param compare Binary function that accepts two elements as arguments (one from each of the two sequences, in the
+     *				  same order), and returns a value convertible to <code>bool</code>. The value returned indicates
+     *				  whether the element passed as first argument is considered to go before the second in the specific
+     *				  <i>strict weak ordering</i> it defines. The function shall not modify any of its arguments.
+     *
+     * @return <code>true</code> if every element in the range [<i>first2</i>, <i>last2</i>) is contained in the range
+     *		   [<i>first1</i>, <i>last1</i>), <code>false</code> otherwise. If [<i>first2</i>, <i>last2</i>) is an empty
+     *		   range, the function returns <code>true</code>.
+     */
+    function includes<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, compare: (x: T, y: T) => boolean): boolean;
+    /**
+     * Union of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set union</i> of the
+     * two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>union</i> of two sets is formed by the elements that are present in either one of the sets, or in both.
+     * Elements from the second range that have an equivalent element in the first range are not copied to the resulting
+     * range.
+     *
+     * The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!less(x, y) && !less(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion ({@link less}). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    /**
+     * Union of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set union</i> of the
+     * two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>union</i> of two sets is formed by the elements that are present in either one of the sets, or in both.
+     * Elements from the second range that have an equivalent element in the first range are not copied to the resulting
+     * range.
+     *
+     * The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!compare(x, y) && !compare(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
+     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
+     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
+     *				  function shall not modify any of its arguments.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    /**
+     * Intersection of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set intersection</i> of
+     * the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>intersection</i> of two sets is formed only by the elements that are present in both sets. The elements
+     * copied by the function come always from the first range, in the same order.
+     *
+     * The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!less(x, y) && !less(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion ({@link less}). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    /**
+     * Intersection of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set intersection</i> of
+     * the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>intersection</i> of two sets is formed only by the elements that are present in both sets. The elements
+     * copied by the function come always from the first range, in the same order.
+     *
+     * The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!compare(x, y) && !compare(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
+     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
+     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
+     *				  function shall not modify any of its arguments.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    /**
+     * Difference of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set difference</i> of
+     * the sorted range [<i>first1</i>, <i>last1</i>) with respect to the sorted range [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>difference</i> of two sets is formed by the elements that are present in the first set, but not in the
+     * second one. The elements copied by the function come always from the first range, in the same order.
+     *
+     * For containers supporting multiple occurrences of a value, the <i>difference</i> includes as many occurrences of
+     * a given value as in the first range, minus the amount of matching elements in the second, preserving order.
+     *
+     * Notice that this is a directional operation - for a symmetrical equivalent, see {@link set_symmetric_difference}.
+     *
+     * The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!less(x, y) && !less(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion ({@link less}). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    /**
+     * Difference of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set difference</i> of
+     * the sorted range [<i>first1</i>, <i>last1</i>) with respect to the sorted range [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>difference</i> of two sets is formed by the elements that are present in the first set, but not in the
+     * second one. The elements copied by the function come always from the first range, in the same order.
+     *
+     * For containers supporting multiple occurrences of a value, the <i>difference</i> includes as many occurrences of
+     * a given value as in the first range, minus the amount of matching elements in the second, preserving order.
+     *
+     * Notice that this is a directional operation - for a symmetrical equivalent, see {@link set_symmetric_difference}.
+     *
+     * The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!compare(x, y) && !compare(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
+     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
+     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
+     *				  function shall not modify any of its arguments.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    /**
+     * Symmetric difference of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by0 <i>result</i> with the set
+     * <i>symmetric difference</i> of the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>symmetric difference</i> of two sets is formed by the elements that are present in one of the sets, but
+     * not in the other. Among the equivalent elements in each range, those discarded are those that appear before in the
+     * existent order before the call. The existing order is also preserved for the copied elements.
+     *
+     * The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!less(x, y) && !less(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion ({@link less}). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
+     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
+     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
+     *				  function shall not modify any of its arguments.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    /**
+     * Symmetric difference of two sorted ranges.
+     *
+     * Constructs a sorted range beginning in the location pointed by0 <i>result</i> with the set
+     * <i>symmetric difference</i> of the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
+     *
+     * The <i>symmetric difference</i> of two sets is formed by the elements that are present in one of the sets, but
+     * not in the other. Among the equivalent elements in each range, those discarded are those that appear before in the
+     * existent order before the call. The existing order is also preserved for the copied elements.
+     *
+     * The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
+     * <code>if (!compare(x, y) && !compare(y, x))</code>.
+     *
+     * The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
+     * resulting range is also sorted according to this.
+     *
+     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
+     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
+     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
+     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
+     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
+     *				[<i>first2</i>, <i>last2</i>).
+     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
+     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
+     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
+     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
+     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
+     *				  function shall not modify any of its arguments.
+     *
+     * @return An iterator to the end of the constructed range.
+     */
+    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+}
+declare namespace std {
+    /**
+     * Return the smallest.
+     *
+     * Returns the smallest of all the elements in the <i>args</i>.
+     *
+     * @param args Values to compare.
+     *
+     * @return The lesser of the values passed as arguments.
+     */
+    function min<T>(...args: T[]): T;
+    /**
+     * Return the largest.
+     *
+     * Returns the largest of all the elements in the <i>args</i>.
+     *
+     * @param args Values to compare.
+     *
+     * @return The largest of the values passed as arguments.
+     */
+    function max<T>(...args: T[]): T;
+    /**
+     * Return smallest and largest elements.
+     *
+     * Returns a {@link Pair} with the smallest of all the elements in the <i>args</i> as first element (the first of
+     * them, if there are more than one), and the largest as second (the last of them, if there are more than one).
+     *
+     * @param args Values to compare.
+     *
+     * @return The lesser and greatest of the values passed as arguments.
+     */
+    function minmax<T>(...args: T[]): Pair<T, T>;
+    /**
+     * Return smallest element in range.
+     *
+     * Returns an iterator pointing to the element with the smallest value in the range  [<i>first</i>, <i>last</i>).
+     *
+     * The comparisons are performed using either {@link less}; An element is the smallest if no other element
+     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
+     * of such elements.
+     *
+     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
+     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
+     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *
+     * @return An iterator to smallest value in the range, or <i>last</i> if the range is empty.
+     */
+    function min_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): ForwardIterator;
+    /**
+     * Return smallest element in range.
+     *
+     * Returns an iterator pointing to the element with the smallest value in the range  [<i>first</i>, <i>last</i>).
+     *
+     * The comparisons are performed using either <i>compare</i>; An element is the smallest if no other element
+     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
+     * of such elements.
+     *
+     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
+     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
+     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
+     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
+     *				  considered less than the second. The function shall not modify any of its arguments.
+     *
+     * @return An iterator to smallest value in the range, or <i>last</i> if the range is empty.
+     */
+    function min_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): ForwardIterator;
+    /**
+     * Return largest element in range.
+     *
+     * Returns an iterator pointing to the element with the largest value in the range  [<i>first</i>, <i>last</i>).
+     *
+     * The comparisons are performed using either {@link greater}; An element is the largest if no other element
+     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
+     * of such elements.
+     *
+     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
+     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
+     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     *
+     * @return An iterator to largest value in the range, or <i>last</i> if the range is empty.
+     */
+    function max_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): ForwardIterator;
+    /**
+     * Return largest element in range.
+     *
+     * Returns an iterator pointing to the element with the largest value in the range  [<i>first</i>, <i>last</i>).
+     *
+     * The comparisons are performed using either <i>compare</i>; An element is the largest if no other element
+     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
+     * of such elements.
+     *
+     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
+     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
+     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
+     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
+     *				  considered less than the second. The function shall not modify any of its arguments.
+     *
+     * @return An iterator to largest value in the range, or <i>last</i> if the range is empty.
+     */
+    function max_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): ForwardIterator;
+    /**
+     * Return smallest and largest elements in range.
+     *
+     * Returns a {@link Pair} with an iterator pointing to the element with the smallest value in the range
+     * [<i>first</i>, <i>last</i>) as first element, and the largest as second.
+     *
+     * The comparisons are performed using either {@link less} and {@link greater}.
+     *
+     * If more than one equivalent element has the smallest value, the first iterator points to the first of such
+     * elements.
+     *
+     * If more than one equivalent element has the largest value, the second iterator points to the last of such
+     * elements.
+     *
+     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
+     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
+     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
+     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
+     *				  considered less than the second. The function shall not modify any of its arguments.
+     *
+     * @return A {@link Pair} with an iterator pointing to the element with the smallest value in the range
+     *		   [<i>first</i>, <i>last</i>) as first element, and the largest as second.
+     */
+    function minmax_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): Pair<ForwardIterator, ForwardIterator>;
+    /**
+     * Return smallest and largest elements in range.
+     *
+     * Returns a {@link Pair} with an iterator pointing to the element with the smallest value in the range
+     * [<i>first</i>, <i>last</i>) as first element, and the largest as second.
+     *
+     * The comparisons are performed using either <i>compare</i>.
+     *
+     * If more than one equivalent element has the smallest value, the first iterator points to the first of such
+     * elements.
+     *
+     * If more than one equivalent element has the largest value, the second iterator points to the last of such
+     * elements.
+     *
+     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
+     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
+     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
+     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
+     *				  considered less than the second. The function shall not modify any of its arguments.
+     *
+     * @return A {@link Pair} with an iterator pointing to the element with the smallest value in the range
+     *		   [<i>first</i>, <i>last</i>) as first element, and the largest as second.
+     */
+    function minmax_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): Pair<ForwardIterator, ForwardIterator>;
+    /**
+     * Clamp a value between a pair of boundary.
+     *
+     * @param v The value to clamp.
+     * @param lo Start of the boundaries to clamp *v* to.
+     * @param hi Terminal of the boundaries to clamp *v* to.
+     *
+     * @return *lo* if *v* is less than *lo*, *hi* if *hi* is less than *v*, otherwise *v*.
+     */
+    function clamp<T>(v: T, lo: T, hi: T): T;
+    /**
+     * Clamp a value between a pair of boundary.
+     *
+     * @param v The value to clamp.
+     * @param lo Start of the boundaries to clamp *v* to.
+     * @param hi Terminal of the boundaries to clamp *v* to.
+     * @param comp Binary function that accepts two elements as arguments (one of each of the two sequences, in the
+     *			   same order), and returns a value convertible to <code>bool</code>. The value returned indicates
+     *			   whether the elements are considered to match in the context of this function.
+     *
+     * @return *lo* if *v* is less than *lo*, *hi* if *hi* is less than *v*, otherwise *v*.
+     */
+    function clamp<T>(v: T, lo: T, hi: T, comp: (x: T, y: T) => boolean): T;
+    /**
+     * Test whether range is permutation of another.
+     *
+     * Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
+     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match, even in a different
+     * order.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
+     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
+     *
+     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
+     *		   of the range starting at <i>first2</i> in any order, and <code>false</code> otherwise.
+     */
+    function is_permutation<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2): boolean;
+    /**
+     * Test whether range is permutation of another.
+     *
+     * Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
+     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match, even in a different
+     * order.
+     *
+     * @param first1 An {@link Iterator} to the initial position of the first sequence.
+     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
+     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
+     *				pointed by <i>last1</i>.
+     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
+     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
+     * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same
+     *			   order), and returns a value convertible to <code>bool</code>. The value returned indicates whether
+     *			   the elements are considered to match in the context of this function.
+     *
+     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
+     *		   of the range starting at <i>first2</i> in any order, and <code>false</code> otherwise.
+     */
+    function is_permutation<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, pred: (x: T, y: T) => boolean): boolean;
+    /**
+     * Transform range to previous permutation.
+     *
+     * Rearranges the elements in the range [*first*, *last*) into the previous *lexicographically-ordered* permutation.
+     *
+     * A *permutation* is each one of the N! possible arrangements the elements can take (where *N* is the number of
+     * elements in the range). Different permutations can be ordered according to how they compare
+     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
+     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
+     * sorted in ascending order, and the largest has all its elements sorted in descending order.
+     *
+     * The comparisons of individual elements are performed using the {@link less less()} function.
+     *
+     * If the function can determine the previous permutation, it rearranges the elements as such and returns true. If
+     * that was not possible (because it is already at the lowest possible permutation), it rearranges the elements
+     * according to the last permutation (sorted in descending order) and returns false.
+     *
+     * @param first Bidirectional iterators to the initial positions of the sequence
+     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
+     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
+     *			   but not the element pointed by *last*.
+     *
+     * @return true if the function could rearrange the object as a lexicographicaly smaller permutation. Otherwise, the
+     *		   function returns false to indicate that the arrangement is not less than the previous, but the largest
+     *		   possible (sorted in descending order).
+     */
+    function prev_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator): boolean;
+    /**
+     * Transform range to previous permutation.
+     *
+     * Rearranges the elements in the range [*first*, *last*) into the previous *lexicographically-ordered* permutation.
+     *
+     * A *permutation* is each one of the N! possible arrangements the elements can take (where *N* is the number of
+     * elements in the range). Different permutations can be ordered according to how they compare
+     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
+     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
+     * sorted in ascending order, and the largest has all its elements sorted in descending order.
+     *
+     * The comparisons of individual elements are performed using the *compare*.
+     *
+     * If the function can determine the previous permutation, it rearranges the elements as such and returns true. If
+     * that was not possible (because it is already at the lowest possible permutation), it rearranges the elements
+     * according to the last permutation (sorted in descending order) and returns false.
+     *
+     * @param first Bidirectional iterators to the initial positions of the sequence
+     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
+     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
+     *			   but not the element pointed by *last*.
+     * @param compare Binary function that accepts two arguments of the type pointed by BidirectionalIterator, and returns
+     *				  a value convertible to bool. The value returned indicates whether the first argument is considered
+     *				  to go before the second in the specific strict weak ordering it defines.
+     *
+     * @return true if the function could rearrange the object as a lexicographicaly smaller permutation. Otherwise, the
+     *		   function returns false to indicate that the arrangement is not less than the previous, but the largest
+     *		   possible (sorted in descending order).
+     */
+    function prev_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, compare: (x: T, y: T) => boolean): boolean;
+    /**
+     * Transform range to next permutation.
+     *
+     * Rearranges the elements in the range [*first*, *last*) into the next *lexicographically greater* permutation.
+     *
+     * A permutation is each one of the *N!* possible arrangements the elements can take (where *N* is the number of
+     * elements in the range). Different permutations can be ordered according to how they compare
+     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
+     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
+     * sorted in ascending order, and the largest has all its elements sorted in descending order.
+     *
+     * The comparisons of individual elements are performed using the {@link less} function.
+     *
+     * If the function can determine the next higher permutation, it rearranges the elements as such and returns true. If
+     * that was not possible (because it is already at the largest possible permutation), it rearranges the elements
+     * according to the first permutation (sorted in ascending order) and returns false.
+     *
+     * @param first Bidirectional iterators to the initial positions of the sequence
+     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
+     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
+     *			   but not the element pointed by *last*.
+     *
+     * @return true if the function could rearrange the object as a lexicographicaly greater permutation. Otherwise, the
+     *		   function returns false to indicate that the arrangement is not greater than the previous, but the lowest
+     *		   possible (sorted in ascending order).
+     */
+    function next_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator): boolean;
+    /**
+     * Transform range to next permutation.
+     *
+     * Rearranges the elements in the range [*first*, *last*) into the next *lexicographically greater* permutation.
+     *
+     * A permutation is each one of the *N!* possible arrangements the elements can take (where *N* is the number of
+     * elements in the range). Different permutations can be ordered according to how they compare
+     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
+     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
+     * sorted in ascending order, and the largest has all its elements sorted in descending order.
+     *
+     * The comparisons of individual elements are performed using the *compare*.
+     *
+     * If the function can determine the next higher permutation, it rearranges the elements as such and returns true. If
+     * that was not possible (because it is already at the largest possible permutation), it rearranges the elements
+     * according to the first permutation (sorted in ascending order) and returns false.
+     *
+     * @param first Bidirectional iterators to the initial positions of the sequence
+     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
+     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
+     *			   but not the element pointed by *last*.
+     * @param compare Binary function that accepts two arguments of the type pointed by BidirectionalIterator, and returns
+     *				  a value convertible to bool. The value returned indicates whether the first argument is considered
+     *				  to go before the second in the specific strict weak ordering it defines.
+     *
+     * @return true if the function could rearrange the object as a lexicographicaly greater permutation. Otherwise, the
+     *		   function returns false to indicate that the arrangement is not greater than the previous, but the lowest
+     *		   possible (sorted in ascending order).
+     */
+    function next_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, compare: (x: T, y: T) => boolean): boolean;
+}
+declare namespace std.base {
+    /**
+     * An abstract container.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/abstract_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/abstract_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * ### Container properties
+     * <dl>
+     * 	<dt> Sequence </dt>
+     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
+     *		 accessed by their position in this sequence. </dd>
+     *
+     * 	<dt> Doubly-linked list </dt>
+     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing
+     *		 constant time insert and erase operations before or after a specific element (even of entire ranges),
+     *		 but no direct random access. </dd>
+     * </dl>
+     *
+     * @param <T> Type of elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Container<T> {
+        /**
+         * Default Constructor.
+         */
+        protected constructor();
+        /**
+         * Assign new content to content.
+         *
+         * Assigns new contents to the container, replacing its current contents, and modifying its
+         * {@link size} accordingly.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        abstract assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * Clear content.
+         *
+         * Removes all elements from the Container, leaving the container with a size of 0.
+         */
+        clear(): void;
+        /**
+         * Return iterator to beginning.
+         *
+         * Returns an iterator referring the first element in the
+         *
+         * #### Note
+         * If the container is {@link empty}, the returned iterator is same with {@link end end()}.
+         *
+         * @return An iterator to the first element in the  The iterator containes the first element's value.
+         */
+        abstract begin(): Iterator<T>;
+        /**
+         * Return iterator to end.
+         * Returns an iterator referring to the past-the-end element in the
+         *
+         * The past-the-end element is the theoretical element that would follow the last element in the
+         * It does not point to any element, and thus shall not be dereferenced.
+         *
+         * Because the ranges used by functions of the Container do not include the element reference by their
+         * closing iterator, this function is often used in combination with {@link Container}.{@link begin} to
+         * specify a range including all the elements in the container.
+         *
+         * #### Note
+         * Returned iterator from {@link Container}.{@link end} does not refer any element. Trying to accessing
+         * element by the iterator will cause throwing exception ({@link OutOfRange}).
+         *
+         * If the container is {@link empty}, this function returns the same as {@link Container}.{@link begin}.
+         *
+         *
+         * @return An iterator to the end element in the
+         */
+        abstract end(): Iterator<T>;
+        /**
+         * Return {@link ReverseIterator reverse iterator} to <i>reverse beginning</i>.
+         *
+         * Returns a {@link ReverseIterator reverse iterator} pointing to the last element in the container (i.e.,
+         * its <i>reverse beginning</i>).
+         *
+         * {@link ReverseIterator reverse iterators} iterate backwards: increasing them moves them towards the
+         * beginning of the
+         *
+         * {@link rbegin} points to the element right before the one that would be pointed to by member {@link end}.
+         *
+         *
+         * @return A {@link ReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
+         */
+        abstract rbegin(): IReverseIterator<T>;
+        /**
+         * Return {@link ReverseIterator reverse iterator} to <i>reverse end</i>.
+         *
+         * Returns a {@link ReverseIterator reverse iterator} pointing to the theoretical element preceding the
+         * first element in the container (which is considered its <i>reverse end</i>).
+         *
+         * The range between {@link Container}.{@link rbegin} and {@link Container}.{@link rend} contains all
+         * the elements of the container (in reverse order).
+         *
+         * @return A {@link ReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence
+         */
+        abstract rend(): IReverseIterator<T>;
+        /**
+         * Return the number of elements in the {@link Container}.
+         *
+         * @return The number of elements in the container.
+         */
+        abstract size(): number;
+        /**
+         * Test whether the container is empty.
+         * Returns whether the container is empty (i.e. whether its size is 0).
+         *
+         * This function does not modify the container in any way. To clear the content of the container,
+         * see {@link clear clear()}.
+         *
+         * @return <code>true</code> if the container size is 0, <code>false</code> otherwise.
+         */
+        empty(): boolean;
+        /**
+         * Insert elements.
+         *
+         * Appends new elements to the container, and returns the new size of the
+         *
+         * @param items New elements to insert.
+         *
+         * @return New size of the Container.
+         */
+        abstract push(...items: T[]): number;
+        /**
+         * Insert an element.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link Container.size container size} by the amount of
+         * elements inserted.
+         *
+         * @param position Position in the {@link Container} where the new element is inserted.
+         *				   {@link iterator} is a member type, defined as a {@link Iterator random access iterator}
+         *				   type that points to elements.
+         * @param val Value to be copied to the inserted element.
+         *
+         * @re
+        public abstract insert(position: Iterator<T>, val: T): Iterator<T>;
+
+        /* ---------------------------------------------------------
+            ERASE
+        --------------------------------------------------------- */
+        /**
+         * Erase an element.
+         *
+         * Removes from the container a single element.
+         *
+         * This effectively reduces the container size by the number of element removed.
+         *
+         * @param position Iterator pointing to a single element to be removed from the Container.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function
+         *		   call. This is the {@link end Container.end} if the operation erased the last element in the
+         *		   sequence.
+         */
+        abstract erase(position: Iterator<T>): Iterator<T>;
+        /**
+         * Erase elements.
+         *
+         * Removes from the container a range of elements.
+         *
+         * This effectively reduces the container size by the number of elements removed.
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function
+         *		   call. This is the {@link end Container.end} if the operation erased the last element in
+         *		   the sequence.
+         */
+        abstract erase<U extends T>(begin: Iterator<U>, end: Iterator<U>): Iterator<T>;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link Container container} object with same type of elements. Sizes and container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link Container container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link Container container}.
+         */
+        swap(obj: Container<T>): void;
+    }
+    interface IReverseIterator<T> extends ReverseIterator<T, Container<T>, Iterator<T>, IReverseIterator<T>> {
+    }
+}
+declare namespace std {
+    /**
+     * Bi-directional iterator.
+     *
+     * {@link Iterator Bidirectional iterators} are iterators that can be used to access the sequence of elements
+     * in a range in both directions (towards the end and towards the beginning).
+     *
+     * All {@link IArrayIterator random-access iterators} are also valid {@link Iterrator bidirectional iterators}.
+     *
+     * There is not a single type of {@link Iterator bidirectional iterator}: {@link Container Each container}
+     * may define its own specific iterator type able to iterate through it and access its elements.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/abstract_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
+     *
+     * @reference http://www.cplusplus.com/reference/iterator/BidirectionalIterator
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Iterator<T> {
+        /**
+         * @hidden
+         */
+        protected source_: base.Container<T>;
+        /**
+         * Construct from the source {@link Container container}.
+         *
+         * @param source The source container.
+         */
+        protected constructor(source: base.Container<T>);
+        /**
+         * Get iterator to previous element.
+         *
+         * If current iterator is the first item(equal with {@link Container.begin Container.begin()}),
+         * returns {@link Container.end Container.end()}.
+         *
+         * @return An iterator of the previous item.
+         */
+        abstract prev(): Iterator<T>;
+        /**
+         * Get iterator to next element.
+         *
+         * If current iterator is the last item, returns {@link Container.end Container.end()}.
+         *
+         * @return An iterator of the next item.
+         */
+        abstract next(): Iterator<T>;
+        /**
+         * Advances the {@link Iterator} by <i>n</i> element positions.
+         *
+         * @param n Number of element positions to advance.
+         * @return An advanced iterator.
+         */
+        abstract advance(n: number): Iterator<T>;
+        /**
+         * Get source container.
+         *
+         * Get source container of this iterator is directing for.
+         */
+        abstract source(): base.Container<T>;
+        /**
+         * Whether an iterator is equal with the iterator.
+         *
+         * Compare two iterators and returns whether they are equal or not.
+         *
+         * #### Note
+         * Iterator's {@link equals equals()} only compare souce container and index number.
+         *
+         * Although elements in a pair, key and value are {@link equal_to equal_to}, if the source map or
+         * index number is different, then the {@link equals equals()} will return false. If you want to
+         * compare the elements of a pair, compare them directly by yourself.
+         *
+         * @param obj An iterator to compare
+         * @return Indicates whether equal or not.
+         */
+        equals(obj: Iterator<T>): boolean;
+        /**
+         * Get value of the iterator is pointing.
+         *
+         * @return A value of the iterator.
+         */
+        readonly abstract value: T;
+        abstract swap(obj: Iterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * This class reverses the direction in which a bidirectional or random-access iterator iterates through a range.
+     *
+     * A copy of the original iterator (the {@link Iterator base iterator}) is kept internally and used to reflect
+     * the operations performed on the {@link ReverseIterator}: whenever the {@link ReverseIterator} is incremented, its
+     * {@link Iterator base iterator} is decreased, and vice versa. A copy of the {@link Iterator base iterator} with the
+     * current state can be obtained at any time by calling member {@link base}.
+     *
+     * Notice however that when an iterator is reversed, the reversed version does not point to the same element in
+     * the range, but to <b>the one preceding it</b>. This is so, in order to arrange for the past-the-end element of a
+     * range: An iterator pointing to a past-the-end element in a range, when reversed, is pointing to the last element
+     * (not past it) of the range (this would be the first element of the reversed range). And if an iterator to the
+     * first element in a range is reversed, the reversed iterator points to the element before the first element (this
+     * would be the past-the-end element of the reversed range).
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/abstract_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
+     *
+     * @reference http://www.cplusplus.com/reference/iterator/reverse_iterator
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ReverseIterator<T, Source extends base.Container<T>, Base extends Iterator<T>, This extends ReverseIterator<T, Source, Base, This>> extends Iterator<T> {
+        /**
+         * @hidden
+         */
+        protected base_: Base;
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        protected constructor(base: Base);
+        /**
+         * @hidden
+         */
+        protected abstract _Create_neighbor(base: Base): This;
+        source(): Source;
+        /**
+         * Return base iterator.
+         *
+         * Return a reference of the base iteraotr.
+         *
+         * The base iterator is an iterator of the same type as the one used to construct the {@link ReverseIterator},
+         * but pointing to the element next to the one the {@link ReverseIterator} is currently pointing to
+         * (a {@link ReverseIterator} has always an offset of -1 with respect to its base iterator).
+         *
+         * @return A reference of the base iterator, which iterates in the opposite direction.
+         */
+        base(): Base;
+        /**
+         * Get value of the iterator is pointing.
+         *
+         * @return A value of the reverse iterator.
+         */
+        readonly value: T;
+        /**
+         * @inheritdoc
+         */
+        prev(): This;
+        /**
+         * @inheritdoc
+         */
+        next(): This;
+        /**
+         * @inheritdoc
+         */
+        advance(n: number): This;
+        /**
+         * @inheritdoc
+         */
+        equals(obj: This): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: This): void;
+    }
+    /**
+     * Return the number of elements in the {@link Container}.
+     *
+     * @param container A container with a size method.
+     * @return The number of elements in the container.
+     */
+    function size<T>(container: base.Container<T>): number;
+    /**
+     * Test whether the container is empty.
+     *
+     * Returns whether the {@link Container} is empty (i.e. whether its {@link size} is 0).
+     *
+     * @param container A container with a empty method.
+     * @return <code>true</code> if the container size is 0, <code>false</code> otherwise.
+     */
+    function empty<T>(container: base.Container<T>): boolean;
+    /**
+     * Return distance between {@link Iterator iterators}.
+     *
+     * Calculates the number of elements between <i>first</i> and <i>last</i>.
+     *
+     * If it is a {@link IArrayIterator random-access iterator}, the function uses operator- to calculate this.
+     * Otherwise, the function uses the increase operator {@link Iterator.next next()} repeatedly.
+     *
+     * @param first Iterator pointing to the initial element.
+     * @param last Iterator pointing to the final element. This must be reachable from first.
+     *
+     * @return The number of elements between first and last.
+     */
+    function distance<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): number;
+    /**
+     * Advance iterator.
+     *
+     * Advances the iterator <i>it</i> by <i>n</i> elements positions.
+     *
+     * @param it Iterator to be advanced.
+     * @param n Number of element positions to advance.
+     *
+     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
+     */
+    function advance<T, InputIterator extends Iterator<T>>(it: InputIterator, n: number): InputIterator;
+    /**
+     * Get iterator to previous element.
+     *
+     * Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>-n</i> positions.
+     *
+     * @param it Iterator to base position.
+     * @param n Number of element positions offset (1 by default).
+     *
+     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
+     */
+    function prev<T, BidirectionalIterator extends Iterator<T>>(it: BidirectionalIterator, n?: number): BidirectionalIterator;
+    /**
+     * Get iterator to next element.
+     *
+     * Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>n</i> positions.
+     *
+     * @param it Iterator to base position.
+     * @param n Number of element positions offset (1 by default).
+     *
+     * @return An iterator to the element <i>n</i> positions away from <i>it</i>.
+     */
+    function next<T, ForwardIterator extends Iterator<T>>(it: ForwardIterator, n?: number): ForwardIterator;
+    /**
+     * Iterator to beginning.
+     *
+     * Returns an iterator pointing to the first element in the sequence.
+     *
+     * If the sequence is {@link empty}, the returned value shall not be dereferenced.
+     *
+     * @param container A container object of a class type for which member {@link begin} is defined.
+     * @return The same as returned by {@link begin begin()}.
+     */
+    function begin<T>(container: base.Container<T>): Iterator<T>;
+    function begin<T>(container: Vector<T>): VectorIterator<T>;
+    function begin<T>(container: List<T>): ListIterator<T>;
+    function begin<T>(container: Deque<T>): DequeIterator<T>;
+    function begin<T>(container: base.SetContainer<T>): SetIterator<T>;
+    function begin<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
+    /**
+     * Iterator to reverse-beginning.
+     *
+     * Returns a reverse iterator pointing to the last element in the sequence.
+     *
+     * If the sequence is {@link empty}, the returned value shall not be dereferenced.
+     *
+     * @param container A container object of a class type for which member {@link rbegin} is defined.
+     * @return The same as returned by {@link rbegin()}.
+     */
+    function rbegin<T>(container: base.Container<T>): base.IReverseIterator<T>;
+    function rbegin<T>(container: Vector<T>): VectorReverseIterator<T>;
+    function rbegin<T>(container: List<T>): ListReverseIterator<T>;
+    function rbegin<T>(container: Deque<T>): DequeReverseIterator<T>;
+    function rbegin<T>(container: base.SetContainer<T>): SetReverseIterator<T>;
+    function rbegin<Key, T>(container: base.MapContainer<Key, T>): MapReverseIterator<Key, T>;
+    /**
+     * Iterator to end.
+     *
+     * Returns an iterator pointing to the <i>past-the-end</i> element in the sequence.
+     *
+     * If the sequence is {@link empty}, the returned value compares equal to the one returned by {@link begin} with the same argument.
+     *
+     * @param container A container of a class type for which member {@link end} is defined.
+     * @return The same as returned by {@link end end()}.
+     */
+    function end<T>(container: base.Container<T>): Iterator<T>;
+    function end<T>(container: Vector<T>): VectorIterator<T>;
+    function end<T>(container: List<T>): ListIterator<T>;
+    function end<T>(container: Deque<T>): DequeIterator<T>;
+    function end<T>(container: base.SetContainer<T>): SetIterator<T>;
+    function end<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
+    /**
+     * Iterator to end.
+     *
+     * Returns an iterator pointing to the <i>past-the-end</i> element in the sequence.
+     *
+     * If the sequence is {@link empty}, the returned value compares equal to the one returned by {@link begin} with the same argument.
+     *
+     * @param container A container of a class type for which member {@link end} is defined.
+     * @return The same as returned by {@link end end()}.
+     */
+    function rend<T>(container: base.Container<T>): base.IReverseIterator<T>;
+    function rend<T>(container: Vector<T>): VectorReverseIterator<T>;
+    function rend<T>(container: List<T>): ListReverseIterator<T>;
+    function rend<T>(container: Deque<T>): DequeReverseIterator<T>;
+    function rend<T>(container: base.SetContainer<T>): SetReverseIterator<T>;
+    function rend<Key, T>(container: base.MapContainer<Key, T>): MapReverseIterator<Key, T>;
+    /**
+     * Make reverse iterator.
+     *
+     * @param it A reference of the base iterator, which iterates in the opposite direction.
+     * @return A {@link ReverseIterator reverse iterator} based on *it*.
+     */
+    function make_reverse_iterator<T>(it: VectorIterator<T>): VectorReverseIterator<T>;
+    function make_reverse_iterator<T>(it: DequeIterator<T>): DequeReverseIterator<T>;
+    function make_reverse_iterator<T>(it: ListIterator<T>): ListReverseIterator<T>;
+    function make_reverse_iterator<T>(it: SetIterator<T>): SetReverseIterator<T>;
+    function make_reverse_iterator<Key, T>(it: MapIterator<Key, T>): MapReverseIterator<Key, T>;
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    abstract class _ListContainer<T, BidirectionalIterator extends _ListIteratorBase<T>> extends Container<T> implements IDequeContainer<T> {
+        /**
+         * @hidden
+         */
+        private begin_;
+        /**
+         * @hidden
+         */
+        private end_;
+        /**
+         * @hidden
+         */
+        private size_;
+        /**
+         * Default Constructor.
+         */
+        protected constructor();
+        /**
+         * @hidden
+         */
+        protected abstract _Create_iterator(prev: BidirectionalIterator, next: BidirectionalIterator, val: T): BidirectionalIterator;
+        /**
+         * @hidden
+         */
+        protected _Set_begin(it: BidirectionalIterator): void;
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        begin(): BidirectionalIterator;
+        /**
+         * @inheritdoc
+         */
+        end(): BidirectionalIterator;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        front(): T;
+        /**
+         * @inheritdoc
+         */
+        back(): T;
+        /**
+         * @inheritdoc
+         */
+        push_front(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        pop_front(): void;
+        /**
+         * @inheritdoc
+         */
+        pop_back(): void;
+        /**
+         * @inheritdoc
+         */
+        push(...items: T[]): number;
+        /**
+         * Insert an element.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new element is inserted.
+         *				   {@link iterator}> is a member type, defined as a
+         *				   {@link ListIterator bidirectional iterator} type that points to elements.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the newly inserted element; <i>val</i>.
+         */
+        insert(position: BidirectionalIterator, val: T): BidirectionalIterator;
+        /**
+         * Insert elements by repeated filling.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param size Number of elements to insert.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: BidirectionalIterator, size: number, val: T): BidirectionalIterator;
+        /**
+         * Insert elements by range iterators.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param begin An iterator specifying range of the begining element.
+         * @param end An iterator specifying range of the ending element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: BidirectionalIterator, begin: InputIterator, end: InputIterator): BidirectionalIterator;
+        /**
+         * @hidden
+         */
+        private _Insert_by_repeating_val(position, n, val);
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(position: BidirectionalIterator, begin: InputIterator, end: InputIterator): BidirectionalIterator;
+        /**
+         * Erase an element.
+         *
+         * Removes from the {@link List} either a single element; <i>position</i>.
+         *
+         * This effectively reduces the container size by the number of element removed.
+         *
+         * Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link List}.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
+         */
+        erase(position: BidirectionalIterator): BidirectionalIterator;
+        /**
+         * Erase elements.
+         *
+         * Removes from the {@link List} container a range of elements.
+         *
+         * This effectively reduces the container {@link size} by the number of elements removed.
+         *
+         * Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
+         */
+        erase(begin: BidirectionalIterator, end: BidirectionalIterator): BidirectionalIterator;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: BidirectionalIterator, last: BidirectionalIterator): BidirectionalIterator;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link List container} object with same type of elements. Sizes and container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link List container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link List container}.
+         */
+        swap(obj: _ListContainer<T, BidirectionalIterator>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: Container<T>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    abstract class _ListIteratorBase<T> extends Iterator<T> {
+        /**
+         * @hidden
+         */
+        protected prev_: _ListIteratorBase<T>;
+        /**
+         * @hidden
+         */
+        protected next_: _ListIteratorBase<T>;
+        /**
+         * @hidden
+         */
+        protected value_: T;
+        /**
+         * Initializer Constructor.
+         *
+         * @param source The source {@link Container} to reference.
+         * @param prev A refenrece of previous node ({@link ListIterator iterator}).
+         * @param next A refenrece of next node ({@link ListIterator iterator}).
+         * @param value Value to be stored in the node (iterator).
+         */
+        protected constructor(source: Container<T>, prev: _ListIteratorBase<T>, next: _ListIteratorBase<T>, value: T);
+        /**
+         * @inheritdoc
+         */
+        prev(): _ListIteratorBase<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): _ListIteratorBase<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(step: number): _ListIteratorBase<T>;
+        /**
+         * @inheritdoc
+         */
+        readonly value: T;
+        /**
+         * @inheritdoc
+         */
+        equals(obj: _ListIteratorBase<T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: _ListIteratorBase<T>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * An abstract error instance.
+     *
+     * {@link ErrorInstance} is an abstract class of {@link ErrorCode} and {@link ErrorCondition}
+     * holding an error instance's identifier {@link value}, associated with a {@link category}.
+     *
+     * The operating system and other low-level applications and libraries generate numerical error codes to
+     * represent possible results. These numerical values may carry essential information for a specific platform,
+     * but be non-portable from one platform to another.
+     *
+     * Objects of this class associate such numerical codes to {@link ErrorCategory error categories},
+     * so that they can be interpreted when needed as more abstract (and portable)
+     * {@link ErrorCondition error conditions}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ErrorInstance {
+        /**
+         * @hidden
+         */
+        protected category_: ErrorCategory;
+        /**
+         * @hidden
+         */
+        protected value_: number;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from a numeric value and error category.
+         *
+         * @param val A numerical value identifying an error instance.
+         * @param category A reference to an {@link ErrorCategory} object.
+         */
+        constructor(val: number, category: ErrorCategory);
+        /**
+         * Assign error instance.
+         *
+         * Assigns the {@link ErrorCode} object a value of val associated with the {@link ErrorCategory}.
+         *
+         * @param val A numerical value identifying an error instance.
+         * @param category A reference to an {@link ErrorCategory} object.
+         */
+        assign(val: number, category: ErrorCategory): void;
+        /**
+         * Clear error instance.
+         *
+         * Clears the value in the {@link ErrorCode} object so that it is set to a value of <i>0</i> of the
+         * {@link ErrorCategory.systemCategory ErrorCategory.systemCategory()} (indicating no error).
+         */
+        clear(): void;
+        /**
+         * Get category.
+         *
+         * Returns a reference to the {@link ErrorCategory} associated with the {@link ErrorCode} object.
+         *
+         * @return A reference to a non-copyable object of a type derived from {@link ErrorCategory}.
+         */
+        category(): ErrorCategory;
+        /**
+         * Error value.
+         *
+         * Returns the error value associated with the {@link ErrorCode} object.
+         *
+         * @return The error value.
+         */
+        value(): number;
+        /**
+         * Get message.
+         *
+         * Returns the message associated with the error instance.
+         *
+         * Error messages are defined by the {@link category} the error instance belongs to.
+         *
+         * This function returns the same as if the following member was called:
+         *
+         * <code>category().message(value())</code>
+         *
+         * @return A string object with the message associated with the {@link ErrorCode}.
+         */
+        message(): string;
+        /**
+         * Default error condition.
+         *
+         * Returns the default {@link ErrorCondition}object associated with the {@link ErrorCode} object.
+         *
+         * This function returns the same as if the following member was called:
+         *
+         * <code>category().default_error_condition(value())</code>
+         *
+         * {@link ErrorCategory.default_error_condition ErrorCategory.default_error_condition()}
+         * is a virtual member function, that can operate differently for each category.
+         *
+         * @return An {@link ErrorCondition}object that corresponds to the {@link ErrorCode} object.
+         */
+        default_error_condition(): ErrorCondition;
+        /**
+         * Convert to bool.
+         *
+         * Returns whether the error instance has a numerical {@link value} other than 0.
+         *
+         * If it is zero (which is generally used to represent no error), the function returns false, otherwise it returns true.
+         *
+         * @return <code>true</code> if the error's numerical value is not zero.
+         *		   <code>false</code> otherwise.
+         */
+        to_bool(): boolean;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    enum _Hash {
+        MIN_SIZE = 10,
+        RATIO = 1,
+        MAX_RATIO = 2,
+    }
+    /**
+     * @hidden
+     */
+    abstract class _HashBuckets<T> {
+        private buckets_;
+        private item_size_;
+        protected constructor();
+        rehash(size: number): void;
+        clear(): void;
+        size(): number;
+        item_size(): number;
+        capacity(): number;
+        at(index: number): Vector<T>;
+        hash_index(val: T): number;
+        insert(val: T): void;
+        erase(val: T): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    class _MapHashBuckets<K, T> extends _HashBuckets<MapIterator<K, T>> {
+        private map_;
+        constructor(map: IHashMap<K, T>);
+        find(key: K): MapIterator<K, T>;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    class _SetHashBuckets<T> extends _HashBuckets<SetIterator<T>> {
+        private set_;
+        constructor(set: IHashSet<T>);
+        find(val: T): SetIterator<T>;
+    }
+}
+declare namespace std.base {
+    /**
+     * Array Container.
+     *
+     * {@link IArrayContainer} is an interface for sequence containers representing <i>arrays</i> that can change in
+     * {@link size}. However, compared to <i>arrays</i>, {@link IArrayContainer} objectss consume more memory in exchange for
+     * the ability to manage storage and grow dynamically in an efficient way.
+     *
+     * Both {@link Vector Vectors} and {@link Deque Deques} who implemented {@link IArrayContainer} provide a very
+     * similar interface and can be used for similar purposes, but internally both work in quite different ways:
+     * While {@link Vector Vectors} use a single array that needs to be occasionally reallocated for growth, the
+     * elements of a {@link Deque} can be scattered in different chunks of storage, with the container keeping the
+     * necessary information internally to provide direct access to any of its elements in constant time and with a
+     * uniform sequential interface (through iterators). Therefore, {@link Deque Deques} are a little more complex
+     * internally than {@link Vector Vectors}, but this allows them to grow more efficiently under certain
+     * circumstances, especially with very long sequences, where reallocations become more expensive.
+     *
+     * Both {@link Vector Vectors} and {@link Deque Deques} provide a very similar interface and can be used for
+     * similar purposes, but internally both work in quite different ways: While {@link Vector Vectors} use a single
+     * array that needs to be occasionally reallocated for growth, the elements of a {@link Deque} can be scattered
+     * in different chunks of storage, with the container keeping the necessary information internally to provide
+     * direct access to any of its elements in constant time and with a uniform sequential interface (through
+     * iterators). Therefore, {@link Deque Deques} are a little more complex internally than {@link Vector Vectors},
+     * but this allows them to grow more efficiently under certain circumstances, especially with very long
+     * sequences, where reallocations become more expensive.
+     *
+     * For operations that involve frequent insertion or removals of elements at positions other than the
+     * beginning or the end, {@link IArrayContainer} objects perform worse and have less consistent iterators and references
+     * than {@link List Lists}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Sequence </dt>
+     *	<dd>
+     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
+     *		accessed by their position in this sequence.
+     *	</dd>
+     *
+     *	<dt> Dynamic array </dt>
+     *	<dd>
+     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
+     *		relatively fast addition/removal of elements at the end of the sequence.
+     *	</dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IArrayContainer<T> extends ILinearContainer<T> {
+        /**
+         * Access element.
+         * Returns a value to the element at position <i>index</i> in the {@link IArrayContainer container}.</p>
+         *
+         * The function automatically checks whether <i>index</i> is within the bounds of valid elements
+         * in the {@link IArrayContainer container}, throwing an {@link OutOfRange} exception if it is not (i.e.,
+         * if <i>index</i> is greater or equal than its {@link size}).
+         *
+         * @param index Position of an element in the
+         *				If this is greater than or equal to the {@link IArrayContainer container} {@link size}, an
+         *				exception of type {@link OutOfRange} is thrown. Notice that the first
+         *				element has a position of 0 (not 1).
+         *
+         * @return The element at the specified position in the
+         */
+        at(index: number): T;
+        /**
+         * Modify element.
+         * Replaces an element at the specified position (<i>index</i>) in this {@link IArrayContainer container}
+         * with the specified element (<i>val</i>).
+         *
+         * The function automatically checks whether <i>index</i> is within the bounds of valid elements
+         * in the {@link IArrayContainer container}, throwing an {@link OutOfRange} exception if it is not (i.e., if
+         * <i>index</i> is greater or equal than its {@link size}).
+         *
+         * @.param index A specified position of the value to replace.
+         * @param val A value to be stored at the specified position.
+         *
+         * @return The previous element had stored at the specified position.
+         */
+        set(index: number, val: T): void;
+    }
+    /**
+     * Random-access iterator.
+     *
+     * {@link IArrayIterator Random-access iterators} are iterators that can be used to access elements at an
+     * arbitrary offset position relative to the element they point to, offering the same functionality as pointers.
+     *
+     * {@link IArrayIterator Random-access iterators} are the most complete iterators in terms of functionality.
+     * All pointer types are also valid {@link IArrayIterator random-access iterators}.
+     *
+     * There is not a single type of {@link IArrayIterator random-access iterator}: Each container may define its
+     * own specific iterator type able to iterate through it and access its elements.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * @reference http://www.cplusplus.com/reference/iterator/RandomAccessIterator
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IArrayIterator<T> extends ILinearIterator<T> {
+        /**
+         * @inheritdoc
+         */
+        source(): IArrayContainer<T>;
+        /**
+         * Get index, sequence number of the iterator in the source {@link IArrayContainer array}.
+         *
+         * @return Sequence number of the iterator in the source {@link IArrayContainer array}.
+         */
+        index(): number;
+        /**
+         * @inheritdoc
+         */
+        prev(): IArrayIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): IArrayIterator<T>;
+    }
+}
+declare namespace std.base {
+    /**
+     * An interface for deque
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IDequeContainer<T> extends ILinearContainer<T> {
+        /**
+         * Insert element at beginning.
+         *
+         * Inserts a new element at the beginning of the {@link IDeque container}, right before its
+         * current first element. This effectively increases the {@link IDeque container} {@link size} by
+         * one.
+         *
+         * @param val Value to be inserted as an element.
+         */
+        push_front(val: T): void;
+        /**
+         * Delete first element.
+         *
+         * Removes the first element in the {@link IDeque container}, effectively reducing its
+         * {@link size} by one.
+         */
+        pop_front(): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * Common interface for hash map.
+     *
+     * {@link IHashMap}s are associative containers that store elements formed by the combination of
+     * a <i>key value</i> and a <i>mapped value</i>.
+     *
+     * In an {@link IHashMap}, the <i>key value</i> is generally used to uniquely identify the
+     * element, while the <i>mapped value</i> is an object with the content associated to this <i>key</i>.
+     * Types of <i>key</i> and <i>mapped value</i> may differ.
+     *
+     * Internally, the elements in the {@link IHashMap} are not sorted in any particular order with
+     * respect to either their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on
+     * their hash values to allow for fast access to individual elements directly by their <i>key values</i>
+     * (with a constant average time complexity on average).
+     *
+     * Elements with equivalent <i>keys</i> are grouped together in the same bucket and in such a way that
+     * an iterator can iterate through all of them. Iterators in the container are doubly linked iterators.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
+     *
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the key values.
+     *				Each element in an {@link IHashMap} is identified by a key value.
+     * @param <T> Type of the mapped value.
+     *			  Each element in an {@link IHashMap} is used to store some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_map
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IHashMap<Key, T> extends MapContainer<Key, T> {
+        /**
+         * Return number of buckets.
+         *
+         * Returns the number of buckets in the {@link IHashMap} container.
+         *
+         * A bucket is a slot in the container's internal hash table to which elements are assigned based on the
+         * hash value of their key.
+         *
+         * The number of buckets influences directly the {@link load_factor load factor} of the container's hash
+         * table (and thus the probability of collision). The container automatically increases the number of buckets to
+         * keep the load factor below a specific threshold (its {@link max_load_factor}), causing a {@link rehash} each
+         * time the number of buckets needs to be increased.
+         *
+         * @return The current amount of buckets.
+         */
+        bucket_count(): number;
+        /**
+         * Return bucket size.
+         *
+         * Returns the number of elements in bucket <i>n</i>.
+         *
+         * A bucket is a slot in the container's internal hash table to which elements are assigned based on the hash
+         * value of their key.
+         *
+         * The number of elements in a bucket influences the time it takes to access a particular element in the
+         * bucket. The container automatically increases the number of buckets to keep the {@link load_cator load factor}
+         * (which is the average bucket size) below its {@link max_load_factor}.
+         *
+         * @param n Bucket number. This shall be lower than {@link bucket_count}.
+         *
+         * @return The number of elements in bucket <i>n</i>.
+         */
+        bucket_size(n: number): number;
+        /**
+         * Get maximum load factor.
+         *
+         * Returns the current maximum load factor for the {@link HashMultiMap} container.
+         *
+         * The load factor is the ratio between the number of elements in the container (its {@link size}) and the
+         * number of buckets ({@link bucket_count}).
+         *
+         * By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0.
+         *
+         * The load factor influences the probability of collision in the hash table (i.e., the probability of two
+         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
+         * that forces an increase in the number of buckets (and thus causing a {@link rehash}).
+         *
+         * Note though, that implementations may impose an upper limit on the number of buckets (see
+         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}.
+         *
+         * @return The current load factor.
+         */
+        max_load_factor(): number;
+        /**
+         * Set maximum load factor.
+         *
+         * Sets <i>z</i> as the cnew maximum load factor for the {@link HashMultiMap} container.
+         *
+         * The load factor is the ratio between the number of elements in the container (its {@link size}) and the
+         * number of buckets ({@link bucket_count}).
+         *
+         * By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0.
+         *
+         * The load factor influences the probability of collision in the hash table (i.e., the probability of two
+         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
+         * that forces an increase in the number of buckets (and thus causing a {@link rehash}).
+         *
+         * Note though, that implementations may impose an upper limit on the number of buckets (see
+         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}.
+         *
+         * @param z The new maximum load factor.
+         */
+        max_load_factor(z: number): void;
+        /**
+         * Locate element's bucket.
+         *
+         * Returns the bucket number where the element with <i>key</i> is located.
+         *
+         * A bucket is a slot in the container's internal hash table to which elements are assigned based on the
+         * hash value of their <i>key</i>. Buckets are numbered from 0 to ({@link bucket_count} - 1).
+         *
+         * Individual elements in a bucket can be accessed by means of the range iterators returned by
+         * {@link begin} and {@link end}.
+         *
+         * @param key Key whose bucket is to be located.
+         */
+        bucket(key: Key): number;
+        /**
+         * Request a capacity change.
+         *
+         * Sets the number of buckets in the container ({@link bucket_count}) to the most appropriate to contain at
+         * least <i>n</i> elements.
+         *
+         * If <i>n</i> is greater than the current {@link bucket_count} multiplied by the {@link max_load_factor},
+         * the container's {@link bucket_count} is increased and a {@link rehash} is forced.
+         *
+         * If <i>n</i> is lower than that, the function may have no effect.
+         *
+         * @param n The number of elements requested as minimum capacity.
+         */
+        reserve(n: number): void;
+        /**
+         * Set number of buckets.
+         *
+         * Sets the number of buckets in the container to <i>n</i> or more.
+         *
+         * If <i>n</i> is greater than the current number of buckets in the container ({@link bucket_count}), a
+         * {@link HashBuckets.rehash rehash} is forced. The new {@link bucket_count bucket count} can either be equal or
+         * greater than <i>n</i>.
+         *
+         * If <i>n</i> is lower than the current number of buckets in the container ({@link bucket_count}), the
+         * function may have no effect on the {@link bucket_count bucket count} and may not force a
+         * {@link HashBuckets.rehash rehash}.
+         *
+         * A {@link HashBuckets.rehash rehash} is the reconstruction of the hash table: All the elements in the
+         * container are rearranged according to their hash value into the new set of buckets. This may alter the order
+         * of iteration of elements within the container.
+         *
+         * {@link HashBuckets.rehash Rehashes} are automatically performed by the container whenever its
+         * {@link load_factor load factor} is going to surpass its {@link max_load_factor} in an operation.
+         *
+         * Notice that this function expects the number of buckets as argument. A similar function exists,
+         * {@link reserve}, that expects the number of elements in the container as argument.
+         *
+         * @param n The minimum number of buckets for the container hash table.
+         */
+        rehash(n: number): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * A common interface for hash set.
+     *
+     * {@link IHashSet}s are containers that store unique elements in no particular order, and which
+     * allow for fast retrieval of individual elements based on their value.
+     *
+     * In an {@link IHashSet}, the value of an element is at the same time its <i>key</i>, that
+     * identifies it uniquely. Keys are immutable, therefore, the elements in an {@link IHashSet} cannot be
+     * modified once in the container - they can be inserted and removed, though.
+     *
+     * Internally, the elements in the {@link IHashSet} are not sorted in any particular order, but
+     * organized into buckets depending on their hash values to allow for fast access to individual elements
+     * directly by their <i>values</i> (with a constant average time complexity on average).
+     *
+     * {@link IHashSet} containers are faster than {@link TreeSet} containers to access individual
+     * elements by their <i>key</i>, although they are generally less efficient for range iteration through a
+     * subset of their elements.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" style="max-width: 100%" /> </a>
+     *
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *			  Each element in an {@link IHashSet} is also uniquely identified by this value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IHashSet<T> extends SetContainer<T> {
+        /**
+         * Return number of buckets.
+         *
+         * Returns the number of buckets in the {@link IHashSet} container.
+         *
+         * A bucket is a slot in the container's internal hash table to which elements are assigned based on the
+         * hash value of their key.
+         *
+         * The number of buckets influences directly the {@link load_factor load factor} of the container's hash
+         * table (and thus the probability of collision). The container automatically increases the number of buckets to
+         * keep the load factor below a specific threshold (its {@link max_load_factor}), causing a {@link rehash} each
+         * time the number of buckets needs to be increased.
+         *
+         * @return The current amount of buckets.
+         */
+        bucket_count(): number;
+        /**
+         * Return bucket size.
+         *
+         * Returns the number of elements in bucket <i>n</i>.
+         *
+         * A bucket is a slot in the container's internal hash table to which elements are assigned based on the hash
+         * value of their key.
+         *
+         * The number of elements in a bucket influences the time it takes to access a particular element in the
+         * bucket. The container automatically increases the number of buckets to keep the {@link load_cator load factor}
+         * (which is the average bucket size) below its {@link max_load_factor}.
+         *
+         * @param n Bucket number. This shall be lower than {@link bucket_count}.
+         *
+         * @return The number of elements in bucket <i>n</i>.
+         */
+        bucket_size(n: number): number;
+        /**
+         * Get maximum load factor.
+         *
+         * Returns the current maximum load factor for the {@link HashMultiMap} container.
+         *
+         * The load factor is the ratio between the number of elements in the container (its {@link size}) and the
+         * number of buckets ({@link bucket_count}).
+         *
+         * By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0.
+         *
+         * The load factor influences the probability of collision in the hash table (i.e., the probability of two
+         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
+         * that forces an increase in the number of buckets (and thus causing a {@link rehash}).
+         *
+         * Note though, that implementations may impose an upper limit on the number of buckets (see
+         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}.
+         *
+         * @return The current load factor.
+         */
+        max_load_factor(): number;
+        /**
+         * Set maximum load factor.
+         *
+         * Sets <i>z</i> as the cnew maximum load factor for the {@link HashMultiMap} container.
+         *
+         * The load factor is the ratio between the number of elements in the container (its {@link size}) and the
+         * number of buckets ({@link bucket_count}).
+         *
+         * By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0.
+         *
+         * The load factor influences the probability of collision in the hash table (i.e., the probability of two
+         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
+         * that forces an increase in the number of buckets (and thus causing a {@link rehash}).
+         *
+         * Note though, that implementations may impose an upper limit on the number of buckets (see
+         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}.
+         *
+         * @param z The new maximum load factor.
+         */
+        max_load_factor(z: number): void;
+        /**
+         * Locate element's bucket.
+         *
+         * Returns the bucket number where the element with <i>key</i> is located.
+         *
+         * A bucket is a slot in the container's internal hash table to which elements are assigned based on the
+         * hash value of their <i>key</i>. Buckets are numbered from 0 to ({@link bucket_count} - 1).
+         *
+         * Individual elements in a bucket can be accessed by means of the range iterators returned by
+         * {@link begin} and {@link end}.
+         *
+         * @param key Key whose bucket is to be located.
+         */
+        bucket(key: T): number;
+        /**
+         * Request a capacity change.
+         *
+         * Sets the number of buckets in the container ({@link bucket_count}) to the most appropriate to contain at
+         * least <i>n</i> elements.
+         *
+         * If <i>n</i> is greater than the current {@link bucket_count} multiplied by the {@link max_load_factor},
+         * the container's {@link bucket_count} is increased and a {@link rehash} is forced.
+         *
+         * If <i>n</i> is lower than that, the function may have no effect.
+         *
+         * @param n The number of elements requested as minimum capacity.
+         */
+        reserve(n: number): void;
+        /**
+         * Set number of buckets.
+         *
+         * Sets the number of buckets in the container to <i>n</i> or more.
+         *
+         * If <i>n</i> is greater than the current number of buckets in the container ({@link bucket_count}), a
+         * {@link HashBuckets.rehash rehash} is forced. The new {@link bucket_count bucket count} can either be equal or
+         * greater than <i>n</i>.
+         *
+         * If <i>n</i> is lower than the current number of buckets in the container ({@link bucket_count}), the
+         * function may have no effect on the {@link bucket_count bucket count} and may not force a
+         * {@link HashBuckets.rehash rehash}.
+         *
+         * A {@link HashBuckets.rehash rehash} is the reconstruction of the hash table: All the elements in the
+         * container are rearranged according to their hash value into the new set of buckets. This may alter the order
+         * of iteration of elements within the container.
+         *
+         * {@link HashBuckets.rehash Rehashes} are automatically performed by the container whenever its
+         * {@link load_factor load factor} is going to surpass its {@link max_load_factor} in an operation.
+         *
+         * Notice that this function expects the number of buckets as argument. A similar function exists,
+         * {@link reserve}, that expects the number of elements in the container as argument.
+         *
+         * @param n The minimum number of buckets for the container hash table.
+         */
+        rehash(n: number): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * An interface for linear containers.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     *
+     *
+     * @author Jeonngho Nam
+     */
+    interface ILinearContainer<T> extends Container<T> {
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * Assign container content.
+         *
+         * Assigns new contents to the {@link IList container}, replacing its current contents,
+         * and modifying its {@link size} accordingly.
+         *
+         * @param n New size for the
+         * @param val Value to fill the container with. Each of the <u>n</u> elements in the container will
+         *			  be initialized to a copy of this value.
+         */
+        assign(n: number, val: T): void;
+        /**
+         * Access first element.
+         * Returns a value of the first element in the {@link IList container}.
+         *
+         * Unlike member {@link end end()}, which returns an iterator just past this element,
+         * this function returns a direct value.
+         *
+         * Calling this function on an {@link empty} {@link IList container} causes undefined behavior.
+         *
+         * @return A value of the first element of the {@link IList container}.
+         */
+        front(): T;
+        /**
+         * Access last element.
+         * Returns a value of the last element in the {@link IList container}.
+         *
+         * Unlike member {@link end end()}, which returns an iterator just past this element,
+         * this function returns a direct value.
+         *
+         * Calling this function on an {@link empty} {@link IList container} causes undefined behavior.
+         *
+         * @return A value of the last element of the {@link IList container}.
+         */
+        back(): T;
+        /**
+         * Add element at the end.
+         *
+         * Adds a new element at the end of the {@link IList container}, after its current last element.
+         * This effectively increases the {@link IList container} {@link size} by one.
+         *
+         * @param val Value to be copied to the new element.
+         */
+        push_back(val: T): void;
+        /**
+         * Delete last element.
+         *
+         * Removes the last element in the {@link IList container}, effectively reducing the
+         * {@link IList container} {@link size} by one.
+         */
+        pop_back(): void;
+        /**
+         * Insert an element.
+         *
+         * The {@link IList conatiner} is extended by inserting new element before the element at the
+         * specified <i>position</i>, effectively increasing the {@link IList container} {@link size} by
+         * one.
+         *
+         * @param position Position in the {@link IList container} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a {@link iterator random access iterator}
+         *				   type that points to elements.
+         * @param val Value to be copied to the inserted element.
+         *
+         * @return An iterator that points to the newly inserted element.
+         */
+        insert(position: Iterator<T>, val: T): Iterator<T>;
+        /**
+         * Insert elements by range iterators.
+         *
+         * The {@link IList container} is extended by inserting new elements before the element at the
+         * specified <i>position</i>, effectively increasing the {@link IList container} {@link size} by
+         * the number of repeating elements </i>n</i>.
+         *
+         * @param position Position in the {@link IList container} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a {@link iterator random access iterator}
+         *				   type that points to elements.
+         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
+         * @param val Value to be copied (or moved) to the inserted elements.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: Iterator<T>, n: number, val: T): Iterator<T>;
+        /**
+         * Insert elements by range iterators.
+         *
+         * The {@link IList container} is extended by inserting new elements before the element at the
+         * specified <i>position</i>, effectively increasing the {@link IList container} {@link size} by
+         * the number of elements inserted by range iterators.
+         *
+         * @param position Position in the {@link IList container} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a {@link iterator random access iterator}
+         *				   type that points to elements.
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: Iterator<T>, begin: InputIterator, end: InputIterator): Iterator<T>;
+    }
+    /**
+     * An interface for iterators from linear containers.
+     *
+     * {@link ILieanerIterator} is an bi-directional iterator which is created from the related
+     * {@link ILinearContainer linear containers}. Not only accessing to {@link value} of the pointed element from
+     * this {@link ILieanerIterator}, but also modifying the {@link value} is possible.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface ILinearIterator<T> extends Iterator<T> {
+        /**
+         * @inheritdoc
+         */
+        source(): ILinearContainer<T>;
+        /**
+         * @inheritdoc
+         */
+        value: T;
+        /**
+         * @inheritdoc
+         */
+        prev(): ILinearIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): ILinearIterator<T>;
+    }
+}
+declare namespace std.base {
+    /**
+     * Common interface for tree-structured map.
+     *
+     * {@link ITreeMap ITreeMaps} are associative containers that store elements formed by a combination of
+     * a <i>key value</i> and a <i>mapped value</i>, following a specific order.
+     *
+     * In a {@link ITreeMap}, the <i>key values</i> are generally used to sort and uniquely identify
+     * the elements, while the <i>mapped values</i> store the content associated to this <i>key</i>. The types of
+     * <i>key</i> and <i>mapped value</i> may differ, and are grouped together in member type
+     * <code>value_type</code>, which is a {@link Pair} type combining both:
+     *
+     * <code>typedef Pair<const Key, T> value_type;</code>
+     *
+     * Internally, the elements in a {@link ITreeMap}are always sorted by its key following a
+     * strict weak ordering criterion indicated by its internal comparison method (of {@link less}).
+     *
+     * {@link ITreeMap}containers are generally slower than {@link IHashMap} containers
+     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based
+     * on their order.
+     *
+     * {@link ITreeMap TreeMultiMaps} are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
+     *		 given a position in this order. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/map
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface ITreeMap<Key, T> extends MapContainer<Key, T> {
+        /**
+         * Return key comparison function.
+         *
+         * Returns a references of the comparison function used by the container to compare <i>keys</i>.
+         *
+         * The <i>comparison object</i> of a {@link ITreeMap tree-map object} is set on
+         * {@link TreeMap.constructor construction}. Its type (<i>Key</i>) is the last parameter of the
+         * {@link ITreeMap.constructor constructors}. By default, this is a {@link less} function, which returns the same
+         * as <i>operator&lt;</i>.
+         *
+         * This function determines the order of the elements in the container: it is a function pointer that takes
+         * two arguments of the same type as the element <i>keys</i>, and returns <code>true</code> if the first argument
+         * is considered to go before the second in the strict weak ordering it defines, and <code>false</code> otherwise.
+         *
+         *
+         * Two keys are considered equivalent if {@link key_comp} returns <code>false</code> reflexively (i.e., no
+         * matter the order in which the keys are passed as arguments).
+         *
+         * @return The comparison function.
+         */
+        key_comp(): (x: Key, y: Key) => boolean;
+        /**
+         * Return value comparison function.
+         *
+         * Returns a comparison function that can be used to compare two elements to get whether the key of the first
+         * one goes before the second.
+         *
+         * The arguments taken by this function object are of member type <code>Pair<Key, T></code> (defined in
+         * {@link ITreeMap}), but the mapped type (<i>T</i>) part of the value is not taken into consideration in this
+         * comparison.
+         *
+         * This comparison class returns <code>true</code> if the {@link Pair.first key} of the <i>first argument</i>
+         * is considered to go before that of the <i>second</i> (according to the strict weak ordering specified by the
+         * container's comparison function, {@link key_comp}), and <code>false</code> otherwise.
+         *
+         * @return The comparison function for element values.
+         */
+        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
+        /**
+         * Return iterator to lower bound.
+         *
+         * Returns an iterator pointing to the first element in the container whose key is not considered to
+         * go before <i>k</i> (i.e., either it is equivalent or goes after).
+         *
+         * The function uses its internal comparison object (key_comp) to determine this, returning an
+         * iterator to the first element for which key_comp(<i>k</i>, element_key) would return false.
+         *
+         * If the {@link ITreeMap} class is instantiated with the default comparison type ({@link less}),
+         * the function returns an iterator to the first element whose key is not less than <i>k</i>.
+         *
+         * A similar member function, {@link upper_bound}, has the same behavior as {@link lower_bound}, except
+         * in the case that the {@link ITreeMap} contains an element with a key equivalent to <i>k</i>: In this
+         * case, {@link lower_bound} returns an iterator pointing to that element, whereas {@link upper_bound}
+         * returns an iterator pointing to the next element.
+         *
+         * @param k Key to search for.
+         *
+         * @return An iterator to the the first element in the container whose key is not considered to go before
+         *		   <i>k</i>, or {@link ITreeMap.end} if all keys are considered to go before <i>k</i>.
+         */
+        lower_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * Return iterator to upper bound.
+         *
+         * Returns an iterator pointing to the first element in the container whose key is considered to
+         * go after <i>k</i>.
+         *
+         * The function uses its internal comparison object (key_comp) to determine this, returning an
+         * iterator to the first element for which key_comp(<i>k</i>, element_key) would return true.
+         *
+         * If the {@link ITreeMap} class is instantiated with the default comparison type ({@link less}),
+         * the function returns an iterator to the first element whose key is greater than <i>k</i>.
+         *
+         * A similar member function, {@link lower_bound}, has the same behavior as {@link upper_bound}, except
+         * in the case that the map contains an element with a key equivalent to <i>k</i>: In this case
+         * {@link lower_bound} returns an iterator pointing to that element, whereas {@link upper_bound} returns an
+         * iterator pointing to the next element.
+         *
+         * @param k Key to search for.
+         *
+         * @return An iterator to the the first element in the container whose key is considered to go after
+         *		   <i>k</i>, or {@link TreeMap.end end} if no keys are considered to go after <i>k</i>.
+         */
+        upper_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * Get range of equal elements.
+         *
+         * Returns the bounds of a range that includes all the elements in the container which have a key
+         * equivalent to <i>k</i>.
+         *
+         * If no matches are found, the range returned has a length of zero, with both iterators pointing to
+         * the first element that has a key considered to go after <i>k</i> according to the container's internal
+         * comparison object (key_comp).
+         *
+         * Two keys are considered equivalent if the container's comparison object returns false reflexively
+         * (i.e., no matter the order in which the keys are passed as arguments).
+         *
+         * @param k Key to search for.
+         *
+         * @return The function returns a {@link Pair}, whose member {@link Pair.first} is the lower bound of
+         *		   the range (the same as {@link lower_bound}), and {@link Pair.second} is the upper bound
+         *		   (the same as {@link upper_bound}).
+         */
+        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
+    }
+}
+declare namespace std.base {
+    /**
+     * A common interface for tree-structured set.
+     *
+     * {@link ITreeSet TreeMultiSets} are containers that store elements following a specific order.
+     *
+     * In a {@link ITreeSet}, the value of an element also identifies it (the value is itself
+     * the <i>key</i>, of type <i>T</i>). The value of the elements in a {@link ITreeSet} cannot
+     * be modified once in the container (the elements are always const), but they can be inserted or removed
+     * from the
+     *
+     * Internally, the elements in a {@link ITreeSet TreeMultiSets} are always sorted following a strict
+     * weak ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}).
+     *
+     * {@link ITreeSet} containers are generally slower than {@link IHashSet} containers
+     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on
+     * their order.
+     *
+     * {@link ITreeSet TreeMultiSets} are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link ITreeSet} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @reference http://www.cplusplus.com/reference/set
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface ITreeSet<T> extends SetContainer<T> {
+        /**
+         * Return comparison function.
+         *
+         * Returns a copy of the comparison function used by the container.
+         *
+         * By default, this is a {@link less} object, which returns the same as <i>operator<</i>.
+         *
+         * This object determines the order of the elements in the container: it is a function pointer or a function
+         * object that takes two arguments of the same type as the container elements, and returns <code>true</code> if
+         * the <i>first argument</i> is considered to go before the <i>second</i> in the <i>strict weak ordering</i> it
+         * defines, and <code>false</code> otherwise.
+         *
+         * Two elements of a {@link ITreeSet} are considered equivalent if {@link key_comp} returns <code>false</code>
+         * reflexively (i.e., no matter the order in which the elements are passed as arguments).
+         *
+         * In {@link ITreeSet} containers, the <i>keys</i> to sort the elements are the values (<i>T</i>) themselves,
+         * therefore {@link key_comp} and its sibling member function {@link value_comp} are equivalent.
+         *
+         * @return The comparison function.
+         */
+        key_comp(): (x: T, y: T) => boolean;
+        /**
+         * Return comparison function.
+         *
+         * Returns a copy of the comparison function used by the container.
+         *
+         * By default, this is a {@link less} object, which returns the same as <i>operator<</i>.
+         *
+         * This object determines the order of the elements in the container: it is a function pointer or a function
+         * object that takes two arguments of the same type as the container elements, and returns <code>true</code> if
+         * the <i>first argument</i> is considered to go before the <i>second</i> in the <i>strict weak ordering</i> it
+         * defines, and <code>false</code> otherwise.
+         *
+         * Two elements of a {@link ITreeSet} are considered equivalent if {@link key_comp} returns <code>false</code>
+         * reflexively (i.e., no matter the order in which the elements are passed as arguments).
+         *
+         * In {@link ITreeSet} containers, the <i>keys</i> to sort the elements are the values (<i>T</i>) themselves,
+         * therefore {@link key_comp} and its sibling member function {@link value_comp} are equivalent.
+         *
+         * @return The comparison function.
+         */
+        value_comp(): (x: T, y: T) => boolean;
+        /**
+         * Return iterator to lower bound.
+         *
+         * Returns an iterator pointing to the first element in the container which is not considered to
+         * go before <i>val</i> (i.e., either it is equivalent or goes after).
+         *
+         * The function uses its internal comparison object (key_comp) to determine this, returning an
+         * iterator to the first element for which key_comp(element,val) would return false.
+         *
+         * If the {@link ITreeSet} class is instantiated with the default comparison type ({@link less}),
+         * the function returns an iterator to the first element that is not less than <i>val</i>.
+
+         * A similar member function, {@link upper_bound}, has the same behavior as {@link lower_bound}, except
+         * in the case that the {@link ITreeSet} contains elements equivalent to <i>val</i>: In this case
+         * {@link lower_bound} returns an iterator pointing to the first of such elements, whereas
+         * {@link upper_bound} returns an iterator pointing to the element following the last.
+         *
+         * @param val Value to compare.
+         *
+         * @return An iterator to the the first element in the container which is not considered to go before
+         *		   <i>val</i>, or {@link ITreeSet.end} if all elements are considered to go before <i>val</i>.
+         */
+        lower_bound(val: T): SetIterator<T>;
+        /**
+         * Return iterator to upper bound.
+         *
+         * Returns an iterator pointing to the first element in the container which is considered to go after
+         * <i>val</i>.
+
+         * The function uses its internal comparison object (key_comp) to determine this, returning an
+         * iterator to the first element for which key_comp(val,element) would return true.
+
+         * If the {@code ITreeSet} class is instantiated with the default comparison type (less), the
+         * function returns an iterator to the first element that is greater than <i>val</i>.
+         *
+         * A similar member function, {@link lower_bound}, has the same behavior as {@link upper_bound}, except
+         * in the case that the {@ITreeSet} contains elements equivalent to <i>val</i>: In this case
+         * {@link lower_bound} returns an iterator pointing to the first of such elements, whereas
+         * {@link upper_bound} returns an iterator pointing to the element following the last.
+         *
+         * @param val Value to compare.
+         *
+         * @return An iterator to the the first element in the container which is considered to go after
+         *		   <i>val</i>, or {@link TreeSet.end end} if no elements are considered to go after <i>val</i>.
+         */
+        upper_bound(val: T): SetIterator<T>;
+        /**
+         * Get range of equal elements.
+         *
+         * Returns the bounds of a range that includes all the elements in the container that are equivalent
+         * to <i>val</i>.
+         *
+         * If no matches are found, the range returned has a length of zero, with both iterators pointing to
+         * the first element that is considered to go after val according to the container's
+         * internal comparison object (key_comp).
+         *
+         * Two elements of a multiset are considered equivalent if the container's comparison object returns
+         * false reflexively (i.e., no matter the order in which the elements are passed as arguments).
+         *
+         * @param key Value to search for.
+         *
+         * @return The function returns a {@link Pair}, whose member {@link Pair.first} is the lower bound of
+         *		   the range (the same as {@link lower_bound}), and {@link Pair.second} is the upper bound
+         *		   (the same as {@link upper_bound}).
+         */
+        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    class _ArrayIterator<T> extends Iterator<T> {
+        private data_;
+        private index_;
+        constructor(data: Array<T>, index: number);
+        source(): Container<T>;
+        index(): number;
+        readonly value: T;
+        prev(): _ArrayIterator<T>;
+        next(): _ArrayIterator<T>;
+        advance(n: number): _ArrayIterator<T>;
+        equals(obj: _ArrayIterator<T>): boolean;
+        swap(obj: _ArrayIterator<T>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    class _Repeater<T> extends Iterator<T> {
+        private index_;
+        private value_;
+        constructor(index: number, value?: T);
+        source(): base.Container<T>;
+        index(): number;
+        readonly value: T;
+        prev(): _Repeater<T>;
+        next(): _Repeater<T>;
+        advance(n: number): _Repeater<T>;
+        equals(obj: _Repeater<T>): boolean;
+        swap(obj: _Repeater<T>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * An abstract map.
+     *
+     * {@link MapContainer MapContainers} are associative containers that store elements formed by a combination
+     * of a <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval
+     * of individual elements based on their keys.
+     *
+     * In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
+     * <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
+     * {@link Pair} type combining both:
+     *
+     * <code>typedef pair<const Key, T> value_type;</code>
+     *
+     * {@link MapContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
+     *		in the container.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MapContainer<Key, T> extends Container<Pair<Key, T>> {
+        /**
+         * @hidden
+         */
+        private data_;
+        /**
+         * Default Constructor.
+         */
+        protected constructor();
+        /**
+         * @inheritdoc
+         */
+        assign<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * Get iterator to element.
+         *
+         * Searches the container for an element with a identifier equivalent to <i>key</i> and returns an
+         * iterator to it if found, otherwise it returns an iterator to {@link end end()}.
+         *
+         * Two keys are considered equivalent if the container's comparison object returns false reflexively
+         * (i.e., no matter the order in which the elements are passed as arguments).
+         *
+         * Another member functions, {@link has has()} and {@link count count()}, can be used to just check
+         * whether a particular <i>key</i> exists.
+         *
+         * @param key Key to be searched for
+         * @return An iterator to the element, if an element with specified <i>key</i> is found, or
+         *		   {@link end end()} otherwise.
+         */
+        abstract find(key: Key): MapIterator<Key, T>;
+        /**
+         * Return iterator to beginning.
+         *
+         * Returns an iterator referring the first element in the
+         *
+         * #### Note
+         * If the container is {@link empty}, the returned iterator is same with {@link end end()}.
+         *
+         * @return An iterator to the first element in the  The iterator containes the first element's value.
+         */
+        begin(): MapIterator<Key, T>;
+        /**
+         * Return iterator to end.
+         * Returns an iterator referring to the past-the-end element in the
+         *
+         * The past-the-end element is the theoretical element that would follow the last element in the
+         *  It does not point to any element, and thus shall not be dereferenced.
+         *
+         * Because the ranges used by functions of the container do not include the element reference by their
+         * closing iterator, this function is often used in combination with {@link MapContainer}.{@link begin} to
+         * specify a range including all the elements in the
+         *
+         * #### Note
+         * Returned iterator from {@link MapContainer}.{@link end} does not refer any element. Trying to accessing
+         * element by the iterator will cause throwing exception ({@link OutOfRange}).
+         *
+         * If the container is {@link empty}, this function returns the same as {@link begin}.
+         *
+         * @return An iterator to the end element in the
+         */
+        end(): MapIterator<Key, T>;
+        /**
+         * Return {@link MapReverseIterator reverse iterator} to <i>reverse beginning</i>.
+         *
+         * Returns a {@link MapReverseIterator reverse iterator} pointing to the last element in the container
+         * (i.e., its <i>reverse beginning</i>).
+         *
+         * {@link MapReverseIterator Reverse iterators} iterate backwards: increasing them moves them towards the
+         * beginning of the container.
+         *
+         * {@link rbegin} points to the element preceding the one that would be pointed to by member {@link end}.
+         *7
+         *
+         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
+         *
+         */
+        rbegin(): MapReverseIterator<Key, T>;
+        /**
+         * Return {@link MapReverseIterator reverse iterator} to <i>reverse end</i>.
+         *
+         * Returns a {@link MapReverseIterator reverse iterator} pointing to the theoretical element right before
+         * the first element in the {@link MapContainer map container} (which is considered its <i>reverse end</i>).
+         *
+         *
+         * The range between {@link MapContainer}.{@link rbegin} and {@link MapContainer}.{@link rend} contains
+         * all the elements of the container (in reverse order).
+         *
+         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence
+         */
+        rend(): MapReverseIterator<Key, T>;
+        /**
+         * Whether have the item or not.
+         *
+         * Indicates whether a map has an item having the specified identifier.
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @return Whether the map has an item having the specified identifier.
+         */
+        has(key: Key): boolean;
+        /**
+         * Count elements with a specific key.
+         *
+         * Searches the container for elements whose key is <i>key</i> and returns the number of elements found.
+         *
+         * @param key Key value to be searched for.
+         *
+         * @return The number of elements in the container with a <i>key</i>.
+         */
+        abstract count(key: Key): number;
+        /**
+         * Return the number of elements in the map.
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        push(...args: Pair<Key, T>[]): number;
+        /**
+         * @inheritdoc
+         */
+        push(...args: [Key, T][]): number;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapIterator<Key, T>, key: Key, val: T): MapIterator<Key, T>;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
+         *		   that already had an equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapReverseIterator<Key, T>, key: Key, val: T): MapReverseIterator<Key, T>;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
+         *		   that already had an equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting a new element, effectively increasing the container {@link size}
+         * by the number of element inserted (zero or one).
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting a new element, effectively increasing the container {@link size}
+         * by the number of element inserted (zero or one).
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size}
+         * by the number of elements inserted.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size}
+         * by the number of elements inserted.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
+        /**
+         * Insert elements from range iterators.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted.
+         *
+         * @param begin Input iterator specifying initial position of a range of elements.
+         * @param end Input iterator specifying final position of a range of elements.
+         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
+         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_pair<L extends Key, U extends T>(pair: Pair<L, U>): any;
+        /**
+         * @hidden
+         */
+        private _Insert_by_tuple<L, U>(tuple);
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private _Insert_by_hint_with_tuple(hint, tuple);
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * Erase an elemet by key.
+         *
+         * Removes from the {@link MapContainer map container} a single element.
+         *
+         * This effectively reduces the container {@link size} by the number of element removed (zero or one),
+         * which are destroyed.
+         *
+         * @param key Key of the element to be removed from the {@link MapContainer}.
+         */
+        erase(key: Key): number;
+        /**
+         * Erase an elemet by iterator.
+         *
+         * Removes from the {@link MapContainer map container} a single element.
+         *
+         * This effectively reduces the container {@link size} by the number of element removed (zero or one),
+         * which are destroyed.
+         *
+         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
+         */
+        erase(it: MapIterator<Key, T>): MapIterator<Key, T>;
+        /**
+         * Erase elements by range iterators.
+         *
+         * Removes from the {@link MapContainer map container} a range of elements.
+         *
+         * This effectively reduces the container {@link size} by the number of elements removed, which are
+         * destroyed.
+         *
+         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
+         *				to be removed.
+         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
+         *			  to be removed.
+         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
+         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        erase(begin: MapIterator<Key, T>, end: MapIterator<Key, T>): MapIterator<Key, T>;
+        /**
+         * Erase an elemet by iterator.
+         *
+         * Removes from the {@link MapContainer map container} a single element.
+         *
+         * This effectively reduces the container {@link size} by the number of element removed (zero or one),
+         * which are destroyed.
+         *
+         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
+         */
+        erase(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * Erase elements by range iterators.
+         *
+         * Removes from the {@link MapContainer map container} a range of elements.
+         *
+         * This effectively reduces the container {@link size} by the number of elements removed, which are
+         * destroyed.
+         *
+         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
+         *				to be removed.
+         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
+         *			  to be removed.
+         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
+         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        erase(begin: MapReverseIterator<Key, T>, end: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private _Erase_by_key(key);
+        /**
+         * @hidden
+         */
+        private _Erase_by_iterator(first, last?);
+        /**
+         * @hidden
+         */
+        private _Erase_by_range(first, last);
+        /**
+         * @hidden
+         */
+        protected _Swap(obj: MapContainer<Key, T>): void;
+        /**
+         * Merge two maps.
+         *
+         * Extracts and transfers elements from *source* to this container.
+         *
+         * @param source A {@link MapContainer map container} to transfer the elements from.
+         */
+        abstract merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+    }
+    /**
+     * @hidden
+     */
+    class _MapElementList<Key, T> extends _ListContainer<Pair<Key, T>, MapIterator<Key, T>> {
+        private associative_;
+        private rend_;
+        constructor(associative: MapContainer<Key, T>);
+        protected _Create_iterator(prev: MapIterator<Key, T>, next: MapIterator<Key, T>, val: Pair<Key, T>): MapIterator<Key, T>;
+        protected _Set_begin(it: MapIterator<Key, T>): void;
+        associative(): MapContainer<Key, T>;
+        rbegin(): MapReverseIterator<Key, T>;
+        rend(): MapReverseIterator<Key, T>;
+    }
+}
+declare namespace std {
+    /**
+     * An iterator of {@link MapContainer map container}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram" style="max-width: 100%" /></a>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MapIterator<Key, T> extends base._ListIteratorBase<Pair<Key, T>> implements IComparable<MapIterator<Key, T>> {
+        /**
+         * Construct from the {@link MapContainer source map} and {@link ListIterator list iterator}.
+         *
+         * @param source The source {@link MapContainer}.
+         * @param list_iterator A {@link ListIterator} pointing {@link Pair} of <i>key</i> and <i>value</i>.
+         */
+        constructor(source: base._MapElementList<Key, T>, prev: MapIterator<Key, T>, next: MapIterator<Key, T>, val: Pair<Key, T>);
+        /**
+         * Get iterator to previous element.
+         */
+        prev(): MapIterator<Key, T>;
+        /**
+         * Get iterator to next element.
+         */
+        next(): MapIterator<Key, T>;
+        /**
+         * Advances the Iterator by n element positions.
+         *
+         * @param step Number of element positions to advance.
+         * @return An advanced Iterator.
+         */
+        advance(step: number): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        source(): base.MapContainer<Key, T>;
+        /**
+         * Get first, key element.
+         */
+        readonly first: Key;
+        /**
+         * Get second, value element.
+         */
+        /**
+         * Set second value.
+         */
+        second: T;
+        /**
+         * @inheritdoc
+         */
+        less(obj: MapIterator<Key, T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        equals(obj: MapIterator<Key, T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        hashCode(): number;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: MapIterator<Key, T>): void;
+    }
+    /**
+     * A reverse-iterator of {@link MapContainer map container}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram" style="max-width: 100%" /></a>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MapReverseIterator<Key, T> extends ReverseIterator<Pair<Key, T>, base.MapContainer<Key, T>, MapIterator<Key, T>, MapReverseIterator<Key, T>> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: MapIterator<Key, T>);
+        /**
+         * @hidden
+         */
+        protected _Create_neighbor(base: MapIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * Get first, key element.
+         */
+        readonly first: Key;
+        /**
+         * Get second, value element.
+         */
+        /**
+         * Set second value.
+         */
+        second: T;
+    }
+}
+declare namespace std.base {
+    /**
+     * An abstract multi-map.
+     *
+     * {@link MultiMap MultiMaps} are associative containers that store elements formed by a combination of a
+     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
+     * individual elements based on their keys.
+     *
+     * In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
+     * <i>mapped values</i> store the content associated to this <i>key</i>. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
+     * {@link Pair} type combining both:
+     *
+     * <code>typedef pair<const Key, T> value_type;</code>
+     *
+     * {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
+     *		in the container.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MultiMap<Key, T> extends MapContainer<Key, T> {
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
+         * as the arguments for the element's constructor.
+         *
+         * This effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An {@link MapIterator iterator} to the newly inserted element.
+         */
+        emplace(key: Key, value: T): MapIterator<Key, T>;
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
+         * as the arguments for the element's constructor.
+         *
+         * This effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         * @return An {@link MapIterator iterator} to the newly inserted element.
+         */
+        emplace(pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * Insert elements.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted.
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to the newly inserted element.
+         */
+        insert(pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * Insert elements.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted.
+         *
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return An iterator pointing to the newly inserted element.
+         */
+        insert<L extends Key, U extends T>(tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * An abstract set.
+     *
+     * {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
+     * individual elements based on their value.
+     *
+     * In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
+     * modified once in the container - they can be inserted and removed, though.
+     *
+     * {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class SetContainer<T> extends Container<T> {
+        /**
+         * {@link List} storing elements.
+         *
+         * Storing elements and keeping those sequence of the {@link SetContainer} are implemented by
+         * {@link data_ this list container}. Implementing index-table is also related with {@link data_ this list}
+         * by storing {@link ListIterator iterators} ({@link SetIterator} references {@link ListIterator}) who are
+         * created from {@link data_ here}.
+         */
+        private data_;
+        /**
+         * Default Constructor.
+         */
+        protected constructor();
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: Iterator<U>, end: Iterator<U>): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * Get iterator to element.
+         *
+         * Searches the container for an element with <i>key</i> as value and returns an iterator to it if found,
+         * otherwise it returns an iterator to {@link end end()} (the element past the end of the container).
+         *
+         * Another member function, {@link count count()}, can be used to just check whether a particular element
+         * exists.
+         *
+         * @param key Key to be searched for.
+         *
+         * @return An iterator to the element, if the specified value is found, or {@link end end()} if it is not
+         *		   found in the
+         */
+        abstract find(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): SetReverseIterator<T>;
+        /**
+         * Whether have the item or not.
+         *
+         * Indicates whether a set has an item having the specified identifier.
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @return Whether the set has an item having the specified identifier.
+         */
+        has(val: T): boolean;
+        /**
+         * Count elements with a specific key.
+         *
+         * Searches the container for elements with a value of k and returns the number of elements found.
+         *
+         * @param key Value of the elements to be counted.
+         *
+         * @return The number of elements in the container with a <i>key</i>.
+         */
+        abstract count(val: T): number;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        push(...items: T[]): number;
+        /**
+         * Insert an element with hint.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container size by the
+         * number of elements inserted.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had its
+         *		   same value in the {@link SetContainer}.
+         */
+        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * Insert an element with hint.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container size by the
+         * number of elements inserted.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had its
+         *		   same value in the {@link SetContainer}.
+         */
+        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
+        /**
+         * Insert elements with a range of a
+         *
+         * Extends the container by inserting new elements, effectively increasing the container size by the
+         * number of elements inserted.
+         *
+         * @param begin An iterator specifying range of the begining element.
+         * @param end An iterator specifying range of the ending element.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * Erase an element.
+         * Removes from the set container the elements whose value is <i>key</i>.
+         *
+         * This effectively reduces the container size by the number of elements removed.
+         *
+         * @param key Value of the elements to be erased.
+         *
+         * @return Number of elements erased.
+         */
+        erase(val: T): number;
+        /**
+         * @inheritdoc
+         */
+        erase(it: SetIterator<T>): SetIterator<T>;
+        /**
+         * Erase elements.
+         * Removes from the set container a range of elements..
+         *
+         * This effectively reduces the container size by the number of elements removed.
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         */
+        erase(begin: SetIterator<T>, end: SetIterator<T>): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(it: SetReverseIterator<T>): SetReverseIterator<T>;
+        /**
+         * Erase elements.
+         * Removes from the set container a range of elements..
+         *
+         * This effectively reduces the container size by the number of elements removed.
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         */
+        erase(begin: SetReverseIterator<T>, end: SetReverseIterator<T>): SetReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Erase_by_iterator(first, last?);
+        /**
+         * @hidden
+         */
+        private _Erase_by_val(val);
+        /**
+         * @hidden
+         */
+        private _Erase_by_range(first, last);
+        /**
+         * @hidden
+         */
+        protected _Swap(obj: SetContainer<T>): void;
+        /**
+         * Merge two sets.
+         *
+         * Extracts and transfers elements from *source* to this container.
+         *
+         * @param source A {@link SetContainer set container} to transfer the elements from.
+         */
+        abstract merge<U extends T>(source: SetContainer<U>): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+    }
+    /**
+     * @hidden
+     */
+    class _SetElementList<T> extends _ListContainer<T, SetIterator<T>> {
+        private associative_;
+        private rend_;
+        constructor(associative: SetContainer<T>);
+        protected _Create_iterator(prev: SetIterator<T>, next: SetIterator<T>, val: T): SetIterator<T>;
+        protected _Set_begin(it: SetIterator<T>): void;
+        associative(): SetContainer<T>;
+        rbegin(): SetReverseIterator<T>;
+        rend(): SetReverseIterator<T>;
+    }
+}
+declare namespace std {
+    /**
+     * An iterator of a Set.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class SetIterator<T> extends base._ListIteratorBase<T> implements IComparable<SetIterator<T>> {
+        /**
+         * Construct from source and index number.
+         *
+         * #### Note
+         * Do not create iterator directly.
+         *
+         * Use begin(), find() or end() in Map instead.
+         *
+         * @param map The source Set to reference.
+         * @param index Sequence number of the element in the source Set.
+         */
+        constructor(source: base._SetElementList<T>, prev: SetIterator<T>, next: SetIterator<T>, val: T);
+        /**
+         * @inheritdoc
+         */
+        source(): base.SetContainer<T>;
+        /**
+         * @inheritdoc
+         */
+        prev(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(size: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        less(obj: SetIterator<T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        equals(obj: SetIterator<T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        hashCode(): number;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: SetIterator<T>): void;
+    }
+    /**
+     * A reverse-iterator of Set.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class SetReverseIterator<T> extends ReverseIterator<T, base.SetContainer<T>, SetIterator<T>, SetReverseIterator<T>> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: SetIterator<T>);
+        /**
+         * @hidden
+         */
+        protected _Create_neighbor(base: SetIterator<T>): SetReverseIterator<T>;
+    }
+}
+declare namespace std.base {
+    /**
+     * An abstract set.
+     *
+     * {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
+     * individual elements based on their value.
+     *
+     * In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
+     * modified once in the container - they can be inserted and removed, though.
+     *
+     * {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MultiSet<T> extends SetContainer<T> {
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted.
+         *
+         * @param key Value to be inserted as an element.
+         *
+         * @return An iterator to the newly inserted element.
+         */
+        insert(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        merge<U extends T>(source: SetContainer<U>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    enum _Color {
+        BLACK = 0,
+        RED = 1,
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    abstract class _XTree<T> {
+        protected root_: _XTreeNode<T>;
+        protected constructor();
+        clear(): void;
+        find(val: T): _XTreeNode<T>;
+        protected _Fetch_maximum(node: _XTreeNode<T>): _XTreeNode<T>;
+        abstract is_less(left: T, right: T): boolean;
+        abstract is_equal_to(left: T, right: T): boolean;
+        insert(val: T): void;
+        private _Insert_case1(N);
+        private _Insert_case2(N);
+        private _Insert_case3(N);
+        private _Insert_case4(node);
+        private _Insert_case5(node);
+        erase(val: T): void;
+        private _Erase_case1(N);
+        private _Erase_case2(N);
+        private _Erase_case3(N);
+        private _Erase_case4(N);
+        private _Erase_case5(N);
+        private _Erase_case6(node);
+        protected _Rotate_left(node: _XTreeNode<T>): void;
+        protected _Rotate_right(node: _XTreeNode<T>): void;
+        protected _Replace_node(oldNode: _XTreeNode<T>, newNode: _XTreeNode<T>): void;
+        private _Fetch_color(node);
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    class _MapTree<Key, T> extends _XTree<MapIterator<Key, T>> {
+        private map_;
+        private compare_;
+        constructor(map: ITreeMap<Key, T>, compare?: (x: Key, y: Key) => boolean);
+        find(key: Key): _XTreeNode<MapIterator<Key, T>>;
+        find(it: MapIterator<Key, T>): _XTreeNode<MapIterator<Key, T>>;
+        private _Find_by_key(key);
+        lower_bound(key: Key): MapIterator<Key, T>;
+        upper_bound(key: Key): MapIterator<Key, T>;
+        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
+        key_comp(): (x: Key, y: Key) => boolean;
+        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
+        is_equal_to(left: MapIterator<Key, T>, right: MapIterator<Key, T>): boolean;
+        is_less(left: MapIterator<Key, T>, right: MapIterator<Key, T>): boolean;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    class _SetTree<T> extends _XTree<SetIterator<T>> {
+        private set_;
+        private compare_;
+        /**
+         * Default Constructor.
+         */
+        constructor(set: ITreeSet<T>, compare?: (x: T, y: T) => boolean);
+        find(val: T): _XTreeNode<SetIterator<T>>;
+        find(it: SetIterator<T>): _XTreeNode<SetIterator<T>>;
+        private _Find_by_val(val);
+        lower_bound(val: T): SetIterator<T>;
+        upper_bound(val: T): SetIterator<T>;
+        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
+        key_comp(): (x: T, y: T) => boolean;
+        value_comp(): (x: T, y: T) => boolean;
+        is_equal_to(left: SetIterator<T>, right: SetIterator<T>): boolean;
+        is_less(left: SetIterator<T>, right: SetIterator<T>): boolean;
+    }
+}
+declare namespace std.base {
+    /**
+     * @hidden
+     */
+    class _XTreeNode<T> {
+        parent: _XTreeNode<T>;
+        left: _XTreeNode<T>;
+        right: _XTreeNode<T>;
+        value: T;
+        color: _Color;
+        constructor(value: T, color: _Color);
+        readonly grandParent: _XTreeNode<T>;
+        readonly sibling: _XTreeNode<T>;
+        readonly uncle: _XTreeNode<T>;
+    }
+}
+declare namespace std.base {
+    /**
+     * An abstract unique-map.
+     *
+     * {@link UniqueMap UniqueMaps} are associative containers that store elements formed by a combination of a
+     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
+     * individual elements based on their keys.
+     *
+     * In a {@link MapContainer}, the <i>key values</i> are generally used to uniquely identify the elements,
+     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
+     * {@link Pair} type combining both:
+     *
+     * <code>typedef pair<const Key, T> value_type;</code>
+     *
+     * {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
+     *		in the container.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class UniqueMap<Key, T> extends MapContainer<Key, T> {
+        /**
+         * @inheritdoc
+         */
+        count(key: Key): number;
+        /**
+         * Get an element
+         *
+         * Returns a reference to the mapped value of the element identified with <i>key</i>.
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @throw exception out of range
+         *
+         * @return A reference object of the mapped value (_Ty)
+         */
+        get(key: Key): T;
+        /**
+         * Set an item as the specified identifier.
+         *
+         * If the identifier is already in map, change value of the identifier. If not, then insert the object
+         * with the identifier.
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         * @param val Value, the item.
+         */
+        set(key: Key, val: T): void;
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
+         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
+         * {@link Pair} type).
+         *
+         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
+         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
+         *
+         * If inserted, this effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return If the function successfully inserts the element (because no equivalent element existed already in
+         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
+         *		   the newly inserted element and a value of true. Otherwise, it returns an
+         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
+         */
+        emplace(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
+         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
+         * {@link Pair} type).
+         *
+         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
+         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
+         *
+         * If inserted, this effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return If the function successfully inserts the element (because no equivalent element existed already in
+         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
+         *		   the newly inserted element and a value of true. Otherwise, it returns an
+         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
+         */
+        emplace(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * one.
+         *
+         * Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is not inserted, returning an iterator to this existing element (if the function
+         * returns a value).
+         *
+         * For a similar container allowing for duplicate elements, see {@link MultiMap}.
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent key already existed.
+         */
+        insert(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting a new element, effectively increasing the container size by the
+         * number of elements inserted.
+         *
+         * Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is not inserted, returning an iterator to this existing element (if the function
+         * returns a value).
+         *
+         * For a similar container allowing for duplicate elements, see {@link MultiMap}.
+         *
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent key already existed.
+         */
+        insert<L extends Key, U extends T>(tuple: [L, U]): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * Insert or assign an element.
+         *
+         * Inserts an element or assigns to the current element if the <i>key</i> already exists.
+         *
+         * Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
+         * value).
+         *
+         * For a similar container allowing for duplicate elements, see {@link MultiMap}.
+         *
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent key already existed so the <i>value</i> is assigned.
+         */
+        insert_or_assign(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * Insert or assign an element.
+         *
+         * Inserts an element or assigns to the current element if the <i>key</i> already exists.
+         *
+         * Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
+         * value).
+         *
+         * For a similar container allowing for duplicate elements, see {@link MultiMap}.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link UniqueMap}.
+         */
+        insert_or_assign(hint: MapIterator<Key, T>, key: Key, value: T): MapIterator<Key, T>;
+        /**
+         * Insert or assign an element.
+         *
+         * Inserts an element or assigns to the current element if the <i>key</i> already exists.
+         *
+         * Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
+         * value).
+         *
+         * For a similar container allowing for duplicate elements, see {@link MultiMap}.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link UniqueMap}.
+         */
+        insert_or_assign(hint: MapReverseIterator<Key, T>, key: Key, value: T): MapReverseIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private _Insert_or_assign_with_key_value(key, value);
+        /**
+         * @hidden
+         */
+        private _Insert_or_assign_with_hint(hint, key, value);
+        /**
+         * Extract an element.
+         *
+         * Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}.
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @return A {@link Pair} containing the value pointed to by <i>key</i>.
+         */
+        extract(key: Key): Pair<Key, T>;
+        /**
+         * Extract an element.
+         *
+         * Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}.
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: MapIterator<Key, T>): MapIterator<Key, T>;
+        /**
+         * Extract an element.
+         *
+         * Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}.
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private _Extract_by_key(key);
+        /**
+         * @hidden
+         */
+        private _Extract_by_iterator(it);
+        /**
+         * @hidden
+         */
+        private _Extract_by_reverse_iterator(it);
+        /**
+         * Merge two maps.
+         *
+         * Attempts to extract each element in *source* and insert it into this container. If there's an element in this
+         * container with key equivalent to the key of an element from *source*, tnen that element is not extracted from
+         * the *source*. Otherwise, no element with same key exists in this container, then that element will be
+         * transfered from the *source* to this container.
+         *
+         * @param source A {@link MapContainer map container} to transfer the elements from.
+         */
+        merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * An abstract set.
+     *
+     * {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
+     * individual elements based on their value.
+     *
+     * In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to uniquely
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be modified
+     * once in the container - they can be inserted and removed, though.
+     *
+     * {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class UniqueSet<T> extends SetContainer<T> {
+        /**
+         * @inheritdoc
+         */
+        count(key: T): number;
+        /**
+         * Insert an element.
+         *
+         * Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of element inserted (zero or one).
+         *
+         * Because elements in a {@link UniqueSet UniqueSets} are unique, the insertion operation checks whether
+         * each inserted element is equivalent to an element already in the container, and if so, the element is not
+         * inserted, returning an iterator to this existing element (if the function returns a value).
+         *
+         * For a similar container allowing for duplicate elements, see {@link MultiSet}.
+         *
+         * @param key Value to be inserted as an element.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the equivalent element already in the {@link UniqueSet}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent element already existed.
+         */
+        insert(val: T): Pair<SetIterator<T>, boolean>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * Extract an element.
+         *
+         * Extracts the element pointed to by <i>val</i> and erases it from the {@link UniqueSet}.
+         *
+         * @param val Value to be extracted.
+         *
+         * @return A value.
+         */
+        extract(val: T): T;
+        /**
+         * Extract an element.
+         *
+         * Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}.
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: SetIterator<T>): SetIterator<T>;
+        /**
+         * Extract an element.
+         *
+         * Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}.
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: SetReverseIterator<T>): SetReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Extract_by_key(val);
+        /**
+         * @hidden
+         */
+        private _Extract_by_iterator(it);
+        /**
+         * @hidden
+         */
+        private _Extract_by_reverse_iterator(it);
+        /**
+         * Merge two sets.
+         *
+         * Attempts to extract each element in *source* and insert it into this container. If there's an element in this
+         * container with key equivalent to the key of an element from *source*, tnen that element is not extracted from
+         * the *source*. Otherwise, no element with same key exists in this container, then that element will be
+         * transfered from the *source* to this container.
+         *
+         * @param source A {@link SetContainer set container} to transfer the elements from.
+         */
+        merge<U extends T>(source: SetContainer<U>): void;
+    }
+}
+declare namespace std.Deque {
+    type iterator<T> = DequeIterator<T>;
+    type reverse_iterator<T> = DequeReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * Double ended queue.
+     *
+     * {@link Deque} (usually pronounced like "<i>deck</i>") is an irregular acronym of
+     * <b>d</b>ouble-<b>e</b>nded <b>q</b>ueue. Double-ended queues are sequence containers with dynamic sizes that can be
+     * expanded or contracted on both ends (either its front or its back).
+     *
+     * Specific libraries may implement deques in different ways, generally as some form of dynamic array. But in any
+     * case, they allow for the individual elements to be accessed directly through random access iterators, with storage
+     * handled automatically by expanding and contracting the container as needed.
+     *
+     * Therefore, they provide a functionality similar to vectors, but with efficient insertion and deletion of
+     * elements also at the beginning of the sequence, and not only at its end. But, unlike {@link Vector Vectors},
+     * {@link Deque Deques} are not guaranteed to store all its elements in contiguous storage locations: accessing
+     * elements in a <u>deque</u> by offsetting a pointer to another element causes undefined behavior.
+     *
+     * Both {@link Vector}s and {@link Deque}s provide a very similar interface and can be used for similar purposes,
+     * but internally both work in quite different ways: While {@link Vector}s use a single array that needs to be
+     * occasionally reallocated for growth, the elements of a {@link Deque} can be scattered in different chunks of
+     * storage, with the container keeping the necessary information internally to provide direct access to any of its
+     * elements in constant time and with a uniform sequential interface (through iterators). Therefore,
+     * {@link Deque Deques} are a little more complex internally than {@link Vector}s, but this allows them to grow more
+     * efficiently under certain circumstances, especially with very long sequences, where reallocations become more
+     * expensive.
+     *
+     * For operations that involve frequent insertion or removals of elements at positions other than the beginning or
+     * the end, {@link Deque Deques} perform worse and have less consistent iterators and references than
+     * {@link List Lists}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
+     *
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Sequence </dt>
+     *	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements
+     *		 are accessed by their position in this sequence. </dd>
+     *
+     *	<dt> Dynamic array </dt>
+     *	<dd> Generally implemented as a dynamic array, it allows direct access to any element in the
+     *		 sequence and provides relatively fast addition/removal of elements at the beginning or the end
+     *		 of the sequence. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/deque/deque/
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Deque<T> extends base.Container<T> implements base.IArrayContainer<T>, base.IDequeContainer<T> {
+        /**
+         * @hidden
+         */
+        private matrix_;
+        /**
+         * @hidden
+         */
+        private size_;
+        /**
+         * @hidden
+         */
+        private capacity_;
+        /**
+         * @hidden
+         */
+        private begin_;
+        /**
+         * @hidden
+         */
+        private end_;
+        /**
+         * @hidden
+         */
+        private rend_;
+        /**
+         * Default Constructor.
+         *
+         * Constructs an empty container, with no elements.
+         */
+        constructor();
+        /**
+         * Initializer list Constructor.
+         *
+         * Constructs a container with a copy of each of the elements in <i>array</i>, in the same order.
+         *
+         * @param array An array containing elements to be copied and contained.
+         */
+        constructor(items: Array<T>);
+        /**
+         * Fill Constructor.
+         *
+         * Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided).
+         *
+         * @param n Initial container size (i.e., the number of elements in the container at construction).
+         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
+         *			  initialized to a copy of this value.
+         */
+        constructor(size: number, val: T);
+        /**
+         * Copy Constructor.
+         *
+         * Constructs a container with a copy of each of the elements in <i>container</i>, in the same order.
+         *
+         * @param container Another container object of the same type (with the same class template
+         *					arguments <i>T</i>), whose contents are either copied or acquired.
+         */
+        constructor(container: Deque<T>);
+        /**
+         * Range Constructor.
+         *
+         * Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
+         * element emplace-constructed from its corresponding element in that range, in the same order.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        assign(n: number, val: T): void;
+        /**
+         * Request a change in capacity.
+         *
+         * Requests that the {@link Deque container} {@link capacity} be at least enough to contain
+         * <i>n</i> elements.
+         *
+         * If <i>n</i> is greater than the current {@link Deque container} {@link capacity}, the
+         * function causes the {@link Deque container} to reallocate its storage increasing its
+         * {@link capacity} to <i>n</i> (or greater).
+         *
+         * In all other cases, the function call does not cause a reallocation and the
+         * {@link Deque container} {@link capacity} is not affected.
+         *
+         * This function has no effect on the {@link Deque container} {@link size} and cannot alter
+         * its elements.
+         *
+         * @param n Minimum {@link capacity} for the {@link Deque container}.
+         *			Note that the resulting {@link capacity} may be equal or greater than <i>n</i>.
+         */
+        reserve(capacity: number): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        empty(): boolean;
+        /**
+         * Return size of allocated storage capacity.
+         *
+         * Returns the size of the storage space currently allocated for the {@link Deque container},
+         * expressed in terms of elements.
+         *
+         * This {@link capacity} is not necessarily equal to the {@link Deque container} {@link size}.
+         * It can be equal or greater, with the extra space allowing to accommodate for growth without the
+         * need to reallocate on each insertion.
+         *
+         * Notice that this {@link capacity} does not suppose a limit on the {@link size} of the
+         * {@link Deque container}. When this {@link capacity} is exhausted and more is needed, it is
+         * automatically expanded by the {@link Deque container} (reallocating it storage space).
+         * The theoretical limit on the {@link size} of a {@link Deque container} is given by member
+         * {@link max_size}.
+         *
+         * The {@link capacity} of a {@link Deque container} can be explicitly altered by calling member
+         * {@link Deque.reserve}.
+         *
+         * @return The size of the currently allocated storage capacity in the {@link Deque container},
+         *		   measured in terms of the number elements it can hold.
+         */
+        capacity(): number;
+        /**
+         * @inheritdoc
+         */
+        front(): T;
+        /**
+         * @inheritdoc
+         */
+        back(): T;
+        /**
+         * @inheritdoc
+         */
+        begin(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        at(index: number): T;
+        /**
+         * @inheritdoc
+         */
+        set(index: number, val: T): void;
+        /**
+         * @hidden
+         */
+        private _Fetch_index(index);
+        /**
+         * @hidden
+         */
+        private _Compute_col_size(capacity?);
+        /**
+         * @inheritdoc
+         */
+        push(...items: T[]): number;
+        /**
+         * @inheritdoc
+         */
+        push_front(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        pop_front(): void;
+        /**
+         * @inheritdoc
+         */
+        pop_back(): void;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeIterator<T>, val: T): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeIterator<T>, n: number, val: T): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeIterator<T>, begin: InputIterator, end: InputIterator): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeReverseIterator<T>, val: T): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeReverseIterator<T>, n: number, val: T): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeReverseIterator<T>, begin: InputIterator, end: InputIterator): DequeReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Insert_by_val(position, val);
+        /**
+         * @hidden
+         */
+        private _Insert_by_repeating_val(position, n, val);
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(pos: DequeIterator<T>, first: InputIterator, last: InputIterator): DequeIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Insert_to_middle<U, InputIterator>(pos, first, last);
+        /**
+         * @hidden
+         */
+        private _Insert_to_end<U, InputIterator>(first, last);
+        /**
+         * @hidden
+         */
+        private _Try_expand_capacity(size);
+        /**
+         * @hidden
+         */
+        private _Try_add_row_at_front();
+        /**
+         * @hidden
+         */
+        private _Try_add_row_at_back();
+        /**
+         * @inheritdoc
+         */
+        erase(position: DequeIterator<T>): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(position: DequeReverseIterator<T>): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(first: DequeReverseIterator<T>, last: DequeReverseIterator<T>): DequeReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link Deque container} object with same type of elements. Sizes and container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link Deque container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link Deque container}.
+         */
+        swap(obj: Deque<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<T>): void;
+        /**
+         * @hidden
+         */
+        private static readonly ROW_SIZE;
+        /**
+         * @hidden
+         */
+        private static readonly MIN_CAPACITY;
+        /**
+         * @hidden
+         */
+        private static readonly MAGNIFIER;
+    }
+}
+declare namespace std {
+    /**
+     * An iterator of {@link Deque}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DequeIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
+        /**
+         * @hidden
+         */
+        private index_;
+        /**
+         * Construct from the source {@link Deque container}.
+         *
+         * #### Note
+         * Do not create the iterator directly, by yourself.
+         *
+         * Use {@link Deque.begin begin()}, {@link Deque.end end()} in {@link Deque container} instead.
+         *
+         * @param source The source {@link Deque container} to reference.
+         * @param index Sequence number of the element in the source {@link Deque}.
+         */
+        constructor(source: Deque<T>, index: number);
+        /**
+         * @inheritdoc
+         */
+        source(): Deque<T>;
+        /**
+         * @inheritdoc
+         */
+        index(): number;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * @inheritdoc
+         */
+        prev(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(n: number): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        equals(obj: DequeIterator<T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: DequeIterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * A reverse-iterator of Deque.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DequeReverseIterator<T> extends ReverseIterator<T, Deque<T>, DequeIterator<T>, DequeReverseIterator<T>> implements base.IArrayIterator<T> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: DequeIterator<T>);
+        /**
+         * @hidden
+         */
+        protected _Create_neighbor(base: DequeIterator<T>): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        index(): number;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+    }
+}
+declare namespace std {
+    /**
+     * Function handling termination on exception
+     *
+     * Calls the current terminate handler.
+     *
+     * By default, the terminate handler calls abort. But this behavior can be redefined by calling
+     * {@link set_terminate}.
+     *
+     * This function is automatically called when no <code>catch</code> handler can be found for a thrown exception,
+     * or for some other exceptional circumstance that makes impossible to continue the exception handling process.
+     *
+     * This function is provided so that the terminate handler can be explicitly called by a program that needs to
+     * abnormally terminate, and works even if {@link set_terminate} has not been used to set a custom terminate handler
+     * (calling abort in this case).
+     */
+    function terminate(): void;
+    /**
+     * Set <i>terminate handler</i> function.
+     *
+     * A <i>terminate handler</i> function is a function automatically called when the exception handling process has
+     * to be abandoned for some reason. This happens when no catch handler can be found for a thrown exception, or for
+     * some other exceptional circumstance that makes impossible to continue the exception handling process.
+     *
+     * Before this function is called by the program for the first time, the default behavior is to call abort.
+     *
+     * A program may explicitly call the current terminate handler function by calling {@link terminate}.
+     *
+     * @param f Function that takes no parameters and returns no value (<i>void</i>).
+     */
+    function set_terminate(f: () => void): void;
+    /**
+     * Get <i>terminate handler</i> function.
+     *
+     * The <i>terminate handler</i> function is automatically called when no <code>catch</code> handler can be found
+     * for a thrown exception, or for some other exceptional circumstance that makes impossible to continue the exception
+     * handling process.
+     *
+     * If no such function has been set by a previous call to {@link set_terminate}, the function returns a
+     * <i>null-pointer</i>.
+     *
+     * @return If {@link set_terminate} has previously been called by the program, the function returns the current
+     *		   <i>terminate handler</i> function. Otherwise, it returns a <i>null-pointer</i>.
+     */
+    function get_terminate(): () => void;
+    /**
+     * Standard exception class.
+     *
+     * Base class for standard exceptions.
+     *
+     * All objects thrown by components of the standard library are derived from this class.
+     * Therefore, all standard exceptions can be caught by catching this type by reference.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/exception/exception
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Exception {
+        /**
+         * @hidden
+         */
+        private message_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+        /**
+         * Get string identifying exception.
+         *
+         * Returns a string that may be used to identify the exception.
+         *
+         * The particular representation pointed by the returned value is implementation-defined.
+         * As a virtual function, derived classes may redefine this function so that specify value are
+         * returned.
+         */
+        what(): string;
+    }
+    /**
+     * Logic error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report errors in the internal
+     * logical of the program, such as violation of logical preconditions or class invariants.
+     *
+     * These errors are presumably detectable before the program executes.
+     *
+     * It is used as a base class for several logical error exceptions.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/logic_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class LogicError extends Exception {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Domain error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report domain errors.
+     *
+     * Generally, the domain of a mathematical function is the subset of values that it is defined for.
+     * For example, the square root function is only defined for non-negative numbers. Thus, a negative number
+     * for such a function would qualify as a domain error.
+     *
+     * No component of the standard library throws exceptions of this type. It is designed as a standard
+     * exception to be thrown by programs.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a></p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/domain_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DomainError extends LogicError {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Invalid argument exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report an invalid argument.
+     *
+     * It is a standard exception that can be thrown by programs. Some components of the standard library
+     * also throw exceptions of this type to signal invalid arguments.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/invalid_argument
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class InvalidArgument extends LogicError {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Length error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report a length error.
+     *
+     * It is a standard exception that can be thrown by programs. Some components of the standard library,
+     * such as vector and string also throw exceptions of this type to signal errors resizing.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/length_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class LengthError extends LogicError {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Out-of-range exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report an out-of-range error.
+     *
+     * It is a standard exception that can be thrown by programs. Some components of the standard library,
+     * such as vector, deque, string and bitset also throw exceptions of this type to signal arguments
+     * out of range.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/out_of_range
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class OutOfRange extends LogicError {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Runtime error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report errors that can only be
+     * detected during runtime.
+     *
+     * It is used as a base class for several runtime error exceptions.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/runtime_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class RuntimeError extends Exception {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Overflow error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to arithmetic overflow errors.
+     *
+     * It is a standard exception that can be thrown by programs. Some components of the standard library
+     * also throw exceptions of this type to signal range errors.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/overflow_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class OverflowError extends RuntimeError {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Underflow error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to arithmetic underflow errors.
+     *
+     * No component of the standard library throws exceptions of this type. It is designed as a standard
+     * exception to be thrown by programs.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/underflow_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class UnderflowError extends RuntimeError {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * Range error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report range errors in internal
+     * computations.
+     *
+     * It is a standard exception that can be thrown by programs. Some components of the standard library
+     * also throw exceptions of this type to signal range errors.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/range_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class RangeError extends RuntimeError {
+        /**
+         * Construct from a message.
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+}
+declare namespace std {
+    /**
+     * Function object class for equality comparison.
+     *
+     * Binary function object class whose call returns whether its two arguments compare <i>equal</i> (as returned by
+     * operator ==).
+     *
+     * Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
+     * defined. This member function allows the object to be used with the same syntax as a function call.
+     *
+     * @param x First element to compare.
+     * @param y Second element to compare.
+     *
+     * @return Whether the arguments are equal.
+     */
+    function equal_to<T>(x: T, y: T): boolean;
+    /**
+     * Function object class for non-equality comparison.
+     *
+     * Binary function object class whose call returns whether its two arguments compare <i>not equal</i> (as returned
+     * by operator operator!=).
+     *
+     * Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
+     * defined. This member function allows the object to be used with the same syntax as a function call.
+     *
+     * @param x First element to compare.
+     * @param y Second element to compare.
+     *
+     * @return Whether the arguments are not equal.
+     */
+    function not_equal_to<T>(x: T, y: T): boolean;
+    /**
+     * Function for less-than inequality comparison.
+     *
+     * Binary function returns whether the its first argument compares less than the second.
+     *
+     * Generically, function objects are instances of a class with member function {@link IComparable.less less}
+     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
+     * This member function allows the object to be used with the same syntax as a function call.
+     *
+     * Objects of this class can be used on standard algorithms such as {@link sort sort()}</code>,
+     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}.
+     *
+     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
+     *			  <i>operator<()</i> or method {@link IComparable.less less}.
+     *
+     * @param x First element, the standard of comparison.
+     * @param y Second element compare with the first.
+     *
+     * @return Whether the first parameter is less than the second.
+     */
+    function less<T>(x: T, y: T): boolean;
+    /**
+     * Function object class for less-than-or-equal-to comparison.
+     *
+     * Binary function object class whose call returns whether the its first argument compares {@link less less than} or
+     * {@link equal_to equal to} the second (as returned by operator <=).
+     *
+     * Generically, <i>function objects</i> are instances of a class with member function {@link IComparable.less less}
+     * and {@link IComparable.equal_to equal_to} defined. This member function allows the object to be used with the same
+     * syntax as a function call.
+     *
+     * @param x First element, the standard of comparison.
+     * @param y Second element compare with the first.
+     *
+     * @return Whether the <i>x</i> is {@link less less than} or {@link equal_to equal to} the <i>y</i>.
+     */
+    function less_equal<T>(x: T, y: T): boolean;
+    /**
+     * Function for greater-than inequality comparison.
+     *
+     * Binary function returns whether the its first argument compares greater than the second.
+     *
+     * Generically, function objects are instances of a class with member function {@link less} and
+     * {@link equal_to equal_to()} defined. If an object doesn't have those methods, then its own uid will be used
+     * to compare insteadly. This member function allows the object to be used with the same syntax as a function
+     * call.
+     *
+     * Objects of this class can be used on standard algorithms such as {@link sort sort()},
+     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}.
+     *
+     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
+     *			  <i>operator>()</i> or method {@link IComparable.greater greater}.
+     *
+     * @return Whether the <i>x</i> is greater than the <i>y</i>.
+     */
+    function greater<T>(x: T, y: T): boolean;
+    /**
+     * Function object class for greater-than-or-equal-to comparison.
+     *
+     * Binary function object class whose call returns whether the its first argument compares
+     * {@link greater greater than} or {@link equal_to equal to} the second (as returned by operator >=).
+     *
+     * Generically, function objects are instances of a class with member function {@link IComparable.less less}
+     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
+     * This member function allows the object to be used with the same syntax as a function call.
+     *
+     * @param x First element, the standard of comparison.
+     * @param y Second element compare with the first.
+     *
+     * @return Whether the <i>x</i> is {@link greater greater than} or {@link equal_to equal to} the <i>y</i>.
+     */
+    function greater_equal<T>(x: T, y: T): boolean;
+    /**
+     * Logical AND function object class.
+     *
+     * Binary function object class whose call returns the result of the <i>logical "and"</i> operation between its two
+     * arguments (as returned by operator &&).
+     *
+     * Generically, function objects are instances of a class with member function operator() defined. This member
+     * function allows the object to be used with the same syntax as a function call.
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of logical AND operation.
+     */
+    function logical_and<T>(x: T, y: T): boolean;
+    /**
+     * Logical OR function object class.
+     *
+     * Binary function object class whose call returns the result of the <i>logical "or"</i> operation between its two
+     * arguments (as returned by operator ||).
+     *
+     * Generically, function objects are instances of a class with member function operator() defined. This member
+     * function allows the object to be used with the same syntax as a function call.
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of logical OR operation.
+     */
+    function logical_or<T>(x: T, y: T): boolean;
+    /**
+     * Logical NOT function object class.
+     *
+     * Unary function object class whose call returns the result of the <i>logical "not"</i> operation on its argument
+     * (as returned by operator !).
+     *
+     * Generically, function objects are instances of a class with member function operator() defined. This member
+     * function allows the object to be used with the same syntax as a function call.
+     *
+     * @param x Target element.
+     *
+     * @return Result of logical NOT operation.
+     */
+    function logical_not<T>(x: T): boolean;
+    /**
+     * Bitwise AND function object class.
+     *
+     * Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
+     * its two arguments (as returned by operator &).
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of bitwise AND operation.
+     */
+    function bit_and(x: number, y: number): number;
+    /**
+     * Bitwise OR function object class.
+     *
+     * Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
+     * its two arguments (as returned by operator &).
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of bitwise OR operation.
+     */
+    function bit_or(x: number, y: number): number;
+    /**
+     * Bitwise XOR function object class.
+     *
+     * Binary function object class whose call returns the result of applying the <i>bitwise "exclusive or"</i>
+     * operation between its two arguments (as returned by operator ^).
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of bitwise XOR operation.
+     */
+    function bit_xor(x: number, y: number): number;
+    /**
+     * Default hash function for number.
+     *
+     * Unary function that defines the default hash function used by the standard library.
+     *
+     * The functional call returns a hash value of its argument: A hash value is a value that depends solely on
+     * its argument, returning always the same value for the same argument (for a given execution of a program). The
+     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
+     *
+     *
+     * @param val Value to be hashed.
+     *
+     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
+     */
+    function hash(val: number): number;
+    /**
+     * Default hash function for string.
+     *
+     * Unary function that defines the default hash function used by the standard library.
+     *
+     * The functional call returns a hash value of its argument: A hash value is a value that depends solely on
+     * its argument, returning always the same value for the same argument (for a given execution of a program). The
+     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
+     *
+     * @param str A string to be hashed.
+     *
+     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
+     */
+    function hash(str: string): number;
+    /**
+     * Default hash function for Object.
+     *
+     * Unary function that defines the default hash function used by the standard library.
+     *
+     * The functional call returns a hash value of its argument: A hash value is a value that depends solely on
+     * its argument, returning always the same value for the same argument (for a given execution of a program). The
+     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
+     *
+     *
+     * The default {@link hash} function of Object returns a value returned from {@link hash hash(number)} with
+     * an <b>unique id</b> of each Object. If you want to specify {@link hash} function of a specific class, then
+     * define a member function <code>public hashCode(): number</code> in the class.
+     *
+     * @param obj Object to be hashed.
+     *
+     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
+     */
+    function hash(obj: Object): number;
+    /**
+     * Exchange contents of {@link IContainers containers}.
+     *
+     * The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must have
+     * same type of elements (same template parameters), although sizes may differ.
+     *
+     * After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i> before
+     * the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references and
+     * pointers remain valid for the swapped objects.
+     *
+     * This is an overload of the generic algorithm swap that improves its performance by mutually transferring
+     * ownership over their assets to the other container (i.e., the containers exchange references to their data, without
+     * actually performing any element copy or movement): It behaves as if <i>left</i>.
+     * {@link Container.swap swap}(<i>right</i>) was called.
+     *
+     * @param left A {@link Container container} to swap its contents.
+     * @param right A {@link Container container} to swap its contents.
+     */
+    function swap<T>(left: base.Container<T>, right: base.Container<T>): void;
+    /**
+     * Exchange contents of queues.
+     *
+     * Exchanges the contents of <i>left</i> and <i>right</i>.
+     *
+     * @param left A {@link Queue} container of the same type. Size may differ.
+     * @param right A {@link Queue} container of the same type. Size may differ.
+     */
+    function swap<T>(left: Queue<T>, right: Queue<T>): void;
+    /**
+     * Exchange contents of {@link PriorityQueue PriorityQueues}.
+     *
+     * Exchanges the contents of <i>left</i> and <i>right</i>.
+     *
+     * @param left A {@link PriorityQueue} container of the same type. Size may differ.
+     * @param right A {@link PriorityQueue} container of the same type. Size may differ.
+     */
+    function swap<T>(left: PriorityQueue<T>, right: PriorityQueue<T>): void;
+    /**
+     * Exchange contents of {@link Stack Stacks}.
+     *
+     * Exchanges the contents of <i>left</i> and <i>right</i>.
+     *
+     * @param left A {@link Stack} container of the same type. Size may differ.
+     * @param right A {@link Stack} container of the same type. Size may differ.
+     */
+    function swap<T>(left: Stack<T>, right: Stack<T>): void;
+    /**
+     * Exchanges the contents of two {@link UniqueMap unique maps}.
+     *
+     * The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
+     * be of the same type (same template parameters), although sizes may differ.
+     *
+     * After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
+     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
+     * and pointers remain valid for the swapped objects.
+     *
+     * This is an overload of the generic algorithm swap that improves its performance by mutually transferring
+     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
+     * without actually performing any element copy or movement): It behaves as if
+     * <i>left</i>.{@link UniqueMap.swap swap}(<i>right</i>) was called.
+     *
+     * @param left An {@link UniqueMap unique map} to swap its conents.
+     * @param right An {@link UniqueMap unique map} to swap its conents.
+     */
+    function swap<Key, T>(left: base.UniqueMap<Key, T>, right: base.UniqueMap<Key, T>): void;
+    /**
+     * Exchanges the contents of two {@link MultiMap multi maps}.
+     *
+     * The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
+     * be of the same type (same template parameters), although sizes may differ.
+     *
+     * After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
+     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
+     * and pointers remain valid for the swapped objects.
+     *
+     * This is an overload of the generic algorithm swap that improves its performance by mutually transferring
+     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
+     * without actually performing any element copy or movement): It behaves as if
+     * <i>left</i>.{@link MultiMap.swap swap}(<i>right</i>) was called.
+     *
+     * @param left A {@link MultiMap multi map} to swap its conents.
+     * @param right A {@link MultiMap multi map} to swap its conents.
+     */
+    function swap<Key, T>(left: base.MultiMap<Key, T>, right: base.MultiMap<Key, T>): void;
+}
+declare namespace std {
+    /**
+     * Bind function arguments.
+     *
+     * Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>.
+     *
+     * Each argument may either be bound to a value or be a {@link placeholders placeholder}:
+     * <ul>
+     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
+     *	<li>
+     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
+     *		call (the one whose order number is specified by the placeholder).
+     *	</li>
+     * </ul>
+     *
+     * Calling the returned object returns the same type as fn.
+     *
+     * @param fn A function object, pointer to function or pointer to member.
+     * @param args List of arguments to bind: either values, or {@link placeholders}.
+     *
+     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
+     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
+     *		   is a member.
+     */
+    function bind<Ret>(fn: (...args: any[]) => Ret, ...args: any[]): (...args: any[]) => Ret;
+    /**
+     * Bind function arguments.
+     *
+     * Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>.
+     *
+     * Each argument may either be bound to a value or be a {@link placeholders placeholder}:
+     * <ul>
+     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
+     *	<li>
+     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
+     *		call (the one whose order number is specified by the placeholder).
+     *	</li>
+     * </ul>
+     *
+     * Calling the returned object returns the same type as fn.
+     *
+     * @param fn A function object, pointer to function or pointer to member.
+     * @param thisArg This argument, owner object of the member method <i>fn</i>.
+     * @param args List of arguments to bind: either values, or {@link placeholders}.
+     *
+     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
+     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
+     *		   is a member.
+     */
+    function bind<Ret, T>(fn: (...args: any[]) => Ret, thisArg: T, ...args: any[]): (...args: any[]) => Ret;
+}
+/**
+ * Bind argument placeholders.
+ *
+ * This namespace declares an unspecified number of objects: <i>_1</i>, <i>_2</i>, <i>_3</i>, ...</i>, which are
+ * used to specify placeholders in calls to function {@link bind}.
+ *
+ * When the function object returned by bind is called, an argument with placeholder {@link _1} is replaced by the
+ * first argument in the call, {@link _2} is replaced by the second argument in the call, and so on... For example:
+ *
+ * <code>
+ * let vec: Vector<number> = new Vector<number>();
+ *
+ * let bind = bind(Vector.insert, _1, vec.end(), _2, _3);
+ * bind.apply(vec, 5, 1); // vec.insert(vec.end(), 5, 1);
+ * // [1, 1, 1, 1, 1]
+ * </code>
+ *
+ * When a call to {@link bind} is used as a subexpression in another call to <i>bind</i>, the {@link placeholders}
+ * are relative to the outermost {@link bind} expression.
+ *
+ * @reference http://www.cplusplus.com/reference/functional/placeholders/
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace std.placeholders {
+    /**
+     * @hidden
+     */
+    class PlaceHolder {
+        private index_;
+        constructor(index: number);
+        index(): number;
+    }
+    /**
+     * Replaced by the first argument in the function call.
+     */
+    const _1: PlaceHolder;
+    /**
+     * Replaced by the second argument in the function call.
+     */
+    const _2: PlaceHolder;
+    /**
+     * Replaced by the third argument in the function call.
+     */
+    const _3: PlaceHolder;
+    const _4: PlaceHolder;
+    const _5: PlaceHolder;
+    const _6: PlaceHolder;
+    const _7: PlaceHolder;
+    const _8: PlaceHolder;
+    const _9: PlaceHolder;
+    const _10: PlaceHolder;
+    const _11: PlaceHolder;
+    const _12: PlaceHolder;
+    const _13: PlaceHolder;
+    const _14: PlaceHolder;
+    const _15: PlaceHolder;
+    const _16: PlaceHolder;
+    const _17: PlaceHolder;
+    const _18: PlaceHolder;
+    const _19: PlaceHolder;
+    const _20: PlaceHolder;
+}
+declare namespace std.HashMap {
+    type iterator<Key, T> = MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * Hashed, unordered map.
+     *
+     * {@link HashMap}s are associative containers that store elements formed by the combination of a <i>key value</i>
+     * and a <i>mapped value</i>, and which allows for fast retrieval of individual elements based on their <i>keys</i>.
+     *
+     * In an {@link HashMap}, the <i>key value</i> is generally used to uniquely identify the element, while the
+     * <i>mapped value</i> is an object with the content associated to this <i>key</i>. Types of <i>key</i> and
+     * <i>mapped value</i> may differ.
+     *
+     * Internally, the elements in the {@link HashMap} are not sorted in any particular order with respect to either
+     * their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on their hash values to allow
+     * for fast access to individual elements directly by their <i>key values</i> (with a constant average time complexity
+     * on average).
+     *
+     * {@link HashMap} containers are faster than {@link TreeMap} containers to access individual elements by their
+     * <i>key</i>, although they are generally less efficient for range iteration through a subset of their elements.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
+     *
+     * ### Container properties
+     * <dl>
+     * 	<dt> Associative </dt>
+     * 	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     * 	<dt> Hashed </dt>
+     * 	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     * 	<dt> Map </dt>
+     * 	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     *
+     * 	<dt> Unique keys </dt>
+     * 	<dd> No two elements in the container can have equivalent keys. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the key values.
+     *				Each element in an {@link HashMap} is uniquely identified by its key value.
+     * @param <T> Type of the mapped value.
+     *			  Each element in an {@link HashMap} is used to store some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_map
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashMap<Key, T> extends base.UniqueMap<Key, T> implements base.IHashMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: Pair<Key, T>[]);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: [Key, T][]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashMap<Key, T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        begin(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(index: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashMap map} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link HashMap map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashMap container}.
+         */
+        swap(obj: HashMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<Pair<Key, T>>): void;
+    }
+}
+declare namespace std.HashMultiMap {
+    type iterator<Key, T> = MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * Hashed, unordered Multimap.
+     *
+     * {@link HashMultiMap}s are associative containers that store elements formed by the combination of
+     * a <i>key value</i> and a <i>mapped value</i>, much like {@link HashMultiMap} containers, but allowing
+     * different elements to have equivalent <i>keys</i>.
+     *
+     * In an {@link HashMultiMap}, the <i>key value</i> is generally used to uniquely identify the
+     * element, while the <i>mapped value</i> is an object with the content associated to this <i>key</i>.
+     * Types of <i>key</i> and <i>mapped value</i> may differ.
+     *
+     * Internally, the elements in the {@link HashMultiMap} are not sorted in any particular order with
+     * respect to either their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on
+     * their hash values to allow for fast access to individual elements directly by their <i>key values</i>
+     * (with a constant average time complexity on average).
+     *
+     * Elements with equivalent <i>keys</i> are grouped together in the same bucket and in such a way that
+     * an iterator can iterate through all of them. Iterators in the container are doubly linked iterators.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the key values.
+     *				Each element in an {@link HashMultiMap} is identified by a key value.
+     * @param <T> Type of the mapped value.
+     *			  Each element in an {@link HashMultiMap} is used to store some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_multimap
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashMultiMap<Key, T> extends base.MultiMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: Pair<Key, T>[]);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: [Key, T][]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashMultiMap<Key, T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        count(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        begin(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(n: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashMultiMap map} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link HashMultiMap map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashMultiMap container}.
+         */
+        swap(obj: HashMultiMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<Pair<Key, T>>): void;
+    }
+}
+declare namespace std.HashMultiSet {
+    type iterator<T> = SetIterator<T>;
+    type reverse_iterator<T> = SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * Hashed, unordered Multiset.
+     *
+     * {@link HashMultiSet HashMultiSets} are containers that store elements in no particular order, allowing fast
+     * retrieval of individual elements based on their value, much like {@link HashMultiSet} containers,
+     * but allowing different elements to have equivalent values.
+     *
+     * In an {@link HashMultiSet}, the value of an element is at the same time its <i>key</i>, used to
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link HashMultiSet} cannot be
+     * modified once in the container - they can be inserted and removed, though.
+     *
+     * Internally, the elements in the {@link HashMultiSet} are not sorted in any particular, but
+     * organized into <i>buckets</i> depending on their hash values to allow for fast access to individual
+     * elements directly by their <i>values</i> (with a constant average time complexity on average).
+     *
+     * Elements with equivalent values are grouped together in the same bucket and in such a way that an
+     * iterator can iterate through all of them. Iterators in the container are doubly linked iterators.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *		   Each element in an {@link UnorderedMultiSet} is also identified by this value..
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_multiset
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashMultiSet<T> extends base.MultiSet<T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: T[]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashMultiSet<T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        count(key: T): number;
+        /**
+         * @inheritdoc
+         */
+        begin(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(n: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: T): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashMultiSet set} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link HashMultiSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashMultiSet container}.
+         */
+        swap(obj: HashMultiSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<T>): void;
+    }
+}
+declare namespace std.HashSet {
+    type iterator<T> = SetIterator<T>;
+    type reverse_iterator<T> = SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * Hashed, unordered set.
+     *
+     * {@link HashSet}s are containers that store unique elements in no particular order, and which
+     * allow for fast retrieval of individual elements based on their value.
+     *
+     * In an {@link HashSet}, the value of an element is at the same time its <i>key</i>, that
+     * identifies it uniquely. Keys are immutable, therefore, the elements in an {@link HashSet} cannot be
+     * modified once in the container - they can be inserted and removed, though.
+     *
+     * Internally, the elements in the {@link HashSet} are not sorted in any particular order, but
+     * organized into buckets depending on their hash values to allow for fast access to individual elements
+     * directly by their <i>values</i> (with a constant average time complexity on average).
+     *
+     * {@link HashSet} containers are faster than {@link TreeSet} containers to access individual
+     * elements by their <i>key</i>, although they are generally less efficient for range iteration through a
+     * subset of their elements.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *			  Each element in an {@link HashSet} is also uniquely identified by this value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashSet<T> extends base.UniqueSet<T> implements base.IHashSet<T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: T[]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashSet<T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(n: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: T): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashSet set} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link HashSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashSet container}.
+         */
+        swap(obj: HashSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * Comparable instance.
+     *
+     * {@link IComparable} is a common interface for objects who can compare each other.
+     *
+     * @reference https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IComparable<T> extends Object {
+        /**
+         * Indicates whether some other object is &quot;equal to&quot; this one.
+         *
+         * The {@link equal_to} method implements an equivalence relation on non-null object references:
+         *
+         * <ul>
+         *	<li>
+         *		It is <b>reflexive</b>: for any non-null reference value <code>x</code>, <code>x.equal_to(x)</code>
+         *		should return <code>true</code>.
+         *	</li>
+         *	<li>
+         *		It is <b>symmetric</b>: for any non-null reference values <code>x</code> and <code>y</code>,
+         *		<code>x.equal_to(y)</code> should return <code>true</code> if and only if <code>y.equal_to(x)</code>
+         *		returns <code>true</code>. </li>
+         *	<li>
+         *		It is <b>transitive</b>: for any non-null reference values <code>x</code>, <code>y</code>, and
+         *		<code>z</code>, if <code>x.equal_to(y)</code> returns <code>true</code> and <code>y.equal_to(z)</code>
+         *		returns <code>true</code>, then <code>x.equal_to(z)</code> should return <code>true</code>.
+         *	</li>
+         *	<li>
+         *		It is <b>consistent</b>: for any non-null reference values <code>x</code> and <code>y</code>, multiple
+         *		invocations of <code>x.equal_to(y)</code> consistently return <code>true</code> or consistently return
+         *		<code>false</code>, provided no information used in equal_to comparisons on the objects is modified.
+         *	</li>
+         *	<li>
+         *		For any non-null reference value <code>x</code>, <code>x.equal_to(null)</code> should return
+         *		<code>false</code>.
+         *	</li>
+         * </ul>
+         *
+         * The {@link equal_to} method for interface {@link IComparable} implements the most discriminating possible
+         * equivalence relation on objects; that is, for any non-null reference values <code>x</code> and
+         * <code>y</code>, this method returns <code>true</code> if and only if <code>x</code> and <code>y</code>
+         * refer to the same object (<code>x == y</code> has the value <code>true</code>).
+         *
+         * Note that it is generally necessary to override the {@link hash_code} method whenever this method is
+         * overridden, so as to maintain the general contract for the {@link hash_code} method, which states that
+         * equal objects must have equal hash codes.
+         *
+         * - {@link IComparable.equal_to} is called by {@link equal_to}.
+         *
+         * @param obj the reference object with which to compare.
+         *
+         * @return <code>true</code> if this object is the same as the obj argument; <code>false</code> otherwise.
+         */
+        equals(obj: T): boolean;
+        /**
+         * Less-than inequality comparison.
+         *
+         * Binary method returns whether the the instance compares less than the <i>obj</i>.
+         *
+         * <ul>
+         *	<li>
+         *		{@link IComparable.less} is called by {@link less}. Also, this method can be used on standard
+         *		algorithms such as {@link sort sort()}</code>, {@link merge merge()} or
+         *		{@link TreeMap.lower_bound lower_bound()}.
+         *	</li>
+         * </ul>
+         *
+         * @param obj the reference object with which to compare.
+         *
+         * @return Whether the first parameter is less than the second.
+         */
+        less(obj: T): boolean;
+        /**
+         * Issue a hash code.
+         *
+         * Returns a hash code value for the object. This method is supported for the benefit of hash tables such
+         * as those provided by hash containers; {@link HashSet}, {@link HashMap}, {@link MultiHashSet} and
+         * {@link MultiHashMap}.
+         *
+         * As much as is reasonably practical, the {@link hash_code} method defined by interface
+         * {@link IComparable} does return distinct integers for distinct objects. (This is typically implemented by
+         * converting the internal address of the object into an integer, but this implementation technique is not
+         * required by the JavaScript programming language.)
+         *
+         * <ul>
+         *	<li>
+         *		{@link IComparable.hash_code} is called by {@link hash_code}. If you want to keep basically
+         *		provided hash function, then returns {@link Hash.code}; <code>return Hash.code(this);</code>
+         *	</li>
+         * </ul>
+         *
+         * @return An hash code who represents the object.
+         */
+        hashCode?(): number;
+    }
+}
+declare namespace std.List {
+    type iterator<T> = ListIterator<T>;
+    type reverse_iterator<T> = ListReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * Doubly linked list.
+     *
+     * {@link List}s are sequence containers that allow constant time insert and erase operations anywhere within the
+     * sequence, and iteration in both directions.
+     *
+     * List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they
+     * contain in different and unrelated storage locations. The ordering is kept internally by the association to each
+     * element of a link to the element preceding it and a link to the element following it.
+     *
+     * Compared to other base standard sequence containers (array, vector and deque), lists perform generally better
+     * in inserting, extracting and moving elements in any position within the container for which an iterator has already
+     * been obtained, and therefore also in algorithms that make intensive use of these, like sorting algorithms.
+     *
+     * The main drawback of lists and forward_lists compared to these other sequence containers is that they lack
+     * direct access to the elements by their position; For example, to access the sixth element in a list, one has to
+     * iterate from a known position (like the beginning or the end) to that position, which takes linear time in the
+     * distance between these. They also consume some extra memory to keep the linking information associated to each
+     * element (which may be an important factor for large lists of small-sized elements).
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     *
+     *
+     * ### Container properties
+     * <dl>
+     * 	<dt> Sequence </dt>
+     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
+     *		 their position in this sequence. </dd>
+     *
+     * 	<dt> Doubly-linked list </dt>
+     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing constant time
+     *		 insert and erase operations before or after a specific element (even of entire ranges), but no direct random
+     *		 access. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/list/list/
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class List<T> extends base._ListContainer<T, ListIterator<T>> {
+        private rend_;
+        /**
+         * Default Constructor.
+         *
+         * Constructs an empty container, with no elements.
+         */
+        constructor();
+        /**
+         * Initializer list Constructor.
+         *
+         * Constructs a container with a copy of each of the elements in <i>array</i>, in the same order.
+         *
+         * @param array An array containing elements to be copied and contained.
+         */
+        constructor(items: Array<T>);
+        /**
+         * Fill Constructor.
+         *
+         * Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided).
+         *
+         * @param n Initial container size (i.e., the number of elements in the container at construction).
+         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
+         *			  initialized to a copy of this value.
+         */
+        constructor(size: number, val: T);
+        /**
+         * Copy Constructor.
+         *
+         * Constructs a container with a copy of each of the elements in <i>container</i>, in the same order.
+         *
+         * @param container Another container object of the same type (with the same class template
+         *					arguments <i>T</i>), whose contents are either copied or acquired.
+         */
+        constructor(container: List<T>);
+        /**
+         * Range Constructor.
+         *
+         * Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
+         * element emplace-constructed from its corresponding element in that range, in the same order.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @hidden
+         */
+        protected _Create_iterator(prev: ListIterator<T>, next: ListIterator<T>, val: T): ListIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Set_begin(it: ListIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        assign(n: number, val: T): void;
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): ListReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): ListReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        front(): T;
+        /**
+         * @inheritdoc
+         */
+        back(): T;
+        /**
+         * Insert an element.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new element is inserted.
+         *				   {@link iterator}> is a member type, defined as a
+         *				   {@link ListIterator bidirectional iterator} type that points to elements.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the newly inserted element; <i>val</i>.
+         */
+        insert(position: ListIterator<T>, val: T): ListIterator<T>;
+        /**
+         * Insert elements by repeated filling.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param size Number of elements to insert.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: ListIterator<T>, size: number, val: T): ListIterator<T>;
+        /**
+         * Insert elements by range iterators.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param begin An iterator specifying range of the begining element.
+         * @param end An iterator specifying range of the ending element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: ListIterator<T>, begin: InputIterator, end: InputIterator): ListIterator<T>;
+        /**
+         * Insert an element.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new element is inserted.
+         *				   {@link iterator}> is a member type, defined as a
+         *				   {@link ListReverseIterator bidirectional iterator} type that points to elements.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the newly inserted element; <i>val</i>.
+         */
+        insert(position: ListReverseIterator<T>, val: T): ListReverseIterator<T>;
+        /**
+         * Insert elements by repeated filling.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param size Number of elements to insert.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: ListReverseIterator<T>, size: number, val: T): ListReverseIterator<T>;
+        /**
+         * Insert elements by range iterators.
+         *
+         * The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted.
+         *
+         * Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param begin An iterator specifying range of the begining element.
+         * @param end An iterator specifying range of the ending element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: ListReverseIterator<T>, begin: InputIterator, end: InputIterator): ListReverseIterator<T>;
+        /**
+         * Erase an element.
+         *
+         * Removes from the {@link List} either a single element; <i>position</i>.
+         *
+         * This effectively reduces the container size by the number of element removed.
+         *
+         * Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link List}.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
+         */
+        erase(position: ListIterator<T>): ListIterator<T>;
+        /**
+         * Erase elements.
+         *
+         * Removes from the {@link List} container a range of elements.
+         *
+         * This effectively reduces the container {@link size} by the number of elements removed.
+         *
+         * Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
+         */
+        erase(begin: ListIterator<T>, end: ListIterator<T>): ListIterator<T>;
+        /**
+         * Erase an element.
+         *
+         * Removes from the {@link List} either a single element; <i>position</i>.
+         *
+         * This effectively reduces the container size by the number of element removed.
+         *
+         * Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link List}.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
+         */
+        erase(position: ListReverseIterator<T>): ListReverseIterator<T>;
+        /**
+         * Erase elements.
+         *
+         * Removes from the {@link List} container a range of elements.
+         *
+         * This effectively reduces the container {@link size} by the number of elements removed.
+         *
+         * Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence.
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
+         */
+        erase(begin: ListReverseIterator<T>, end: ListReverseIterator<T>): ListReverseIterator<T>;
+        /**
+         * Remove duplicate values.
+         *
+         * Removes all but the first element from every consecutive group of equal elements in the
+         *
+         * Notice that an element is only removed from the {@link List} container if it compares equal to the
+         * element immediately preceding it. Thus, this function is especially useful for sorted lists.
+         */
+        unique(): void;
+        /**
+         * Remove duplicate values.
+         *
+         * Removes all but the first element from every consecutive group of equal elements in the
+         *
+         * The argument <i>binary_pred</i> is a specific comparison function that determine the <u>uniqueness</u>
+         * of an element. In fact, any behavior can be implemented (and not only an equality comparison), but notice
+         * that the function will call <code>binary_pred(it.value, it.prev().value)</code> for all pairs of elements
+         * (where <code>it</code> is an iterator to an element, starting from the second) and remove <code>it</code>
+         * from the {@link List} if the predicate returns <code>true</code>.
+         *
+         * Notice that an element is only removed from the {@link List} container if it compares equal to the
+         * element immediately preceding it. Thus, this function is especially useful for sorted lists.
+         *
+         * @param binary_pred Binary predicate that, taking two values of the same type than those contained in the
+         *					  {@link List}, returns <code>true</code> to remove the element passed as first argument
+         *					  from the container, and <code>false</code> otherwise. This shall be a function pointer
+         *					  or a function object.
+         */
+        unique(binary_pred: (left: T, right: T) => boolean): void;
+        /**
+         * Remove elements with specific value.
+         *
+         * Removes from the container all the elements that compare equal to <i>val</i>. This calls the
+         * destructor of these objects and reduces the container {@link size} by the number of elements removed.
+         *
+         * Unlike member function {@link List.erase}, which erases elements by their position (using an
+         * iterator), this function ({@link List.remove}) removes elements by their value.
+         *
+         * A similar function, {@link List.remove_if}, exists, which allows for a condition other than an
+         * equality comparison to determine whether an element is removed.
+         *
+         * @param val Value of the elements to be removed.
+         */
+        remove(val: T): void;
+        /**
+         * Remove elements fulfilling condition.
+         *
+         * Removes from the container all the elements for which <i>pred</i> returns <code>true</code>. This
+         * calls the destructor of these objects and reduces the container {@link size} by the number of elements
+         * removed.
+         *
+         * The function calls <code>pred(it.value)</code> for each element (where <code>it</code> is an iterator
+         * to that element). Any of the elements in the list for which this returns <code>true</code>, are removed
+         * from the
+         *
+         * @param pred Unary predicate that, taking a value of the same type as those contained in the forward_list
+         *			   object, returns <code>true</code> for those values to be removed from the container, and
+         *			   <code>false</code> for those remaining. This can either be a function pointer or a function
+         *			   object.
+         */
+        remove_if(pred: (val: T) => boolean): void;
+        /**
+         * Merge sorted {@link List Lists}.
+         *
+         * Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
+         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
+         *
+         *
+         * This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
+         * them into their ordered position within container (which expands in {@link size} by the number of elements
+         * transferred). The operation is performed without constructing nor destroying any element: they are
+         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
+         * move-construction or not.
+         *
+         * This function requires that the {@link List} containers have their elements already ordered by value
+         * ({@link less}) before the call. For an alternative on unordered {@link List Lists}, see
+         * {@link List.splice}.
+         *
+         * Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
+         * value according to the strict weak ordering defined by {@link less}. The resulting order of equivalent
+         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
+         * existing elements precede those equivalent inserted from <i>obj</i>).
+         *
+         * The function does nothing if <code>this == obj</code>.
+         *
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
+         *			  passed.
+         */
+        merge<U extends T>(obj: List<U>): void;
+        /**
+         * Merge sorted {@link List Lists}.
+         *
+         * Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
+         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
+         *
+         *
+         * This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
+         * them into their ordered position within container (which expands in {@link size} by the number of elements
+         * transferred). The operation is performed without constructing nor destroying any element: they are
+         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
+         * move-construction or not.
+         *
+         * The argument <i>compare</i> is a specific predicate to perform the comparison operation between
+         * elements. This comparison shall produce a strict weak ordering of the elements (i.e., a consistent
+         * transitive comparison, without considering its reflexiveness).
+         *
+         * This function requires that the {@link List} containers have their elements already ordered by
+         * <i>compare</i> before the call. For an alternative on unordered {@link List Lists}, see
+         * {@link List.splice}.
+         *
+         * Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
+         * value according to the strict weak ordering defined by <i>compare</i>. The resulting order of equivalent
+         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
+         * existing elements precede those equivalent inserted from <i>obj</i>).
+         *
+         * The function does nothing if <code>this == obj</code>.
+         *
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
+         *			  passed.
+         * @param compare Binary predicate that, taking two values of the same type than those contained in the
+         *				  {@link list}, returns <code>true</code> if the first argument is considered to go before
+         *				  the second in the strict weak ordering it defines, and <code>false</code> otherwise.
+         *				  This shall be a function pointer or a function object.
+         */
+        merge<U extends T>(obj: List<U>, compare: (left: T, right: T) => boolean): void;
+        /**
+         * Transfer elements from {@link List} to {@link List}.
+         *
+         * Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>.
+         *
+         * This effectively inserts all elements into the container and removes them from <i>obj</i>, altering
+         * the sizes of both containers. The operation does not involve the construction or destruction of any
+         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
+         * value_type supports move-construction or not.
+         *
+         * This first version (1) transfers all the elements of <i>obj</i> into the
+         *
+         * @param position Position within the container where the elements of <i>obj</i> are inserted.
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         */
+        splice<U extends T>(position: ListIterator<T>, obj: List<U>): void;
+        /**
+         * Transfer an element from {@link List} to {@link List}.
+         *
+         * Transfers an element from <i>obj</i>, which is pointed by an {@link ListIterator iterator} <i>it</i>,
+         * into the container, inserting the element at specified <i>position</i>.
+         *
+         * This effectively inserts an element into the container and removes it from <i>obj</i>, altering the
+         * sizes of both containers. The operation does not involve the construction or destruction of any element.
+         * They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type
+         * supports move-construction or not.
+         *
+         * This second version (2) transfers only the element pointed by <i>it</i> from <i>obj</i> into the
+         *
+         *
+         * @param position Position within the container where the element of <i>obj</i> is inserted.
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
+         *			  being spliced.
+         * @param it {@link ListIterator Iterator} to an element in <i>obj</i>. Only this single element is
+         *			 transferred.
+         */
+        splice<U extends T>(position: ListIterator<T>, obj: List<U>, it: ListIterator<U>): void;
+        /**
+         * Transfer elements from {@link List} to {@link List}.
+         *
+         * Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>.
+         *
+         * This effectively inserts those elements into the container and removes them from <i>obj</i>, altering
+         * the sizes of both containers. The operation does not involve the construction or destruction of any
+         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
+         * value_type supports move-construction or not.
+         *
+         * This third version (3) transfers the range [<i>begin</i>, <i>end</i>) from <i>obj</i> into the
+         *
+         *
+         * @param position Position within the container where the elements of <i>obj</i> are inserted.
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
+         *			  being spliced.
+         * @param begin {@link ListIterator An Iterator} specifying initial position of a range of elements in
+         *				<i>obj</i>. Transfers the elements in the range [<b><i>begin</i></b>, <i>end</i>) to
+         *				<i>position</i>.
+         * @param end {@link ListIterator An Iterator} specifying final position of a range of elements in
+         *			  <i>obj</i>. Transfers the elements in the range [<i>begin</i>, <b><i>end</i></b>) to
+         *			  <i>position</i>. Notice that the range includes all the elements between <i>begin<i/> and
+         *			  <i>end</i>, including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        splice<U extends T>(position: ListIterator<T>, obj: List<U>, begin: ListIterator<U>, end: ListIterator<U>): void;
+        /**
+         * Sort elements in
+         *
+         * Sorts the elements in the {@link List}, altering their position within the
+         *
+         * The sorting is performed by applying an algorithm that uses {@link less}. This comparison shall
+         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
+         * considering its reflexiveness).
+         *
+         * The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
+         * order they had before the call.
+         *
+         * The entire operation does not involve the construction, destruction or copy of any element object.
+         * Elements are moved within the
+         */
+        sort(): void;
+        /**
+         * Sort elements in
+         *
+         * Sorts the elements in the {@link List}, altering their position within the
+         *
+         * The sorting is performed by applying an algorithm that uses <i>compare</i>. This comparison shall
+         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
+         * considering its reflexiveness).
+         *
+         * The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
+         * order they had before the call.
+         *
+         * The entire operation does not involve the construction, destruction or copy of any element object.
+         * Elements are moved within the
+         *
+         * @param compare Binary predicate that, taking two values of the same type of those contained in the
+         *				  {@link List}, returns <code>true</code> if the first argument goes before the second
+         *				  argument in the strict weak ordering it defines, and <code>false</code> otherwise. This
+         *				  shall be a function pointer or a function object.
+         */
+        sort(compare: (left: T, right: T) => boolean): void;
+        /**
+         * @hidden
+         */
+        private _Quick_sort(first, last, compare);
+        /**
+         * @hidden
+         */
+        private _Quick_sort_partition(first, last, compare);
+        /**
+         * Reverse the order of elements.
+         *
+         * Reverses the order of the elements in the list container.
+         */
+        reverse(): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link List container} object with same type of elements. Sizes and container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link List container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link List container}.
+         */
+        swap(obj: List<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * An iterator, node of a List.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ListIterator<T> extends base._ListIteratorBase<T> {
+        /**
+         * Initializer Constructor.
+         *
+         * #### Note
+         * Do not create the iterator directly, by yourself.
+         *
+         * Use {@link List.begin begin()}, {@link List.end end()} in {@link List container} instead.
+         *
+         * @param source The source {@link List container} to reference.
+         * @param prev A refenrece of previous node ({@link ListIterator iterator}).
+         * @param next A refenrece of next node ({@link ListIterator iterator}).
+         * @param value Value to be stored in the node (iterator).
+         */
+        constructor(source: List<T>, prev: ListIterator<T>, next: ListIterator<T>, value: T);
+        /**
+         * @inheritdoc
+         */
+        source(): List<T>;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * @inheritdoc
+         */
+        prev(): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(step: number): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        equals(obj: ListIterator<T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: ListIterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * A reverse-iterator of List.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ListReverseIterator<T> extends ReverseIterator<T, List<T>, ListIterator<T>, ListReverseIterator<T>> implements base.ILinearIterator<T> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: ListIterator<T>);
+        /**
+         * @hidden
+         */
+        protected _Create_neighbor(base: ListIterator<T>): ListReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+    }
+}
+declare namespace std.Vector {
+    type iterator<T> = VectorIterator<T>;
+    type reverse_iterator<T> = VectorReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * Vector, the dynamic array.
+     *
+     * {@link Vector}s are sequence containers representing arrays that can change in size.
+     *
+     * Just like arrays, {@link Vector}s use contiguous storage locations for their elements, which means that
+     * their elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently
+     * as in arrays. But unlike arrays, their size can change dynamically, with their storage being handled
+     * automatically by the container.
+     *
+     * Internally, {@link Vector}s use a dynamically allocated array to store their elements. This array may need
+     * to be reallocated in order to grow in size when new elements are inserted, which implies allocating a new
+     * array and moving all elements to it. This is a relatively expensive task in terms of processing time, and
+     * thus, {@link Vector}s do not reallocate each time an element is added to the container.
+     *
+     * Compared to the other dynamic sequence containers ({@link Deque}s, {@link List}s), {@link Vector Vectors}
+     * are very efficient accessing its elements (just like arrays) and relatively efficient adding or removing
+     * elements from its end. For operations that involve inserting or removing elements at positions other than the
+     * end, they perform worse than the others, and have less consistent iterators and references than {@link List}s.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Sequence </dt>
+     *	<dd>
+     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
+     *		accessed by their position in this sequence.
+     *	</dd>
+     *
+     *	<dt> Dynamic array </dt>
+     *	<dd>
+     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
+     *		relatively fast addition/removal of elements at the end of the sequence.
+     *	</dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/vector/vector
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Vector<T> extends base.Container<T> implements base.IArrayContainer<T> {
+        /**
+         * @hidden
+         */
+        private data_;
+        /**
+         * @hidden
+         */
+        private begin_;
+        /**
+         * @hidden
+         */
+        private end_;
+        /**
+         * @hidden
+         */
+        private rend_;
+        /**
+         * Default Constructor.
+         *
+         * Constructs an empty container, with no elements.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        constructor(array: Array<T>);
+        /**
+         * Initializer list Constructor.
+         *
+         * Constructs a container with a copy of each of the elements in <i>array</i>, in the same order.
+         *
+         * @param array An array containing elements to be copied and contained.
+         */
+        constructor(n: number);
+        /**
+         * Fill Constructor.
+         *
+         * Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided).
+         *
+         * @param n Initial container size (i.e., the number of elements in the container at construction).
+         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
+         *			  initialized to a copy of this value.
+         */
+        constructor(n: number, val: T);
+        /**
+         * Copy Constructor.
+         *
+         * Constructs a container with a copy of each of the elements in <i>container</i>, in the same order.
+         *
+         * @param container Another container object of the same type (with the same class template
+         *					arguments <i>T</i>), whose contents are either copied or acquired.
+         */
+        constructor(container: Vector<T>);
+        /**
+         * Range Constructor.
+         *
+         * Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
+         * element emplace-constructed from its corresponding element in that range, in the same order.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        assign(n: number, val: T): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        begin(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): VectorReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): VectorReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        empty(): boolean;
+        /**
+         * @inheritdoc
+         */
+        at(index: number): T;
+        /**
+         * @inheritdoc
+         */
+        set(index: number, val: T): T;
+        /**
+         * @inheritdoc
+         */
+        front(): T;
+        /**
+         * @inheritdoc
+         */
+        back(): T;
+        /**
+         * Access data.
+         *
+         * Returns a direct array which is used internally by the {@link vector} to store its owned elements.
+         *
+         * @returns An array.
+         */
+        data(): Array<T>;
+        /**
+         * @inheritdoc
+         */
+        push(...items: T[]): number;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * Insert an element.
+         *
+         * The {@link Vector} is extended by inserting new element before the element at the specified
+         * <i>position</i>, effectively increasing the container size by one.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new element is inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param val Value to be copied to the inserted element.
+         *
+         * @return An iterator that points to the newly inserted element.
+         */
+        insert(position: VectorIterator<T>, val: T): VectorIterator<T>;
+        /**
+         * Insert elements by repeated filling.
+         *
+         * The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
+         * @param val Value to be copied (or moved) to the inserted elements.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: VectorIterator<T>, n: number, val: T): VectorIterator<T>;
+        /**
+         * Insert elements by range iterators.
+         *
+         * The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
+         * iterators.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorIterator<T>, begin: InputIterator, end: InputIterator): VectorIterator<T>;
+        /**
+         * Insert an element.
+         *
+         * The {@link Vector} is extended by inserting new element before the element at the specified
+         * <i>position</i>, effectively increasing the container size by one.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new element is inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param val Value to be copied to the inserted element.
+         *
+         * @return An iterator that points to the newly inserted element.
+         */
+        insert(position: VectorReverseIterator<T>, val: T): VectorReverseIterator<T>;
+        /**
+         * Insert elements by repeated filling.
+         *
+         * The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
+         * @param val Value to be copied (or moved) to the inserted elements.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: VectorReverseIterator<T>, n: number, val: T): VectorReverseIterator<T>;
+        /**
+         * Insert elements by range iterators.
+         *
+         * The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
+         * iterators.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorReverseIterator<T>, begin: InputIterator, end: InputIterator): VectorReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private _Insert_by_val(position, val);
+        /**
+         * @hidden
+         */
+        private _Insert_by_repeating_val(position, n, val);
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<InputIterator extends Iterator<T>>(position: VectorIterator<T>, first: InputIterator, last: InputIterator): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        pop_back(): void;
+        /**
+         * Erase element.
+         *
+         * Removes from the {@link Vector} either a single element; <i>position</i>.
+         *
+         * This effectively reduces the container size by the number of element removed.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(position: VectorIterator<T>): VectorIterator<T>;
+        /**
+         * Erase element.
+         *
+         * Removes from the <ode>Vector</code> either a single element; <i>position</i>.
+         *
+         * This effectively reduces the container size by the number of elements removed.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
+        /**
+         * Erase element.
+         *
+         * Removes from the {@link Vector} either a single element; <i>position</i>.
+         *
+         * This effectively reduces the container size by the number of element removed.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(position: VectorReverseIterator<T>): VectorReverseIterator<T>;
+        /**
+         * Erase element.
+         *
+         * Removes from the <ode>Vector</code> either a single element; <i>position</i>.
+         *
+         * This effectively reduces the container size by the number of elements removed.
+         *
+         * Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(first: VectorReverseIterator<T>, last: VectorReverseIterator<T>): VectorReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link Vector container} object with same type of elements. Sizes and container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link Vector container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link Vector container}.
+         */
+        swap(obj: Vector<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * An iterator of Vector.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class VectorIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
+        /**
+         * @hidden
+         */
+        private index_;
+        /**
+         * Construct from the source {@link Vector container}.
+         *
+         * #### Note
+         * Do not create the iterator directly, by yourself.
+         *
+         * Use {@link Vector.begin begin()}, {@link Vector.end end()} in {@link Vector container} instead.
+         *
+         * @param source The source {@link Vector container} to reference.
+         * @param index Sequence number of the element in the source {@link Vector}.
+         */
+        constructor(source: Vector<T>, index: number);
+        /**
+         * @inheritdoc
+         */
+        source(): Vector<T>;
+        /**
+         * @inheritdoc
+         */
+        index(): number;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * @inheritdoc
+         */
+        prev(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(n: number): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        equals(obj: VectorIterator<T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: VectorIterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * A reverse-iterator of Vector.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class VectorReverseIterator<T> extends ReverseIterator<T, Vector<T>, VectorIterator<T>, VectorReverseIterator<T>> implements base.IArrayIterator<T> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: VectorIterator<T>);
+        /**
+         * @hidden
+         */
+        protected _Create_neighbor(base: VectorIterator<T>): VectorReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        index(): number;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+    }
+}
+declare namespace std {
+    /**
+     * FIFO queue.
+     *
+     * {@link Queue}s are a type of container adaptor, specifically designed to operate in a FIFO context
+     * (first-in first-out), where elements are inserted into one end of the container and extracted from the other.
+     *
+     * {@link Queue}s are implemented as containers adaptors, which are classes that use an encapsulated object of
+     * a specific container class as its underlying container, providing a specific set of member functions to access
+     * its elements. Elements are pushed into the {@link IDeque.back back()} of the specific container and popped from
+     * its {@link IDeque.front front()}.
+     *
+     * {@link container_ The underlying container} may be one of the standard container class template or some
+     * other specifically designed container class. This underlying container shall support at least the following
+     * operations:
+     *
+     * - {@link IDequeContainer.empty empty}
+     * - {@link IDequeContainer.size size}
+     * - {@link IDequeContainer.front front}
+     * - {@link IDequeContainer.back back}
+     * - {@link IDequeContainer.push_back push_back}
+     * - {@link IDequeContainer.pop_front pop_front}
+     *
+     * The standard container classes {@link Deque} and {@link List} fulfill these requirements.
+     * By default, if no container class is specified for a particular {@link Queue} class instantiation, the standard
+     * container {@link List} is used.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     *
+     * @param <T> Type of elements.
+     *
+     * @reference http://www.cplusplus.com/reference/queue/queue
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Queue<T> {
+        /**
+         * The <i>underlying object</i> for implementing the <i>FIFO</i>
+         */
+        private container_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: Queue<T>);
+        /**
+         * Return size.
+         *
+         * Returns the number of elements in the {@link Queue}.
+         *
+         * This member function effectively calls member {@link IDeque.size size()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @return The number of elements in the {@link container_ underlying container}.
+         */
+        size(): number;
+        /**
+         * Test whether container is empty.
+         *
+         * returns whether the {@link Queue} is empty: i.e. whether its <i>size</i> is zero.
+         *
+         * This member function efeectively calls member {@link IDeque.empty empty()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @return <code>true</code> if the {@link container_ underlying container}'s size is 0,
+         *		   <code>false</code> otherwise.
+         */
+        empty(): boolean;
+        /**
+         * Access next element.
+         *
+         * Returns a value of the next element in the {@link Queue}.
+         *
+         * The next element is the "oldest" element in the {@link Queue} and the same element that is popped out
+         * from the queue when {@link pop Queue.pop()} is called.
+         *
+         * This member function effectively calls member {@link IDeque.front front()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @return A value of the next element in the {@link Queue}.
+         */
+        front(): T;
+        /**
+         * Access last element.
+         *
+         * Returns a vaue of the last element in the queue. This is the "newest" element in the queue (i.e. the
+         * last element pushed into the queue).
+         *
+         * This member function effectively calls the member function {@link IDeque.back back()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @return A value of the last element in the {@link Queue}.
+         */
+        back(): T;
+        /**
+         * Insert element.
+         *
+         * Inserts a new element at the end of the {@link Queue}, after its current last element.
+         * The content of this new element is initialized to <i>val</i>.
+         *
+         * This member function effectively calls the member function {@link IDeque.push_back push_back()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @param val Value to which the inserted element is initialized.
+         */
+        push(val: T): void;
+        /**
+         * Remove next element.
+         *
+         * Removes the next element in the {@link Queue}, effectively reducing its size by one.
+         *
+         * The element removed is the "oldest" element in the {@link Queue} whose value can be retrieved by calling
+         * member {@link front Queue.front()}.
+         *
+         * This member function effectively calls the member function {@link IDeque.pop_front pop_front()} of the
+         * {@link container_ underlying container} object.
+         */
+        pop(): void;
+        /**
+         * Swap contents.
+         *
+         * Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>.
+         *
+         * This member function calls the non-member function {@link Container.swap swap} (unqualified) to swap
+         * the {@link container_ underlying containers}.
+         *
+         * @param obj Another {@link Queue} container adaptor of the same type (i.e., instantiated with the same
+         *			  template parameter, <b>T</b>). Sizes may differ.
+         */
+        swap(obj: Queue<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * Priority queue.
+     *
+     * {@link PriorityQueue Priority queues} are a type of container adaptors, specifically designed such that its
+     * first element is always the greatest of the elements it contains, according to some <i>strict weak ordering</i>
+     * criterion.
+     *
+     * This context is similar to a <i>heap</i>, where elements can be inserted at any moment, and only the
+     * <i>max heap</i> element can be retrieved (the one at the top in the {@link PriorityQueue priority queue}).
+     *
+     * {@link PriorityQueue Priority queues} are implemented as <i>container adaptors</i>, which are classes that
+     * use an encapsulated object of a specific container class as its {@link container_ underlying container},
+     * providing a specific set of member functions to access its elements. Elements are popped from the <i>"back"</i>
+     * of the specific container, which is known as the <i>top</i> of the {@link PriorityQueue Priority queue}.
+     *
+     * The {@link container_ underlying container} may be any of the standard container class templates or some
+     * other specifically designed container class. The container shall be accessible through
+     * {@link IArrayIterator random access iterators} and support the following operations:
+     *
+     * - {@link IArrayContainer.empty empty()}
+     * - {@link IArrayContainer.size size()}
+     * - {@link IArrayContainer.front front()}
+     * - {@link IArrayContainer.push_back push_back()}
+     * - {@link IArrayContainer.pop_back pop_back()}
+     *
+     * The standard container classes {@link Vector} and {@link Deque} fulfill these requirements. By default, if
+     * no container class is specified for a particular {@link PriorityQueue} class instantiation, the standard
+     * container {@link Vector} is used.
+     *
+     * Support of {@link IArrayIterator random access iterators} is required to keep a heap structure internally
+     * at all times. This is done automatically by the container adaptor by automatically calling the algorithm
+     * functions <i>make_heap</i>, <i>push_heap</i> and <i>pop_heap</i> when needed.
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/queue/priority_queue/
+     * @author Jeongho Nam
+     */
+    class PriorityQueue<T> {
+        /**
+         * @hidden
+         */
+        private container_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (left: T, right: T) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<T>);
+        /**
+         * Contruct from elements with compare.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<T>, compare: (left: T, right: T) => boolean);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: base.Container<T>);
+        /**
+         * Copy Constructor with compare.
+         *
+         * @param container A container to be copied.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: base.Container<T>, compare: (left: T, right: T) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * Range Constructor with compare.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (left: T, right: T) => boolean);
+        /**
+         * Return size.
+         *
+         * Returns the number of elements in the {@link PriorityQueue}.
+         *
+         * This member function effectively calls member {@link IArrayContainer.size size} of the
+         * {@link IArrayContainer underlying container} object.
+         *
+         * @return The number of elements in the underlying
+         */
+        size(): number;
+        /**
+         * Test whether container is empty.
+         *
+         * Returns whether the {@link PriorityQueue} is empty: i.e. whether its {@link size} is zero.
+         *
+         * This member function effectively calls member {@link IARray.empty empty} of the
+         * {@link IArrayContainer underlying container} object.
+         */
+        empty(): boolean;
+        /**
+         * Access top element.
+         *
+         * Returns a constant reference to the top element in the {@link PriorityQueue}.
+         *
+         * The top element is the element that compares higher in the {@link PriorityQueue}, and the next that is
+         * removed from the container when {@link PriorityQueue.pop} is called.
+         *
+         * This member function effectively calls member {@link IArrayContainer.front front} of the
+         * {@link IArrayContainer underlying container} object.
+         *
+         * @return A reference to the top element in the {@link PriorityQueue}.
+         */
+        top(): T;
+        /**
+         * Insert element.
+         *
+         * Inserts a new element in the {@link PriorityQueue}. The content of this new element is initialized to
+         * <i>val</i>.
+         *
+         * This member function effectively calls the member function {@link IArrayContainer.push_back push_back} of the
+         * {@link IArrayContainer underlying container} object, and then reorders it to its location in the heap by calling
+         * the <i>push_heap</i> algorithm on the range that includes all the elements of the
+         *
+         * @param val Value to which the inserted element is initialized.
+         */
+        push(val: T): void;
+        /**
+         * Remove top element.
+         *
+         * Removes the element on top of the {@link PriorityQueue}, effectively reducing its {@link size} by one.
+         * The element removed is the one with the highest (or lowest) value.
+         *
+         * The value of this element can be retrieved before being popped by calling member
+         * {@link PriorityQueue.top}.
+         *
+         * This member function effectively calls the <i>pop_heap</i> algorithm to keep the heap property of
+         * {@link PriorityQueue PriorityQueues} and then calls the member function {@link IArrayContainer.pop_back pop_back} of
+         * the {@link IArrayContainer underlying container} object to remove the element.
+         */
+        pop(): void;
+        /**
+         * Swap contents.
+         *
+         * Exchanges the contents of the container adaptor by those of <i>obj</i>, swapping both the
+         * {@link IArrayContainer underlying container} value and their comparison function using the corresponding
+         * {@link swap swap} non-member functions (unqualified).
+         *
+         * This member function has a <i>noexcept</i> specifier that matches the combined <i>noexcept</i> of the
+         * {@link IArrayContainer.swap swap} operations on the {@link IArrayContainer underlying container} and the comparison
+         * functions.
+         *
+         * @param obj {@link PriorityQueue} container adaptor of the same type (i.e., instantiated with the same
+         *			  template parameters, <b>T</b>). Sizes may differ.
+         */
+        swap(obj: PriorityQueue<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * LIFO stack.
+     *
+     * {@link Stack}s are a type of container adaptor, specifically designed to operate in a LIFO context
+     * (last-in first-out), where elements are inserted and extracted only from one end of the
+     *
+     * {@link Stack}s are implemented as containers adaptors, which are classes that use an encapsulated object of
+     * a specific container class as its <i>underlying container</i>, providing a specific set of member functions to
+     * access its elements. Elements are pushed/popped from the {@link ILinearContainer.back back()} of the
+     * {@link ILinearContainer specific container}, which is known as the top of the {@link Stack}.
+     *
+     * {@link container_ The underlying container} may be any of the standard container class templates or some
+     * other specifically designed container class. The container shall support the following operations:
+     *
+     * - {@link ILinearContainer.empty empty}
+     * - {@link ILinearContainer.size size}
+     * - {@link ILinearContainer.front front}
+     * - {@link ILinearContainer.back back}
+     * - {@link ILinearContainer.push_back push_back}
+     * - {@link ILinearContainer.pop_back pop_back}
+     *
+     * The standard container classes {@link Vector}, {@link Deque} and {@link List} fulfill these requirements.
+     * By default, if no container class is specified for a particular {@link Stack} class instantiation, the standard
+     * container {@link List} is used.
+     *
+     * <a href="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     *
+     * @param <T> Type of elements.
+     *
+     * @reference http://www.cplusplus.com/reference/stack/stack
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Stack<T> {
+        /**
+         * The <i>underlying object</i> for implementing the <i>LIFO</i>
+         */
+        private container_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Copy Constructor.
+         */
+        constructor(stack: Stack<T>);
+        /**
+         * Return size.
+         *
+         * Returns the number of elements in the {@link Stack}.
+         *
+         * This member function effectively calls member {@link ILinearContainer.size size()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @return The number of elements in the {@link container_ underlying container}.
+         */
+        size(): number;
+        /**
+         * Test whether container is empty.
+         *
+         * returns whether the {@link Stack} is empty: i.e. whether its <i>size</i> is zero.
+         *
+         * This member function effectively calls member {@link ILinearContainer.empty empty()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @return <code>true</code> if the <i>underlying container</i>'s size is 0,
+         *		   <code>false</code> otherwise.
+         */
+        empty(): boolean;
+        /**
+         * Access next element.
+         *
+         * Returns a value of the top element in the {@link Stack}.
+         *
+         * Since {@link Stack}s are last-in first-out containers, the top element is the last element inserted into
+         * the {@link Stack}.
+         *
+         * This member function effectively calls member {@link ILinearContainer.back back()} of the
+         * {@link container_ underlying container} object.
+         *
+         * @return A value of the top element in the {@link Stack}.
+         */
+        top(): T;
+        /**
+         * Insert element.
+         *
+         * Inserts a new element at the top of the {@link Stack}, above its current top element.
+         *
+         * This member function effectively calls the member function
+         * {@link ILinearContainer.push_back push_back()} of the {@link container_ underlying container} object.
+         *
+         * @param val Value to which the inserted element is initialized.
+         */
+        push(val: T): void;
+        /**
+         * Remove top element.
+         *
+         * Removes the element on top of the {@link Stack}, effectively reducing its size by one.
+         *
+         * The element removed is the latest element inserted into the {@link Stack}, whose value can be retrieved
+         * by calling member {@link top Stack.top()}.
+         *
+         * This member function effectively calls the member function {@link ILinearContainer.pop_back pop_back()}
+         * of the {@link container_ underlying container} object.
+         */
+        pop(): void;
+        /**
+         * Swap contents.
+         *
+         * Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>.
+         *
+         * This member function calls the non-member function {@link Container.swap swap} (unqualified) to swap
+         * the {@link container_ underlying containers}.
+         *
+         * @param obj Another {@link Stack} container adaptor of the same type (i.e., instantiated with the same
+         *			  template parameter, <b>T</b>). Sizes may differ.
+         */
+        swap(obj: Stack<T>): void;
+    }
+}
+declare namespace std.TreeSet {
+    type iterator<T> = SetIterator<T>;
+    type reverse_iterator<T> = SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * Tree-structured set, <code>std::set</code> of STL.
+     *
+     * {@link TreeSet}s are containers that store unique elements following a specific order.
+     *
+     * In a {@link TreeSet}, the value of an element also identifies it (the value is itself the
+     * <i>key</i>, of type <i>T</i>), and each value must be unique. The value of the elements in a
+     * {@link TreeSet} cannot be modified once in the container (the elements are always const), but they
+     * can be inserted or removed from the container.
+     *
+     * Internally, the elements in a {@link TreeSet} are always sorted following a specific strict weak
+     * ordering criterion indicated by its internal comparison method (of {@link less}).
+     *
+     * {@link TreeSet} containers are generally slower than {@link HashSet} containers to access
+     * individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on their
+     * order.
+     *
+     * {@link TreeSet}s are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *			  Each element in an {@link TreeSet} is also uniquely identified by this value.
+     *
+     * @reference http://www.cplusplus.com/reference/set/set
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeSet<T> extends base.UniqueSet<T> implements base.ITreeSet<T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: T, y: T) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<T>);
+        /**
+         * Contruct from elements with compare.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: TreeMultiSet<T>);
+        /**
+         * Copy Constructor with compare.
+         *
+         * @param container A container to be copied.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * Construct from range and compare.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeSet set} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link TreeSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeSet container}.
+         */
+        swap(obj: TreeSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<T>): void;
+    }
+}
+declare namespace std.TreeMap {
+    type iterator<Key, T> = MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * Tree-structured map, <code>std::map</code> of STL.
+     *
+     * {@link TreeMap TreeMaps} are associative containers that store elements formed by a combination of a
+     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), following order.
+     *
+     * In a {@link TreeMap}, the <i>key values</i> are generally used to sort and uniquely identify the elements,
+     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a {@link Pair}
+     * type combining both:
+     *
+     * <code>typedef Pair<Key, T> value_type;</code>
+     *
+     * Internally, the elements in a {@link TreeMap} are always sorted by its <i>key</i> following a
+     * <i>strict weak ordering</i> criterion indicated by its internal comparison method {@link less}.
+     *
+     * {@link TreeMap} containers are generally slower than {@link HashMap HashMap} containers to access individual
+     * elements by their <i>key</i>, but they allow the direct iteration on subsets based on their order.
+     *
+     * {@link TreeMap}s are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
+     *		 given a position in this order. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/map/map
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeMap<Key, T> extends base.UniqueMap<Key, T> implements base.ITreeMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<Pair<Key, T>>);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: Array<[Key, T]>);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         */
+        constructor(container: TreeMap<Key, T>);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMap<Key, T>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: Key, y: Key) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeMap map} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link TreeMap map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeMap container}.
+         */
+        swap(obj: TreeMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<Pair<Key, T>>): void;
+    }
+}
+declare namespace std.TreeMultiSet {
+    type iterator<T> = SetIterator<T>;
+    type reverse_iterator<T> = SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * Tree-structured multiple-key set.
+     *
+     * {@link TreeMultiSet TreeMultiSets} are containers that store elements following a specific order, and
+     * where multiple elements can have equivalent values.
+     *
+     * In a {@link TreeMultiSet}, the value of an element also identifies it (the value is itself
+     * the <i>key</i>, of type <i>T</i>). The value of the elements in a {@link TreeMultiSet} cannot
+     * be modified once in the container (the elements are always const), but they can be inserted or removed
+     * from the container.
+     *
+     * Internally, the elements in a {@link TreeMultiSet TreeMultiSets} are always sorted following a strict
+     * weak ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}).
+     *
+     * {@link TreeMultiSet} containers are generally slower than {@link HashMultiSet} containers
+     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on
+     * their order.
+     *
+     * {@link TreeMultiSet TreeMultiSets} are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link TreeMultiSet} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @reference http://www.cplusplus.com/reference/set/multiset
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeMultiSet<T> extends base.MultiSet<T> implements base.ITreeSet<T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: T, y: T) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<T>);
+        /**
+         * Contruct from elements with compare.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: TreeMultiSet<T>);
+        /**
+         * Copy Constructor with compare.
+         *
+         * @param container A container to be copied.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * Construct from range and compare.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        count(val: T): number;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeMultiSet set} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link TreeMultiSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeMultiSet container}.
+         */
+        swap(obj: TreeMultiSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<T>): void;
+    }
+}
+declare namespace std.TreeMultiMap {
+    type iterator<Key, T> = MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * Tree-structured multiple-key map.
+     *
+     * {@link TreeMultiMap TreeMultiMaps} are associative containers that store elements formed by a combination of
+     * a <i>key value</i> and a <i>mapped value</i>, following a specific order, and where multiple elements can
+     * have equivalent keys.
+     *
+     * In a {@link TreeMultiMap}, the <i>key values</i> are generally used to sort and uniquely identify
+     * the elements, while the <i>mapped values</i> store the content associated to this <i>key</i>. The types of
+     * <i>key</i> and <i>mapped value</i> may differ, and are grouped together in member type
+     * <code>value_type</code>, which is a {@link Pair} type combining both:
+     *
+     * <code>typedef Pair<const Key, T> value_type;</code>
+     *
+     * Internally, the elements in a {@link TreeMultiMap}are always sorted by its key following a
+     * strict weak ordering criterion indicated by its internal comparison method (of {@link less}).
+     *
+     * {@link TreeMultiMap}containers are generally slower than {@link HashMap} containers
+     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based
+     * on their order.
+     *
+     * {@link TreeMultiMap TreeMultiMaps} are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" target="_blank"> <
+     * img src="http://samchon.github.io/tstl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * ### Container properties
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/map/multimap
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeMultiMap<Key, T> extends base.MultiMap<Key, T> implements base.ITreeMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<Pair<Key, T>>);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: Array<[Key, T]>);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         */
+        constructor(container: TreeMultiMap<Key, T>);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMultiMap<Key, T>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        count(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: Key, y: Key) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @hidden
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * Swap content.
+         *
+         * Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeMapMulti map} of the same type. Sizes abd container type may differ.
+         *
+         * After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects.
+         *
+         * Notice that a non-member function exists with the same name, {@link swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function.
+         *
+         * @param obj Another {@link TreeMapMulti map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeMapMulti container}.
+         */
+        swap(obj: TreeMultiMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.Container<Pair<Key, T>>): void;
+    }
+}
+declare namespace std {
+    /**
+     * System error exception.
+     *
+     * This class defines the type of objects thrown as exceptions to report conditions originating during
+     * runtime from the operating system or other low-level application program interfaces which have an
+     * associated {@link ErrorCode}.
+     *
+     * The class inherits from {@link RuntimeError}, to which it adds an {@link ErrorCode} as
+     * member code (and defines a specialized what member).
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/system_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class SystemError extends RuntimeError {
+        /**
+         * @hidden
+         */
+        protected code_: ErrorCode;
+        /**
+         * Construct from an error code.
+         *
+         * @param code An {@link ErrorCode} object.
+         */
+        constructor(code: ErrorCode);
+        /**
+         * Construct from an error code and message.
+         *
+         * @param code An {@link ErrorCode} object.
+         * @param message A message incorporated in the string returned by member {@link what what()}.
+         */
+        constructor(code: ErrorCode, message: string);
+        /**
+         * Construct from a numeric value and error category.
+         *
+         * @param val A numerical value identifying an error code.
+         * @param category A reference to an {@link ErrorCode} object.
+         */
+        constructor(val: number, category: ErrorCategory);
+        /**
+         * Construct from a numeric value, error category and message.
+         *
+         * @param val A numerical value identifying an error code.
+         * @param category A reference to an {@link ErrorCode} object.
+         * @param message A message incorporated in the string returned by member {@link what what()}.
+         */
+        constructor(val: number, category: ErrorCategory, message: string);
+        /**
+         * Get error code.
+         *
+         * Returns the {@link ErrorCode} object associated with the exception.
+         *
+         * This value is either the {@link ErrorCode} passed to the construction or its equivalent
+         * (if constructed with a value and a {@link category}.
+         *
+         * @return The {@link ErrorCode} associated with the object.
+         */
+        code(): ErrorCode;
+    }
+}
+declare namespace std {
+    /**
+     * Error category.
+     *
+     * This type serves as a base class for specific category types.
+     *
+     * Category types are used to identify the source of an error. They also define the relation between
+     * {@link ErrorCode} and {@link ErrorCondition}objects of its category, as well as the message set for {@link ErrorCode}
+     * objects.
+     *
+     * Objects of these types have no distinct values and are not-copyable and not-assignable, and thus can only be
+     * passed by reference. As such, only one object of each of these types shall exist, each uniquely identifying its own
+     * category: all error codes and conditions of a same category shall return a reference to same object.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/error_category
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ErrorCategory {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Return category name.
+         *
+         * In derived classes, the function returns a string naming the category.
+         *
+         * In {@link ErrorCategory}, it is a pure virtual member function.
+         *
+         * <ul>
+         *	<li> In the {@link GenericCategory} object, it returns <i>"generic"</i>. </li>
+         *	<li> In the {@link SystemCategory} object, it returns <i>"system"</i>. </li>
+         *	<li> In the {@link IOStreamCategory} object, it returns <i>"iostream"</i>. </li>
+         * </ul>
+         *
+         * @return The category name.
+         */
+        abstract name(): string;
+        /**
+         * Error message.
+         *
+         * In derived classes, the function returns a string object with a message describing the error condition
+         * denoted by <i>val</i>.
+         *
+         * In {@link ErrorCategory}, it is a pure virtual member function.
+         *
+         * This function is called both by {@link ErrorCode.message ErrorCode.message()} and
+         * {@link ErrorCondition.message ErrorCondition.message()} to obtain the corresponding message in the
+         * {@link category}. Therefore, numerical values used by custom <i>error codes</i> and
+         * {@link ErrorCondition error conditions} should only match for a category if they describe the same error.
+         *
+         * @param val A numerical value identifying an error condition.
+         *			  If the {@link ErrorCategory} object is the {@link GenericCategory}, this argument is equivalent to an
+         *			  {@link errno} value.
+         *
+         * @return A string object with the message.
+         */
+        abstract message(val: number): string;
+        /**
+         * Default error condition.
+         *
+         * Returns the default {@link ErrorCondition}object of this category that is associated with the
+         * {@link ErrorCode} identified by a value of <i>val</i>.
+         *
+         * Its definition in the base class {@link ErrorCategory} returns the same as constructing an
+         * {@link ErrorCondition} object with:
+         *
+         * <code>new ErrorCondition(val, *this);</code>
+         *
+         * As a virtual member function, this behavior can be overriden in derived classes.
+         *
+         * This function is called by the default definition of member {@link equivalent equivalent()}, which is used to
+         * compare {@link ErrorCondition error conditions} with error codes.
+         *
+         * @param val A numerical value identifying an error condition.
+         *
+         * @return The default {@link ErrorCondition}object associated with condition value <i>val</i> for this category.
+         */
+        default_error_condition(val: number): ErrorCondition;
+        /**
+         * Check error code equivalence.
+         *
+         * Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
+         * {@link ErrorCondition error condition.
+         *
+         * This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
+         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
+         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
+         * equivalent by the operator.
+         *
+         * As a virtual member function, this behavior can be overridden in derived classes to define a different
+         * correspondence mechanism for each {@link ErrorCategory} type.
+         *
+         * @param val_code A numerical value identifying an error code.
+         * @param cond An object of an {@link ErrorCondition} type.
+         *
+         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
+         */
+        equivalent(val_code: number, cond: ErrorCondition): boolean;
+        /**
+         * Check error code equivalence.
+         *
+         * Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
+         * {@link ErrorCondition error condition.
+         *
+         * This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
+         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
+         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
+         * equivalent by the operator.
+         *
+         * As a virtual member function, this behavior can be overridden in derived classes to define a different
+         * correspondence mechanism for each {@link ErrorCategory} type.
+         *
+         * @param code An object of an {@link ErrorCode} type.
+         * @param val_cond A numerical value identifying an error code.
+         *
+         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
+         */
+        equivalent(code: ErrorCode, val_cond: number): boolean;
+    }
+}
+declare namespace std {
+    /**
+     * Error condition.
+     *
+     * Objects of this type hold a condition {@link value} associated with a {@link category}.
+     *
+     * Objects of this type describe errors in a generic way so that they may be portable across different
+     * systems. This is in contrast with {@link ErrorCode} objects, that may contain system-specific
+     * information.
+     *
+     * Because {@link ErrorCondition}objects can be compared with error_code objects directly by using
+     * <code>relational operators</code>, {@link ErrorCondition}objects are generally used to check whether
+     * a particular {@link ErrorCode} obtained from the system matches a specific error condition no matter
+     * the system.
+     *
+     * The {@link ErrorCategory categories} associated with the {@link ErrorCondition} and the
+     * {@link ErrorCode} define the equivalences between them.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/error_condition
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ErrorCondition extends base.ErrorInstance {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from a numeric value and error category.
+         *
+         * @param val A numerical value identifying an error condition.
+         * @param category A reference to an {@link ErrorCategory} object.
+         */
+        constructor(val: number, category: ErrorCategory);
+    }
+}
+declare namespace std {
+    /**
+     * Error code.
+     *
+     * Objects of this type hold an error code {@link value} associated with a {@link category}.
+     *
+     * The operating system and other low-level applications and libraries generate numerical error codes to
+     * represent possible results. These numerical values may carry essential information for a specific platform,
+     * but be non-portable from one platform to another.
+     *
+     * Objects of this class associate such numerical codes to {@link ErrorCategory error categories}, so that they
+     * can be interpreted when needed as more abstract (and portable) {@link ErrorCondition error conditions}.
+     *
+     * <a href="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/tstl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/error_code
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ErrorCode extends base.ErrorInstance {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from a numeric value and error category.
+         *
+         * @param val A numerical value identifying an error code.
+         * @param category A reference to an {@link ErrorCategory} object.
+         */
+        constructor(val: number, category: ErrorCategory);
+    }
+}
+declare namespace std {
+    /**
+     * Running on Node.
+     *
+     * Test whether the JavaScript is running on Node.
+     *
+     * @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
+     */
+    function is_node(): boolean;
+    /**
+     * Pair of values.
+     *
+     * This class couples together a pair of values, which may be of different types (<i>T1</i> and
+     * <i>T2</i>). The individual values can be accessed through its public members {@link first} and
+     * {@link second}.
+     *
+     * @param <T1> Type of member {@link first}.
+     * @param <T2> Type of member {@link second}.
+     *
+     * @reference http://www.cplusplus.com/reference/utility/pair
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Pair<T1, T2> implements IComparable<Pair<T1, T2>> {
+        /**
+         * A first value in the Pair.
+         */
+        first: T1;
+        /**
+         * A second value in the Pair.
+         */
+        second: T2;
+        /**
+         * Construct from pair values.
+         *
+         * @param first The first value of the Pair
+         * @param second The second value of the Pair
+         */
+        constructor(first: T1, second: T2);
+        /**
+         * Whether a Pair is equal with the Pair.
+         *
+         * Compare each first and second value of two Pair(s) and returns whether they are equal or not.
+         *
+         * If stored key and value in a Pair are not number or string but an object like a class or struct,
+         * the comparison will be executed by a member method (SomeObject)::equals(). If the object does not have
+         * the member method equal_to(), only address of pointer will be compared.
+         *
+         * @param obj A Map to compare
+         * @return Indicates whether equal or not.
+         */
+        equals<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
+        /**
+         * @inheritdoc
+         */
+        less<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
+    }
+    /**
+     * Construct {@link Pair} object.
+     *
+     * Constructs a {@link Pair} object with its {@link Pair.first first} element set to <i>x</i> and its
+     * {@link Pair.second second} element set to <i>y</i>.
+     *
+     * The template types can be implicitly deduced from the arguments passed to {@link make_pair}.
+     *
+     * {@link Pair} objects can be constructed from other {@link Pair} objects containing different types, if the
+     * respective types are implicitly convertible.
+     *
+     * @param x Value for member {@link Pair.first first}.
+     * @param y Value for member {@link Pair.second second}.
+     *
+     * @return A {@link Pair} object whose elements {@link Pair.first first} and {@link Pair.second second} are set to
+     *		   <i>x</i> and <i>y</i> respectivelly.
+     */
+    function make_pair<T1, T2>(x: T1, y: T2): Pair<T1, T2>;
+}
+declare namespace std {
+    /**
+     * Type definition of {@link Vector} and it's the original name used in C++.
+     */
+    export import vector = Vector;
+    /**
+     * Type definition of {@link List} and it's the original name used in C++.
+     */
+    export import list = List;
+    /**
+     * Type definition of {@link Deque} and it's the original name used in C++.
+     */
+    export import deque = Deque;
+    /**
+     * Type definition of {@link Stack} and it's the original name used in C++.
+     */
+    type stack<T> = Stack<T>;
+    /**
+     * Type definition of {@link Queue} and it's the original name used in C++.
+     */
+    type queue<T> = Queue<T>;
+    /**
+     * Type definition of {@link PriorityQueue} and it's the original name used in C++.
+     */
+    type priority_queue<T> = PriorityQueue<T>;
+    var stack: typeof Stack;
+    var queue: typeof Queue;
+    var priority_queue: typeof PriorityQueue;
+    /**
+     * Type definition of {@link TreeSet} and it's the original name used in C++.
+     */
+    export import set = TreeSet;
+    /**
+     * Type definition of {@link TreeMultiSet} and it's the original name used in C++.
+     */
+    export import multiset = TreeMultiSet;
+    /**
+     * Type definition of {@link HashSet} and it's the original name used in C++.
+     */
+    export import unordered_set = HashSet;
+    /**
+     * Type definition of {@link HashMultiSet} and it's the original name used in C++.
+     */
+    export import unordered_multiset = HashMultiSet;
+    /**
+     * Type definition of {@link TreeMap} and it's the original name used in C++.
+     */
+    export import map = TreeMap;
+    /**
+     * Type definition of {@link TreeMultiMap} and it's the original name used in C++.
+     */
+    export import multimap = TreeMultiMap;
+    /**
+     * Type definition of {@link HashMap} and it's the original name used in C++.
+     */
+    export import unordered_map = HashMap;
+    /**
+     * Type definition of {@link HashMultiMap} and it's the original name used in C++.
+     */
+    export import unordered_multimap = HashMultiMap;
+    type exception = Exception;
+    type logic_error = LogicError;
+    type domain_error = DomainError;
+    type invalid_argument = InvalidArgument;
+    type length_error = LengthError;
+    type out_of_range = OutOfRange;
+    type runtime_error = RuntimeError;
+    type overflow_error = OverflowError;
+    type underflow_error = UnderflowError;
+    type range_error = RangeError;
+    type system_error = SystemError;
+    type error_category = ErrorCategory;
+    type error_condition = ErrorCondition;
+    type error_code = ErrorCode;
+    var exception: typeof Exception;
+    var logic_error: typeof LogicError;
+    var domain_error: typeof DomainError;
+    var invalid_argument: typeof InvalidArgument;
+    var length_error: typeof LengthError;
+    var out_of_range: typeof OutOfRange;
+    var runtime_error: typeof RuntimeError;
+    var overflow_error: typeof OverflowError;
+    var underflow_error: typeof UnderflowError;
+    var range_error: typeof RangeError;
+    var system_error: typeof SystemError;
+    var error_category: typeof ErrorCategory;
+    var error_condition: typeof ErrorCondition;
+    var error_code: typeof ErrorCode;
+}
diff --git a/tstl/tsconfig.json b/tstl/tsconfig.json
new file mode 100644
index 0000000000..b5f47406d8
--- /dev/null
+++ b/tstl/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "tstl-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/tstl/tstl-tests.ts b/tstl/tstl-tests.ts
new file mode 100644
index 0000000000..ec42d087b4
--- /dev/null
+++ b/tstl/tstl-tests.ts
@@ -0,0 +1,2 @@
+import std = require("tstl");
+console.log(std);
\ No newline at end of file
diff --git a/typescript-stl/index.d.ts b/typescript-stl/index.d.ts
index bd6886deed..bbd6c5ca57 100644
--- a/typescript-stl/index.d.ts
+++ b/typescript-stl/index.d.ts
@@ -1,12485 +1,13 @@
-// Type definitions for TypeScript-STL v1.2.4
-// Project: https://github.com/samchon/typescript-stl
+// Type definitions for TSTL v1.3.x
+// Project: https://github.com/samchon/tstl
 // Definitions by: Jeongho Nam <http://samchon.org>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+/// <reference types="tstl" />
+// TypeScript-STL is renamed to TSTL
+
 declare module "typescript-stl"
 {
+	import std = require("tstl");
 	export = std;
-}
-
-/**
- * <h1> TypeScript-STL </h1>
- * <p> <a href="https://nodei.co/npm/typescript-stl">
- *	<img src="https://nodei.co/npm/typescript-stl.png?downloads=true&downloadRank=true&stars=true"> </a> </p>
- *
- * <p> STL (Standard Template Library) Containers and Algorithms for TypeScript. </p>
- *
- * <p> TypeScript-STL is a TypeScript's <b>Standard Template Library</b> who is migrated from C++ STL. Most of classes
- * and functions of STL have implemented. Just enjoy it. </p>
- *
- * @git https://github.com/samchon/typescript-stl
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace std {
-}
-/**
- * Base classes composing STL in background.
- *
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace std.base {
-}
-declare namespace std {
-    /**
-     * <p> Apply function to range. </p>
-     *
-     * <p> Applies function <i>fn</i> to each of the elements in the range [<i>first</i>, <i>last</i>). </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param fn Unary function that accepts an element in the range as argument. This can either be a function p
-     *			 ointer or a move constructible function object. Its return value, if any, is ignored.
-     */
-    function for_each<T, InputIterator extends Iterator<T>, Func extends (val: T) => any>(first: InputIterator, last: InputIterator, fn: Func): Func;
-    /**
-     * Apply function to range.
-     *
-     * Applies function *fn* to each of the elements in the range [*first*, *first + n*).
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param n the number of elements to apply the function to
-     * @param fn Unary function that accepts an element in the range as argument. This can either be a function p
-     *			 ointer or a move constructible function object. Its return value, if any, is ignored.
-     *
-     * @return first + n
-     */
-    function for_each_n<T, InputIterator extends Iterator<T>>(first: InputIterator, n: number, fn: (val: T) => any): InputIterator;
-    /**
-     * <p> Test condition on all elements in range. </p>
-     *
-     * <p> Returns <code>true</code> if <i>pred</i> returns <code>true</code> for all the elements in the range
-     * [<i>first</i>, <i>last</i>) or if the range is {@link IContainer.empty empty}, and <code>false</code> otherwise.
-     * </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
-     *			   <code>boolean</code>. The value returned indicates whether the element fulfills the condition
-     *			   checked by this function. The function shall not modify its argument.
-     *
-     * @return <code>true</code> if pred returns true for all the elements in the range or if the range is
-     *		   {@link IContainer.empty empty}, and <code>false</code> otherwise.
-     */
-    function all_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean;
-    /**
-     * <p> Test if any element in range fulfills condition. </p>
-     *
-     * <p> Returns <code>true</code> if <i>pred</i> returns true for any of the elements in the range
-     * [<i>first</i>, <i>last</i>), and <code>false</code> otherwise. </p>
-     *
-     * <p> If [<i>first</i>, <i>last</i>) is an {@link IContainer.empty empty} range, the function returns
-     * <code>false</code>. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
-     *			   <code>boolean</code>. The value returned indicates whether the element fulfills the condition
-     *			   checked by this function. The function shall not modify its argument.
-     *
-     * @return <code>true</code> if <i>pred</i> returns <code>true</code> for any of the elements in the range
-     *		   [<i>first</i>, <i>last</i>), and <code>false</code> otherwise. If [<i>first</i>, <i>last</i>) is an
-     *		   {@link IContainer.empty empty} range, the function returns <code>false</code>.
-     */
-    function any_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean;
-    /**
-     * <p> Test if no elements fulfill condition. </p>
-     *
-     * <p> Returns <code>true</code> if <i>pred</i> returns false for all the elements in the range
-     * [<i>first</i>, <i>last</i>) or if the range is {@link IContainer.empty empty}, and <code>false</code> otherwise.
-     * </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
-     *			   <code>boolean</code>. The value returned indicates whether the element fulfills the condition
-     *			   checked by this function. The function shall not modify its argument.
-     *
-     * @return <code>true</code> if <i>pred</i> returns <code>false</code> for all the elements in the range
-     *		   [<i>first</i>, <i>last</i>) or if the range is {@link IContainer.empty empty}, and <code>false</code>
-     *		   otherwise.
-     */
-    function none_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean;
-    /**
-     * <p> Test whether the elements in two ranges are equal. </p>
-     *
-     * <p> Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
-     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
-     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
-     *
-     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
-     *		   of the range starting at <i>first2</i>, and <code>false</code> otherwise.
-     */
-    function equal<T, InputIterator extends Iterator<T>>(first1: InputIterator, last1: InputIterator, first2: Iterator<T>): boolean;
-    /**
-     * <p> Test whether the elements in two ranges are equal. </p>
-     *
-     * <p> Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
-     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
-     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
-     * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same
-     *			   order), and returns a value convertible to <code>bool</code>. The value returned indicates whether
-     *			   the elements are considered to match in the context of this function.
-     *
-     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
-     *		   of the range starting at <i>first2</i>, and <code>false</code> otherwise.
-     */
-    function equal<T, InputIterator extends Iterator<T>>(first1: InputIterator, last1: InputIterator, first2: Iterator<T>, pred: (x: T, y: T) => boolean): boolean;
-    /**
-     * <p> Lexicographical less-than comparison. </p>
-     *
-     * <p> Returns <code>true</code> if the range [<i>first1</i>, <i>last1</i>) compares <i>lexicographically less</i>
-     * than the range [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> A <i>lexicographical comparison</i> is the kind of comparison generally used to sort words alphabetically in
-     * dictionaries; It involves comparing sequentially the elements that have the same position in both ranges against
-     * each other until one element is not equivalent to the other. The result of comparing these first non-matching
-     * elements is the result of the lexicographical comparison. </p>
-     *
-     * <p> If both sequences compare equal until one of them ends, the shorter sequence is <i>lexicographically less</i>
-     * than the longer one. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence.
-     * @param last2 An {@link Iterator} to the final position of the second sequence. The ranged used is
-     *				[<i>first2</i>, <i>last2</i>).
-     *
-     * @return <code>true</code> if the first range compares <i>lexicographically less</i> than than the second.
-     *		   <code>false</code> otherwise (including when all the elements of both ranges are equivalent).
-     */
-    function lexicographical_compare<T, T1 extends T, T2 extends T, Iterator1 extends Iterator<T1>, Iterator2 extends Iterator<T2>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): boolean;
-    /**
-     * <p> Lexicographical comparison. </p>
-     *
-     * <p> Returns <code>true</code> if the range [<i>first1</i>, <i>last1</i>) compares <i>lexicographically
-     * relationship</i> than the range [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> A <i>lexicographical comparison</i> is the kind of comparison generally used to sort words alphabetically in
-     * dictionaries; It involves comparing sequentially the elements that have the same position in both ranges against
-     * each other until one element is not equivalent to the other. The result of comparing these first non-matching
-     * elements is the result of the lexicographical comparison. </p>
-     *
-     * <p> If both sequences compare equal until one of them ends, the shorter sequence is <i>lexicographically
-     * relationship</i> than the longer one. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence.
-     * @param last2 An {@link Iterator} to the final position of the second sequence. The ranged used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param compare Binary function that accepts two arguments of the types pointed by the iterators, and returns a
-     *		  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *		  considered to go before the second in the specific <i>strict weak ordering</i> it defines.
-     *
-     * @return <code>true</code> if the first range compares <i>lexicographically relationship</i> than than the
-     *		   second. <code>false</code> otherwise (including when all the elements of both ranges are equivalent).
-     */
-    function lexicographical_compare<T, T1 extends T, T2 extends T, Iterator1 extends Iterator<T1>, Iterator2 extends Iterator<T2>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, compare: (x: T, y: T) => boolean): boolean;
-    /**
-     * <p> Find value in range. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) that compares equal to
-     * <i>val</i>. If no such element is found, the function returns <i>last</i>. </p>
-     *
-     * <p> The function uses {@link equal_to equal_to} to compare the individual elements to <i>val</i>. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value to search for in the range.
-     *
-     * @return An {@link Iterator} to the first element in the range that compares equal to <i>val</i>. If no elements
-     *		   match, the function returns <i>last</i>.
-     */
-    function find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): InputIterator;
-    /**
-     * <p> Find element in range. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) for which pred returns
-     * <code>true</code>. If no such element is found, the function returns <i>last</i>. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible
-     *			   to <code>bool</code>. The value returned indicates whether the element is considered a match in
-     *			   the context of this function. The function shall not modify its argument.
-     *
-     * @return An {@link Iterator} to the first element in the range for which <i>pred</i> does not return
-     *		   <code>false</code>. If <i>pred</i> is <code>false</code> for all elements, the function returns
-     *		   <i>last</i>.
-     */
-    function find_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): InputIterator;
-    /**
-     * <p> Find element in range. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) for which pred returns
-     * <code>true</code>. If no such element is found, the function returns <i>last</i>. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible
-     *			   to <code>bool</code>. The value returned indicates whether the element is considered a match in
-     *			   the context of this function. The function shall not modify its argument.
-     *
-     * @return An {@link Iterator} to the first element in the range for which <i>pred</i> returns <code>false</code>.
-     *		   If <i>pred</i> is <code>true</code> for all elements, the function returns <i>last</i>.
-     */
-    function find_if_not<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): InputIterator;
-    /**
-     * <p> Find last subsequence in range. </p>
-     *
-     * <p> Searches the range [<i>first1</i>, <i>last1</i>) for the last occurrence of the sequence defined by
-     * [<i>first2</i>, <i>last2</i>), and returns an {@link Iterator} to its first element, or <i>last1,/i> if no
-     * occurrences are found. </p>
-     *
-     * <p> The elements in both ranges are compared sequentially using {@link equal_to}: A subsequence of
-     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is <code>true</code> for all the elements of
-     * [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> This function returns the last of such occurrences. For an algorithm that returns the first instead, see
-     * {@link search}. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
-     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
-     *				is [<i>first2</i>, <i>last2</i>).
-     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the
-     *			   same order), and returns a value convertible to <code>bool</code>. The value returned indicates
-     *			   whether the elements are considered to match in the context of this function.
-     *
-     * @return An {@link Iterator} to the first element of the last occurrence of [<i>first2</i>, <i>last2</i>) in
-     *		   [<i>first1</i>, <i>last1</i>). If the sequence is not found, the function returns ,i>last1</i>. Otherwise
-     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>last1</i>.
-     */
-    function find_end<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): Iterator1;
-    /**
-     * <p> Find last subsequence in range. </p>
-     *
-     * <p> Searches the range [<i>first1</i>, <i>last1</i>) for the last occurrence of the sequence defined by
-     * [<i>first2</i>, <i>last2</i>), and returns an {@link Iterator} to its first element, or <i>last1,/i> if no
-     * occurrences are found. </p>
-     *
-     * <p> The elements in both ranges are compared sequentially using <i>pred</i>: A subsequence of
-     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is <code>true</code> for all the elements of
-     * [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> This function returns the last of such occurrences. For an algorithm that returns the first instead, see
-     * {@link search}. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
-     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
-     *				is [<i>first2</i>, <i>last2</i>).
-     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the
-     *			   same order), and returns a value convertible to <code>bool</code>. The value returned indicates
-     *			   whether the elements are considered to match in the context of this function.
-     *
-     * @return An {@link Iterator} to the first element of the last occurrence of [<i>first2</i>, <i>last2</i>) in
-     *		   [<i>first1</i>, <i>last1</i>). If the sequence is not found, the function returns ,i>last1</i>. Otherwise
-     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>last1</i>.
-     */
-    function find_end<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, pred: (x: T, y: T) => boolean): Iterator1;
-    /**
-     * <p> Find element from set in range. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first1</i>, <i>last1</i>) that matches any of the
-     * elements in [<i>first2</i>, <i>last2</i>). If no such element is found, the function returns <i>last1</i>. </p>
-     *
-     * <p> The elements in [<i>first1</i>, <i>last1</i>) are sequentially compared to each of the values in
-     * [<i>first2</i>, <i>last2</i>) using {@link equal_to}, until a pair matches. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
-     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
-     *				is [<i>first2</i>, <i>last2</i>).
-     *
-     * @return An {@link Iterator} to the first element in [<i>first1</i>, <i>last1</i>) that is part of
-     *		   [<i>first2</i>, <i>last2</i>). If no matches are found, the function returns <i>last1</i>.
-     */
-    function find_first_of<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): Iterator1;
-    /**
-     * <p> Find element from set in range. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first1</i>, <i>last1</i>) that matches any of the
-     * elements in [<i>first2</i>, <i>last2</i>). If no such element is found, the function returns <i>last1</i>. </p>
-     *
-     * <p> The elements in [<i>first1</i>, <i>last1</i>) are sequentially compared to each of the values in
-     * [<i>first2</i>, <i>last2</i>) using <i>pred</i>, until a pair matches. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the element values to be searched for.
-     * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used
-     *				is [<i>first2</i>, <i>last2</i>).
-     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the
-     *			   same order), and returns a value convertible to <code>bool</code>. The value returned indicates
-     *			   whether the elements are considered to match in the context of this function.
-     *
-     * @return An {@link Iterator} to the first element in [<i>first1</i>, <i>last1</i>) that is part of
-     *		   [<i>first2</i>, <i>last2</i>). If no matches are found, the function returns <i>last1</i>.
-     */
-    function find_first_of<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, pred: (x: T, y: T) => boolean): Iterator1;
-    /**
-     * <p> Find equal adjacent elements in range. </p>
-     *
-     * <p> Searches the range [<i>first</i>, <i>last</i>) for the first occurrence of two consecutive elements that match,
-     * and returns an {@link Iterator} to the first of these two elements, or <i>last</i> if no such pair is found. </p>
-     *
-     * <p> Two elements match if they compare equal using {@link equal_to}. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     *
-     * @return An {@link Iterator} to the first element of the first pair of matching consecutive elements in the range
-     *		   [<i>first</i>, <i>last</i>). If no such pair is found, the function returns <i>last</i>.
-     */
-    function adjacent_find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): InputIterator;
-    /**
-     * <p> Find equal adjacent elements in range. </p>
-     *
-     * <p> Searches the range [<i>first</i>, <i>last</i>) for the first occurrence of two consecutive elements that match,
-     * and returns an {@link Iterator} to the first of these two elements, or <i>last</i> if no such pair is found. </p>
-     *
-     * <p> Two elements match if they compare equal using <i>pred</i>. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element is considered a match in the
-     *			   context of this function. The function shall not modify its argument.
-     *
-     * @return An {@link Iterator} to the first element of the first pair of matching consecutive elements in the range
-     *		   [<i>first</i>, <i>last</i>). If no such pair is found, the function returns <i>last</i>.
-     */
-    function adjacent_find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (x: T, y: T) => boolean): InputIterator;
-    /**
-     * <p> Search range for subsequence. </p>
-     *
-     * <p> Searches the range [<i>first1</i>, <i>last1</i>) for the first occurrence of the sequence defined by
-     * [<i>first2</i>, <i>last2</i>), and returns an iterator to its first element, or <i>last1</i> if no occurrences are
-     * found. </p>
-     *
-     * <p> The elements in both ranges are compared sequentially using {@link equal_to}: A subsequence of
-     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is true for <b>all</b> the elements of
-     * [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> This function returns the first of such occurrences. For an algorithm that returns the last instead, see
-     * {@link find_end}. </p>
-     *
-     * @param first1 {@link Iterator Forward iterator} to the initial position of the searched sequence.
-     * @param last1 {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Forward iterator} to the initial position of the sequence to be searched for.
-     * @param last2 {@link Iterator Forward iterator} to the final position of the sequence to be searched for. The range
-     *				used is [<i>first2</i>, <i>last2</i>).
-     *
-     * @return An iterator to the first element of the first occurrence of [<i>first2</i>, <i>last2</i>) in <i>first1</i>
-     *		   and <i>last1</i>. If the sequence is not found, the function returns <i>last1</i>. Otherwise
-     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>first1</i>.
-     */
-    function search<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2, last2: ForwardIterator2): ForwardIterator1;
-    /**
-     * <p> Search range for subsequence. </p>
-     *
-     * <p> Searches the range [<i>first1</i>, <i>last1</i>) for the first occurrence of the sequence defined by
-     * [<i>first2</i>, <i>last2</i>), and returns an iterator to its first element, or <i>last1</i> if no occurrences are
-     * found. </p>
-     *
-     * <p> The elements in both ranges are compared sequentially using <i>pred</i>: A subsequence of
-     * [<i>first1</i>, <i>last1</i>) is considered a match only when this is true for <b>all</b> the elements of
-     * [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> This function returns the first of such occurrences. For an algorithm that returns the last instead, see
-     * {@link find_end}. </p>
-     *
-     * @param first1 {@link Iterator Forward iterator} to the initial position of the searched sequence.
-     * @param last1 {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Forward iterator} to the initial position of the sequence to be searched for.
-     * @param last2 {@link Iterator Forward iterator} to the final position of the sequence to be searched for. The range
-     *				used is [<i>first2</i>, <i>last2</i>).
-     * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the same
-     *			   order), and returns a value convertible to bool. The returned value indicates whether the elements are
-     *			   considered to match in the context of this function. The function shall not modify any of its
-     *			   arguments.
-     *
-     * @return An iterator to the first element of the first occurrence of [<i>first2</i>, <i>last2</i>) in
-     *		   [<i>first1</i>, <i>last1</i>). If the sequence is not found, the function returns last1. Otherwise
-     *		   [<i>first2</i>, <i>last2</i>) is an empty range, the function returns <i>first1</i>.
-     */
-    function search<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2, last2: ForwardIterator2, pred: (x: T, y: T) => boolean): ForwardIterator1;
-    /**
-     * <p> Search range for elements. </p>
-     *
-     * <p> Searches the range [<i>first</i>, <i>last</i>) for a sequence of <i>count</i> elements, each comparing equal to
-     * <i>val</i>. </p>
-     *
-     * <p> The function returns an iterator to the first of such elements, or <i>last</i> if no such sequence is found.
-     * </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the searched sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param count Minimum number of successive elements to match.
-     * @param val Individual value to be compared, or to be used as argument for {@link equal_to}.
-     *
-     * @return An iterator to the first element of the sequence. If no such sequence is found, the function returns
-     *		   <i>last</i>.
-     */
-    function search_n<T, ForwardIterator extends base.IArrayIterator<T>>(first: ForwardIterator, last: ForwardIterator, count: number, val: T): ForwardIterator;
-    /**
-     * <p> Search range for elements. </p>
-     *
-     * <p> Searches the range [<i>first</i>, <i>last</i>) for a sequence of <i>count</i> elements, each comparing equal to
-     * <i>val</i>. </p>
-     *
-     * <p> The function returns an iterator to the first of such elements, or <i>last</i> if no such sequence is found.
-     * </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the searched sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param count Minimum number of successive elements to match.
-     * @param val Individual value to be compared, or to be used as argument for <i>pred</i>.
-     * @param pred Binary function that accepts two arguments (one element from the sequence as first, and <i>val</i> as
-     *			   second), and returns a value convertible to <code>bool</code>. The value returned indicates whether the
-     *			   element is considered a match in the context of this function. The function shall not modify any of its
-     *			   arguments.
-     *
-     * @return An {@link Iterator} to the first element of the sequence. If no such sequence is found, the function
-     *		   returns <i>last</i>.
-     */
-    function search_n<T, ForwardIterator extends base.IArrayIterator<T>>(first: ForwardIterator, last: ForwardIterator, count: number, val: T, pred: (x: T, y: T) => boolean): ForwardIterator;
-    /**
-     * <p> Return first position where two ranges differ. </p>
-     *
-     * <p> Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
-     * <i>first2</i>, and returns the first element of both sequences that does not match. </p>
-     *
-     * <p> The function returns a {@link Pair} of {@link iterators Iterator} to the first element in each range that
-     * does not match. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
-     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
-     *
-     * @return A {@link Pair}, where its members {@link Pair.first first} and {@link Pair.second second} point to the
-     *		   first element in both sequences that did not compare equal to each other. If the elements compared in
-     *		   both sequences have all matched, the function returns a {@link Pair} with {@link Pair.first first} set
-     *		   to <i>last1</i> and {@link Pair.second second} set to the element in that same relative position in the
-     *		   second sequence. If none matched, it returns {@link make_pair}(<i>first1</i>, <i>first2</i>).
-     */
-    function mismatch<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2): Pair<Iterator1, Iterator2>;
-    /**
-     * <p> Return first position where two ranges differ. </p>
-     *
-     * <p> Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
-     * <i>first2</i>, and returns the first element of both sequences that does not match. </p>
-     *
-     * <p> The function returns a {@link Pair} of {@link iterators Iterator} to the first element in each range that
-     * does not match. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
-     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
-     * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same
-     *			   order), and returns a value convertible to <code>bool</code>. The value returned indicates whether
-     *			   the elements are considered to match in the context of this function.
-     *
-     * @return A {@link Pair}, where its members {@link Pair.first first} and {@link Pair.second second} point to the
-     *		   first element in both sequences that did not compare equal to each other. If the elements compared in
-     *		   both sequences have all matched, the function returns a {@link Pair} with {@link Pair.first first} set
-     *		   to <i>last1</i> and {@link Pair.second second} set to the element in that same relative position in the
-     *		   second sequence. If none matched, it returns {@link make_pair}(<i>first1</i>, <i>first2</i>).
-     */
-    function mismatch<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, compare: (x: T, y: T) => boolean): Pair<Iterator1, Iterator2>;
-    /**
-     * <p> Count appearances of value in range. </p>
-     *
-     * <p> Returns the number of elements in the range [<i>first</i>, <i>last</i>) that compare equal to <i>val</i>. </p>
-     *
-     * <p> The function uses {@link equal_to} to compare the individual elements to <i>val</i>. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value to match.
-     *
-     * @return The number of elements in the range [<i>first</i>, <i>last</i>) that compare equal to <i>val</i>.
-     */
-    function count<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): number;
-    /**
-     * <p> Return number of elements in range satisfying condition. </p>
-     *
-     * <p> Returns the number of elements in the range [<i>first</i>, <i>last</i>) for which pred is <code>true</code>.
-     * </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible
-     *			   to <code>bool</code>. The value returned indicates whether the element is counted by this function.
-     *			   The function shall not modify its argument. This can either be a function pointer or a function
-     *			   object.
-     */
-    function count_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): number;
-}
-declare namespace std {
-    /**
-     * <p> Copy range of elements. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) into the range beginning at <i>result</i>. </p>
-     *
-     * <p> The function returns an iterator to the end of the destination range (which points to the element following the
-     * last element copied). </p>
-     *
-     * <p> The ranges shall not overlap in such a way that result points to an element in the range
-     * [<i>first</i>, <i>last</i>). For such cases, see {@link copy_backward}. </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position in a sequence to be copied.
-     * @param last {@link Iterator Input iterator} to the initial position in a sequence to be copied. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output iterator} to the initial position in the destination sequence. This shall not
-     *				 point to any element in the range [<i>first</i>, <i>last</i>).
-     *
-     * @return An iterator to the end of the destination range where elements have been copied.
-     */
-    function copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Copy elements. </p>
-     *
-     * <p> Copies the first <i>n</i> elements from the range beginning at <i>first</i> into the range beginning at
-     * <i>result</i>. </p>
-     *
-     * <p> The function returns an iterator to the end of the destination range (which points to one past the last element
-     * copied). </p>
-     *
-     * <p> If <i>n</i> is negative, the function does nothing. </p>
-     *
-     * <p> If the ranges overlap, some of the elements in the range pointed by result may have undefined but valid values.
-     * </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position in a sequence of at least <i>n</i> elements to
-     *				be copied. <i>InputIterator</i> shall point to a type assignable to the elements pointed by
-     *				<i>OutputIterator</i>.
-     * @param n Number of elements to copy. If this value is negative, the function does nothing.
-     * @param result {@link Iterator Output iterator} to the initial position in the destination sequence of at least
-     *				 <i>n</i> elements. This shall not point to any element in the range [<i>first</i>, last].
-     *
-     * @return An iterator to the end of the destination range where elements have been copied.
-     */
-    function copy_n<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, n: number, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Copy certain elements of range. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) for which pred returns <code>true</code> to the
-     * range beginning at <i>result</i>. </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position in a sequence to be copied.
-     * @param last {@link Iterator Input iterator} to the initial position in a sequence to be copied. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output iterator} to the initial position in the destination sequence. This shall not
-     *				 point to any element in the range [<i>first</i>, <i>last</i>).
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element is to be copied (if
-     *			   <code>true</code>, it is copied). The function shall not modify any of its arguments.
-     *
-     * @return An iterator to the end of the destination range where elements have been copied.
-     */
-    function copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T) => boolean): OutputIterator;
-    /**
-     * <p> Copy range of elements backward. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) starting from the end into the range terminating
-     * at <i>result</i>. </p>
-     *
-     * <p> The function returns an iterator to the first element in the destination range. </p>
-     *
-     * <p> The resulting range has the elements in the exact same order as [<i>first</i>, <i>last</i>). To reverse their
-     * order, see {@link reverse_copy}. </p>
-     *
-     * <p> The function begins by copying <code>*(last-1)</code> into <code>*(result-1)</code>, and then follows backward
-     * by the elements preceding these, until <i>first</i> is reached (and including it). </p>
-     *
-     * <p> The ranges shall not overlap in such a way that <i>result</i> (which is the <i>past-the-end element</i> in the
-     * destination range) points to an element in the range (first,last]. For such cases, see {@link copy}. </p>
-     *
-     * @param first {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied.
-     * @param last {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied. The range
-     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Bidirectional iterator} to the initial position in the destination sequence. This
-     *				 shall not point to any element in the range [<i>first</i>, <i>last</i>).
-     *
-     * @return An iterator to the first element of the destination sequence where elements have been copied.
-     */
-    function copy_backward<T, BidirectionalIterator1 extends Iterator<T>, BidirectionalIterator2 extends base.ILinearIterator<T>>(first: BidirectionalIterator1, last: BidirectionalIterator1, result: BidirectionalIterator2): BidirectionalIterator2;
-    /**
-     * <p> Fill range with value. </p>
-     *
-     * <p> Assigns val to all the elements in the range [<i>first</i>, <i>last</i>). </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position in a sequence of elements that support being
-     *				assigned a value of type <i>T</i>.
-     * @param last {@link Iterator Forward iterator} to the final position in a sequence of elements that support being
-     *				assigned a value of type <i>T</i>.. The range filled is [<i>first</i>, <i>last</i>), which contains
-     *				all the elements between <i>first</i> and <i>last</i>, including the element pointed by <i>first</i>
-     *				but not the element pointed by <i>last</i>.
-     * @param val Value to assign to the elements in the filled range.
-     */
-    function fill<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): void;
-    /**
-     * <p> Fill sequence with value. </p>
-     *
-     * <p> Assigns <i>val</i> to the first <i>n</i> elements of the sequence pointed by <i>first</i>. </p>
-     *
-     * @param first {@link Iterator Output iterator} to the initial position in a sequence of elements that support being
-     *				assigned a value of type <i>T</i>.
-     * @param n Number of elements to fill. If negative, the function does nothing.
-     * @param val Value to be used to fill the range.
-     *
-     * @return An iterator pointing to the element that follows the last element filled.
-     */
-    function fill_n<T, OutputIterator extends base.ILinearIterator<T>>(first: OutputIterator, n: number, val: T): OutputIterator;
-    /**
-     * <p> Transform range. </p>
-     *
-     * <p> Applies <i>op</i> to each of the elements in the range [<i>first</i>, <i>last</i>) and stores the value returned
-     * by each operation in the range that begins at <i>result</i>. </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position in a sequence to be transformed.
-     * @param last {@link Iterator Input iterator} to the initial position in a sequence to be transformed. The range
-     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output} iterator to the initial position of the range where the operation results are
-     *				 stored. The range includes as many elements as [<i>first</i>, <i>last</i>).
-     * @param op Unary function that accepts one element of the type pointed to by <i>InputIterator</i> as argument, and
-     *			 returns some result value convertible to the type pointed to by <i>OutputIterator</i>.
-     *
-     * @return An iterator pointing to the element that follows the last element written in the <i>result</i> sequence.
-     */
-    function transform<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, op: (val: T) => T): OutputIterator;
-    /**
-     * <p> Transform range. </p>
-     *
-     * <p> Calls <i>binary_op</i> using each of the elements in the range [<i>first1</i>, <i>last1</i>) as first argument,
-     * and the respective argument in the range that begins at <i>first2</i> as second argument. The value returned by
-     * each call is stored in the range that begins at <i>result</i>. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second range. The range includes as
-     *				 many elements as [<i>first1</i>, <i>last1</i>).
-     * @param result {@link Iterator Output} iterator to the initial position of the range where the operation results are
-     *				 stored. The range includes as many elements as [<i>first1</i>, <i>last1</i>).
-     * @param binary_op Binary function that accepts two elements as argument (one of each of the two sequences), and
-     *					returns some result value convertible to the type pointed to by <i>OutputIterator</i>.
-     *
-     * @return An iterator pointing to the element that follows the last element written in the <i>result</i> sequence.
-     */
-    function transform<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, result: OutputIterator, binary_op: (x: T, y: T) => T): OutputIterator;
-    /**
-     * <p> Generate values for range with function. </p>
-     *
-     * <p> Assigns the value returned by successive calls to gen to the elements in the range [<i>first</i>, <i>last</i>).
-     * </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position in a sequence.
-     * @param last {@link Iterator Forward iterator} to the final position in a sequence. The range affected is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param gen Generator function that is called with no arguments and returns some value of a type convertible to
-     *			  those pointed by the iterators.
-     */
-    function generate<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, last: ForwardIterator, gen: () => T): void;
-    /**
-     * <p> Generate values for sequence with function. </p>
-     *
-     * <p> Assigns the value returned by successive calls to <i>gen</i> to the first <i>n</i> elements of the sequence
-     * pointed by <i>first</i>. </p>
-     *
-     * @param first {@link Iterator Output iterator} to the initial position in a sequence of at least <i>n</i> elements
-     *				that support being assigned a value of the type returned by <i>gen</i>.
-     * @param n Number of values to generate. If negative, the function does nothing.
-     * @param gen Generator function that is called with no arguments and returns some value of a type convertible to
-     *			  those pointed by the iterators.
-     *
-     * @return An iterator pointing to the element that follows the last element whose value has been generated.
-     */
-    function generate_n<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, n: number, gen: () => T): ForwardIterator;
-    /**
-     * <p> Remove consecutive duplicates in range. </p>
-     *
-     * <p> Removes all but the first element from every consecutive group of equivalent elements in the range
-     * [<i>first</i>, <i>last</i>). </p>
-     *
-     * <p> The function cannot alter the properties of the object containing the range of elements (i.e., it cannot
-     * alter the size of an array or a container): The removal is done by replacing the duplicate elements by the next
-     * element that is not a duplicate, and signaling the new size of the shortened range by returning an iterator to
-     * the element that should be considered its new past-the-last element. </p>
-     *
-     * <p> The relative order of the elements not removed is preserved, while the elements between the returned
-     * iterator and last are left in a valid but unspecified state. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     *
-     * @return An iterator to the element that follows the last element not removed. The range between <i>first</i> and
-     *		   this iterator includes all the elements in the sequence that were not considered duplicates.
-     */
-    function unique<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): InputIterator;
-    /**
-     * <p> Remove consecutive duplicates in range. </p>
-     *
-     * <p> Removes all but the first element from every consecutive group of equivalent elements in the range
-     * [<i>first</i>, <i>last</i>). </p>
-     *
-     * <p> The function cannot alter the properties of the object containing the range of elements (i.e., it cannot
-     * alter the size of an array or a container): The removal is done by replacing the duplicate elements by the next
-     * element that is not a duplicate, and signaling the new size of the shortened range by returning an iterator to
-     * the element that should be considered its new past-the-last element. </p>
-     *
-     * <p> The relative order of the elements not removed is preserved, while the elements between the returned
-     * iterator and last are left in a valid but unspecified state. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Binary function that accepts two elements in the range as argument, and returns a value convertible
-     *			   to <code>bool</code>. The value returned indicates whether both arguments are considered equivalent
-     *			  (if <code>true</code>, they are equivalent and one of them is removed). The function shall not modify
-     *			  any of its arguments.
-     *
-     * @return An iterator to the element that follows the last element not removed. The range between <i>first</i> and
-     *		   this iterator includes all the elements in the sequence that were not considered duplicates.
-     */
-    function unique<t, InputIterator extends Iterator<t>>(first: InputIterator, last: InputIterator, pred: (left: t, right: t) => boolean): InputIterator;
-    /**
-     * <p> Copy range removing duplicates. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
-     * consecutive duplicates (elements that compare equal to the element preceding). </p>
-     *
-     * <p> Only the first element from every consecutive group of equivalent elements in the range
-     * [<i>first</i>, <i>last</i>) is copied. </p>
-     *
-     * <p> The comparison between elements is performed by applying {@lnk equal_to}. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position in a sequence.
-     * @param last {@link Iterator Forward iterator} to the final position in a sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result Output iterator to the initial position of the range where the resulting range of values is stored.
-     *				 The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     *
-     * @return An iterator pointing to the end of the copied range, which contains no consecutive duplicates.
-     */
-    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Copy range removing duplicates. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
-     * consecutive duplicates (elements that compare equal to the element preceding). </p>
-     *
-     * <p> Only the first element from every consecutive group of equivalent elements in the range
-     * [<i>first</i>, <i>last</i>) is copied. </p>
-     *
-     * <p> The comparison between elements is performed by applying <i>pred</i>. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position in a sequence.
-     * @param last {@link Iterator Forward iterator} to the final position in a sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result Output iterator to the initial position of the range where the resulting range of values is stored.
-     *				 The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     * @param pred Binary function that accepts two elements in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether both arguments are considered equivalent (if
-     *			   <code>true</code>, they are equivalent and one of them is removed). The function shall not modify any
-     *			   of its arguments.
-     *
-     * @return An iterator pointing to the end of the copied range, which contains no consecutive duplicates.
-     */
-    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T, y: T) => boolean): OutputIterator;
-    /**
-     * <p> Remove value from range. </p>
-     *
-     * <p> Transforms the range [<i>first</i>, <i>last</i>) into a range with all the elements that compare equal to
-     * <i>val</i> removed, and returns an iterator to the new last of that range. </p>
-     *
-     * <p> The function cannot alter the properties of the object containing the range of elements (i.e., it cannot alter
-     * the size of an array or a container): The removal is done by replacing the elements that compare equal to
-     * <i>val</i> by the next element that does not, and signaling the new size of the shortened range by returning an
-     * iterator to the element that should be considered its new past-the-last element. </p>
-     *
-     * <p> The relative order of the elements not removed is preserved, while the elements between the returned iterator
-     * and last are left in a valid but unspecified state. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value to be removed.
-     */
-    function remove<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): InputIterator;
-    /**
-     * <p> Remove elements from range. </p>
-     *
-     * <p> Transforms the range [<i>first</i>, <i>last</i>) into a range with all the elements for which pred returns
-     * <code>true</code> removed, and returns an iterator to the new last of that range. </p>
-     *
-     * <p> The function cannot alter the properties of the object containing the range of elements (i.e., it cannot
-     * alter the size of an array or a container): The removal is done by replacing the elements for which pred returns
-     * <code>true</code> by the next element for which it does not, and signaling the new size of the shortened range
-     * by returning an iterator to the element that should be considered its new past-the-last element. </p>
-     *
-     * <p> The relative order of the elements not removed is preserved, while the elements between the returned
-     * iterator and last are left in a valid but unspecified state. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element is to be removed (if
-     *			   <code>true</code>, it is removed). The function shall not modify its argument.
-     */
-    function remove_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (left: T) => boolean): InputIterator;
-    /**
-     * <p> Copy range removing value. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
-     * those elements that compare equal to <i>val</i>. </p>
-     *
-     * <p> The resulting range is shorter than [<i>first</i>, <i>last</i>) by as many elements as matches in the sequence,
-     * which are "removed". </p>
-     *
-     * <p> The function uses {@link equal_to} to compare the individual elements to <i>val</i>. </p>
-     *
-     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
-     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     * @param val Value to be removed.
-     *
-     * @return An iterator pointing to the end of the copied range, which includes all the elements in
-     *		   [<i>first</i>, <i>last</i>) except those that compare equal to <i>val</i>.
-     */
-    function remove_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, val: T): OutputIterator;
-    /**
-     * <p> Copy range removing values. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, except
-     * those elements for which <i>pred</i> returns <code>true</code>. </p>
-     *
-     * <p> The resulting range is shorter than [<i>first</i>, <i>last</i>) by as many elements as matches, which are
-     * "removed". </p>
-     *
-     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
-     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element is to be removed from the copy (if
-     *			   <code>true</code>, it is not copied). The function shall not modify its argument.
-     *
-     * @return An iterator pointing to the end of the copied range, which includes all the elements in
-     *		   [<i>first</i>, <i>last</i>) except those for which <i>pred</i> returns <code>true</code>.
-     */
-    function remove_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean): OutputIterator;
-    /**
-     * <p> Replace value in range. </p>
-     *
-     * <p> Assigns <i>new_val</i> to all the elements in the range [<i>first</i>, <i>last</i>) that compare equal to
-     * <i>old_val</i>. </p>
-     *
-     * <p> The function uses {@link equal_to} to compare the individual elements to old_val. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param old_val Value to be replaced.
-     * @param new_val Replacement value.
-     */
-    function replace<T, InputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, old_val: T, new_val: T): void;
-    /**
-     * <p> Replace value in range. </p>
-     *
-     * <p> Assigns <i>new_val</i> to all the elements in the range [<i>first</i>, <i>last</i>) for which pred returns
-     * <code>true</code>. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element is to be replaced (if
-     *			   <code>true</code>, it is replaced). The function shall not modify its argument.
-     * @param new_val Value to assign to replaced elements.
-     */
-    function replace_if<T, InputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean, new_val: T): void;
-    /**
-     * <p> Copy range replacing value. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, replacing
-     * the appearances of <i>old_value</i> by <i>new_value</i>. </p>
-     *
-     * <p> The function uses {@link std.equal_to} to compare the individual elements to <i>old_value</i>. </p>
-     *
-     * <p> The ranges shall not overlap in such a way that result points to an element in the range
-     * [<i>first</i>, <i>last</i>). </p>
-     *
-     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
-     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     * @param old_val Value to be replaced.
-     * @param new_val Replacement value.
-     *
-     * @return An iterator pointing to the element that follows the last element written in the result sequence.
-     */
-    function replace_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, old_val: T, new_val: T): OutputIterator;
-    /**
-     * <p> Copy range replacing value. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, replacing
-     * those for which <i>pred</i> returns <code>true</code> by <i>new_value</i>. </p>
-     *
-     * @param first {@link Iterator InputIterator} to the initial position in a sequence.
-     * @param last {@link Iterator InputIterator} to the final position in a sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element is to be removed from the copy (if
-     *			   <code>true</code>, it is not copied). The function shall not modify its argument.
-     * @param new_val Value to assign to replaced values.
-     *
-     * @return An iterator pointing to the element that follows the last element written in the result sequence.
-     */
-    function replace_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean, new_val: T): OutputIterator;
-    /**
-     * <p> Exchange values of objects pointed to by two iterators. </p>
-     *
-     * <p> Swaps the elements pointed to by <i>x</i> and <i>y</i>. </p>
-     *
-     * <p> The function calls {@link Iterator.swap} to exchange the elements. </p>
-     *
-     * @param x {@link Iterator Forward iterator} to the objects to swap.
-     * @param y {@link Iterator Forward iterator} to the objects to swap.
-     */
-    function iter_swap<T>(x: Iterator<T>, y: Iterator<T>): void;
-    /**
-     * <p> Exchange values of two ranges. </p>
-     *
-     * <p> Exchanges the values of each of the elements in the range [<i>first1</i>, <i>last1</i>) with those of their
-     * respective elements in the range beginning at <i>first2</i>. </p>
-     *
-     * <p> The function calls {@link Iterator.swap} to exchange the elements. </p>
-     *
-     * @param first1 {@link Iterator Forward iterator} to the initial position of the first sequence.
-     * @param last1 {@link Iterator Forward iterator} to the final position of the first sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Forward iterator} to the initial position of the second range. The range includes as
-     *				 many elements as [<i>first1</i>, <i>last1</i>). The two ranges shall not overlap.
-     *
-     * @return An iterator to the last element swapped in the second sequence.
-     */
-    function swap_ranges<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2): ForwardIterator2;
-    /**
-     * <p> Reverse range. </p>
-     *
-     * <p> Reverses the order of the elements in the range [<i>first</i>, <i>last</i>). </p>
-     *
-     * <p> The function calls {@link iter_swap} to swap the elements to their new locations. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     */
-    function reverse<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): void;
-    /**
-     * <p> Copy range reversed. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, but in
-     * reverse order. </p>
-     *
-     * @param first {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied.
-     * @param last {@link Iterator Bidirectional iterator} to the initial position in a sequence to be copied. The range
-     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the reserved range is
-     *				 stored. The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     *
-     * @return An output iterator pointing to the end of the copied range, which contains the same elements in reverse
-     *		   order.
-     */
-    function reverse_copy<T, BidirectionalIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Rotate left the elements in range. </p>
-     *
-     * <p> Rotates the order of the elements in the range [<i>first</i>, <i>last</i>), in such a way that the element
-     * pointed by middle becomes the new first element. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param middle An {@link Iterator} pointing to the element within the range [<i>first</i>, <i>last</i>) that is
-     *				 moved to the first position in the range.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     *
-     * @return An iterator pointing to the element that now contains the value previously pointed by <i>first</i>.
-     */
-    function rotate<T, InputIterator extends Iterator<T>>(first: InputIterator, middle: InputIterator, last: InputIterator): InputIterator;
-    /**
-     * <p> Copy range rotated left. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) to the range beginning at <i>result</i>, but
-     * rotating the order of the elements in such a way that the element pointed by <i>middle</i> becomes the first
-     * element in the resulting range. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the range to be copy-rotated.
-     * @param middle Forward iterator pointing to the element within the range [<i>first</i>, <i>last</i>) that is copied as the first element in the resulting range.
-     * @param last {@link Iterator Forward iterator} to the final positions of the range to be copy-rotated. The range
-     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   Notice that in this function, these are not consecutive parameters, but the first and <b>third</b> ones.
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the reserved range is
-     *				 stored. The pointed type shall support being assigned the value of an element in the range
-     *				 [<i>first</i>, <i>last</i>).
-     *
-     * @return An output iterator pointing to the end of the copied range.
-     */
-    function rotate_copy<T, ForwardIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: ForwardIterator, middle: ForwardIterator, last: ForwardIterator, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Randomly rearrange elements in range. </p>
-     *
-     * <p> Rearranges the elements in the range [<i>first</i>, <i>last</i>) randomly. </p>
-     *
-     * <p> The function swaps the value of each element with that of some other randomly picked element. When provided,
-     * the function gen determines which element is picked in every case. Otherwise, the function uses some unspecified
-     * source of randomness. </p>
-     *
-     * <p> To specify a uniform random generator, see {@link shuffle}. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     */
-    function random_shuffle<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
-    /**
-     * <p> Randomly rearrange elements in range using generator. </p>
-     *
-     * <p> Rearranges the elements in the range [<i>first</i>, <i>last</i>) randomly, using <i>g</i> as uniform random
-     * number generator. </p>
-     *
-     * <p> The function swaps the value of each element with that of some other randomly picked element. The function
-     * determines the element picked by calling <i>g()</i>. </p>
-     *
-     * <p> To shuffle the elements of the range without such a generator, see {@link random_shuffle} instead. </p>
-     *
-     * <h5> Note </h5>
-     * <p> Using random generator engine is not implemented yet. </p>
-     *
-     * @param first An {@link Iterator} to the initial position in a sequence.
-     * @param last An {@link Iterator} to the final position in a sequence. The range used is [<i>first</i>, <i>last</i>),
-     *			  which contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			  <i>first</i> but not the element pointed by <i>last</i>.
-     */
-    function shuffle<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
-}
-declare namespace std {
-    /**
-     * <p> Sort elements in range. </p>
-     *
-     * <p> Sorts the elements in the range [<i>first</i>, <i>last</i>) into ascending order. The elements are compared
-     * using {@link less}. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
-     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
-     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
-     *			  <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
-     *			  {@link Iterator.swap swap} is properly defined.
-     */
-    function sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
-    /**
-     * <p> Sort elements in range. </p>
-     *
-     * <p> Sorts the elements in the range [<i>first</i>, <i>last</i>) into specific order. The elements are compared
-     * using <i>compare</i>. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
-     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
-     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
-     *			  <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
-     *			  {@link Iterator.swap swap} is properly defined.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *		  convertible to <code>boolean</code>. The value returned indicates whether the element passed as first
-     *		  argument is considered to go before the second in the specific strict weak ordering it defines. The
-     *		  function shall not modify any of its arguments. This can either be a function pointer or a function
-     *		  object.
-     */
-    function sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (left: T, right: T) => boolean): void;
-    /**
-     * <p> Partially sort elements in range. </p>
-     *
-     * <p> Rearranges the elements in the range [<i>first</i>, <i>last</i>), in such a way that the elements before
-     * <i>middle</i> are the smallest elements in the entire range and are sorted in ascending order, while the remaining
-     * elements are left without any specific order. </p>
-     *
-     * <p> The elements are compared using {@link less}. </p>
-     *
-     * @param last {@link IArrayIterator Random-access iterator} to the first position of the sequence to be sorted.
-     * @param middle {@link IArrayIterator Random-access iterator} pointing to the element within the range [<i>first</i>, <i>last</i>) that is used as the upper boundary of the elements that are fully sorted.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
-     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
-     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
-     *			  <i>last</i>.
-     */
-    function partial_sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, middle: RandomAccessIterator, last: RandomAccessIterator): void;
-    /**
-     * <p> Partially sort elements in range. </p>
-     *
-     * <p> Rearranges the elements in the range [<i>first</i>, <i>last</i>), in such a way that the elements before
-     * <i>middle</i> are the smallest elements in the entire range and are sorted in ascending order, while the remaining
-     * elements are left without any specific order. </p>
-     *
-     * <p> The elements are compared using <i>comp</i>. </p>
-     *
-     * @param last {@link IArrayIterator Random-access iterator} to the first position of the sequence to be sorted.
-     * @param middle {@link IArrayIterator Random-access iterator} pointing to the element within the range [<i>first</i>, <i>last</i>) that is used as the upper boundary of the elements that are fully sorted.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
-     *			  The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i>
-     *			  and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
-     *			  <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
-     *				  first argument is considered to go before the second in the specific strict weak ordering it
-     *				  defines. The function shall not modify any of its arguments.
-     */
-    function partial_sort<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, middle: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
-    /**
-     * <p> Copy and partially sort range. </p>
-     *
-     * <p> Copies the smallest  elements in the range [<i>first</i>, <i>last</i>) to
-     * [<i>result_first</i>, <i>result_last</i>), sorting the elements copied. The number of elements copied is the same
-     * as the {@link distance} between <i>result_first</i> and <i>result_last</i> (unless this is more than the amount of
-     * elements in [<i>first</i>, <i>last</i>)). </p>
-     *
-     * <p> The range [<i>first</i>, <i>last</i>) is not modified. </p>
-     *
-     * <p> The elements are compared using {@link less}. </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position of the sequence to copy from.
-     * @param last {@link Iterator Input iterator} to the final position of the sequence to copy from. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   <i>InputIterator</i> shall point to a type assignable to the elements pointed by
-     *			   <i>RandomAccessIterator</i>.
-     * @param result_first {@link Iterator Random-access iterator} to the initial position of the destination sequence.
-     * @param result_last {@link Iterator Random-access iterator} to the final position of the destination sequence.
-     *					  The range used is [<i>result_first</i>, <i>result_last</i>).
-     * @param compare Binary function that accepts two elements in the result range as arguments, and returns a value
-     *				  convertible to <code>bool</code>. The value returned indicates whether the element passed as first
-     *				  argument is considered to go before the second in the specific <i>strict weak ordering</i> it
-     *				  defines. The function shall not modify any of its arguments.
-     *
-     * @return An iterator pointing to the element that follows the last element written in the result sequence.
-     */
-    function partial_sort_copy<T, InputIterator extends Iterator<T>, RandomAccessIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result_first: RandomAccessIterator, result_last: RandomAccessIterator): RandomAccessIterator;
-    /**
-     * <p> Copy and partially sort range. </p>
-     *
-     * <p> Copies the smallest (or largest) elements in the range [<i>first</i>, <i>last</i>) to
-     * [<i>result_first</i>, <i>result_last</i>), sorting the elements copied. The number of elements copied is the same
-     * as the {@link distance} between <i>result_first</i> and <i>result_last</i> (unless this is more than the amount of
-     * elements in [<i>first</i>, <i>last</i>)). </p>
-     *
-     * <p> The range [<i>first</i>, <i>last</i>) is not modified. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position of the sequence to copy from.
-     * @param last {@link Iterator Input iterator} to the final position of the sequence to copy from. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   <i>InputIterator</i> shall point to a type assignable to the elements pointed by
-     *			   <i>RandomAccessIterator</i>.
-     * @param result_first {@link Iterator Random-access iterator} to the initial position of the destination sequence.
-     * @param result_last {@link Iterator Random-access iterator} to the final position of the destination sequence.
-     *					  The range used is [<i>result_first</i>, <i>result_last</i>).
-     * @param compare Binary function that accepts two elements in the result range as arguments, and returns a value
-     *				  convertible to <code>bool</code>. The value returned indicates whether the element passed as first
-     *				  argument is considered to go before the second in the specific <i>strict weak ordering</i> it
-     *				  defines. The function shall not modify any of its arguments.
-     *
-     * @return An iterator pointing to the element that follows the last element written in the result sequence.
-     */
-    function partial_sort_copy<T, InputIterator extends Iterator<T>, RandomAccessIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result_first: RandomAccessIterator, result_last: RandomAccessIterator, compare: (x: T, y: T) => boolean): RandomAccessIterator;
-    /**
-     * <p> Check whether range is sorted. </p>
-     *
-     * <p> Returns <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order. </p>
-     *
-     * <p> The elements are compared using {@link less}. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *
-     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order,
-     *		   <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less than two elements,
-     *		   the function always returns <code>true</code>.
-     */
-    function is_sorted<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): boolean;
-    /**
-     * <p> Check whether range is sorted. </p>
-     *
-     * <p> Returns <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
-     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
-     *				  considered to go before the second in the specific strict weak ordering it defines. The function
-     *				  shall not modify any of its arguments.
-     *
-     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is sorted into ascending order,
-     *		   <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less than two elements,
-     *		   the function always returns <code>true</code>.
-     */
-    function is_sorted<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): boolean;
-    /**
-     * <p> Find first unsorted element in range. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which does not follow an
-     * ascending order. </p>
-     *
-     * <p> The range between <i>first</i> and the iterator returned {@link is_sorted is sorted}. </p>
-     *
-     * <p> If the entire range is sorted, the function returns <i>last</i>. </p>
-     *
-     * <p> The elements are compared using {@link equal_to}. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
-     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
-     *				  considered to go before the second in the specific strict weak ordering it defines. The function
-     *				  shall not modify any of its arguments.
-     *
-     * @return An iterator to the first element in the range which does not follow an ascending order, or <i>last</i> if
-     *		   all elements are sorted or if the range contains less than two elements.
-     */
-    function is_sorted_until<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): ForwardIterator;
-    /**
-     * <p> Find first unsorted element in range. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which does not follow an
-     * ascending order. </p>
-     *
-     * <p> The range between <i>first</i> and the iterator returned {@link is_sorted is sorted}. </p>
-     *
-     * <p> If the entire range is sorted, the function returns <i>last</i>. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of the sequence. The range checked is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
-     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
-     *				  considered to go before the second in the specific strict weak ordering it defines. The function
-     *				  shall not modify any of its arguments.
-     *
-     * @return An iterator to the first element in the range which does not follow an ascending order, or <i>last</i> if
-     *		   all elements are sorted or if the range contains less than two elements.
-     */
-    function is_sorted_until<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): ForwardIterator;
-}
-declare namespace std {
-    /**
-     * <p> Make heap from range. </p>
-     *
-     * <p> Rearranges the elements in the range [<i>first</i>, <i>last</i>) in such a way that they form a heap. </p>
-     *
-     * <p> A heap is a way to organize the elements of a range that allows for fast retrieval of the element with the
-     * highest value at any moment (with {@link pop_heap}), even repeatedly, while allowing for fast insertion of new
-     * elements (with {@link push_heap}). </p>
-     *
-     * <p> The element with the highest value is always pointed by first. The order of the other elements depends on the
-     * particular implementation, but it is consistent throughout all heap-related functions of this header. </p>
-     *
-     * <p> The elements are compared using {@link less}: The element with the highest value is an element for which this
-     * would return false when compared to every other element in the range. </p>
-     *
-     * <p> The standard container adaptor {@link PriorityQueue} calls {@link make_heap}, {@link push_heap} and
-     * {@link pop_heap} automatically to maintain heap properties for a container. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be
-     *				transformed into a heap.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be transformed
-     *			   into a heap. The range used is [<i>first</i>, <i>last</i>), which contains all the elements between
-     *			   <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed
-     *			   by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
-     *			   {@link Iterator.swap swap} is properly defined.
-     */
-    function make_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
-    /**
-     * <p> Make heap from range. </p>
-     *
-     * <p> Rearranges the elements in the range [<i>first</i>, <i>last</i>) in such a way that they form a heap. </p>
-     *
-     * <p> A heap is a way to organize the elements of a range that allows for fast retrieval of the element with the
-     * highest value at any moment (with {@link pop_heap}), even repeatedly, while allowing for fast insertion of new
-     * elements (with {@link push_heap}). </p>
-     *
-     * <p> The element with the highest value is always pointed by first. The order of the other elements depends on the
-     * particular implementation, but it is consistent throughout all heap-related functions of this header. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>: The element with the highest value is an element for which this
-     * would return false when compared to every other element in the range. </p>
-     *
-     * <p> The standard container adaptor {@link PriorityQueue} calls {@link make_heap}, {@link push_heap} and
-     * {@link pop_heap} automatically to maintain heap properties for a container. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be
-     *				transformed into a heap.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be transformed
-     *			   into a heap. The range used is [<i>first</i>, <i>last</i>), which contains all the elements between
-     *			   <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element pointed
-     *			   by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
-     *			   {@link Iterator.swap swap} is properly defined.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
-     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
-     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
-     *				  function object.
-     */
-    function make_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
-    /**
-     * <p> Push element into heap range. </p>
-     *
-     * <p> Given a heap in the range [<i>first</i>, <i>last</i> - 1), this function extends the range considered a heap to
-     * [<i>first</i>, <i>last</i>) by placing the value in (<i>last</i> - 1) into its corresponding location within it.
-     * </p>
-     *
-     * <p> A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
-     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
-     * </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the new heap range, including
-     *				the pushed element.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the new heap range, including
-     *			   the pushed element.  The range used is [<i>first</i>, <i>last</i>), which contains all the elements
-     *			   between <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element
-     *			   pointed by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
-     *			   {@link Iterator.swap swap} is properly defined.
-     */
-    function push_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
-    /**
-     * <p> Push element into heap range. </p>
-     *
-     * <p> Given a heap in the range [<i>first</i>, <i>last</i> - 1), this function extends the range considered a heap to
-     * [<i>first</i>, <i>last</i>) by placing the value in (<i>last</i> - 1) into its corresponding location within it.
-     * </p>
-     *
-     * <p> A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
-     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
-     * </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the new heap range, including
-     *				the pushed element.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the new heap range, including
-     *			   the pushed element.  The range used is [<i>first</i>, <i>last</i>), which contains all the elements
-     *			   between <i>first</i> and <i>last</i>, including the element pointed by <i>first</i> but not the element
-     *			   pointed by <i>last</i>. {@link IArrayIterator RandomAccessIterator} shall point to a type for which
-     *			   {@link Iterator.swap swap} is properly defined.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
-     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
-     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
-     *				  function object.
-     */
-    function push_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
-    /**
-     * <p> Pop element from heap range. </p>
-     *
-     * <p> Rearranges the elements in the heap range [<i>first</i>, <i>last</i>) in such a way that the part considered a
-     * heap is shortened by one: The element with the highest value is moved to (<i>last</i> - 1). </p>
-     *
-     * <p> While the element with the highest value is moved from first to (<i>last</i> - 1) (which now is out of the
-     * heap), the other elements are reorganized in such a way that the range [<i>first</i>, <i>last</i> - 1) preserves
-     * the properties of a heap. </p>
-     *
-     * <p> A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
-     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
-     * </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the heap to be shrank by one.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the heap to be shrank by one.
-     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     */
-    function pop_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
-    /**
-     * <p> Pop element from heap range. </p>
-     *
-     * <p> Rearranges the elements in the heap range [<i>first</i>, <i>last</i>) in such a way that the part considered a
-     * heap is shortened by one: The element with the highest value is moved to (<i>last</i> - 1). </p>
-     *
-     * <p> While the element with the highest value is moved from first to (<i>last</i> - 1) (which now is out of the
-     * heap), the other elements are reorganized in such a way that the range [<i>first</i>, <i>last</i> - 1) preserves
-     * the properties of a heap. </p>
-     *
-     * <p> A range can be organized into a heap by calling {@link make_heap}. After that, its heap properties are
-     * preserved if elements are added and removed from it using {@link push_heap} and {@link pop_heap}, respectively.
-     * </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the heap to be shrank by one.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the heap to be shrank by one.
-     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
-     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
-     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
-     *				  function object.
-     */
-    function pop_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
-    /**
-     * <p> Test if range is heap. </p>
-     *
-     * <p> Returns true if the range [<i>first</i>, <i>last</i>) forms a heap, as if constructed with {@link make_heap}.
-     * </p>
-     *
-     * <p> The elements are compared using {@link less}. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     *
-     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is a heap (as if constructed with
-     *		   {@link make_heap}), <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less
-     *		   than two elements, the function always returns <code>true</code>.
-     */
-    function is_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): boolean;
-    /**
-     * <p> Test if range is heap. </p>
-     *
-     * <p> Returns true if the range [<i>first</i>, <i>last</i>) forms a heap, as if constructed with {@link make_heap}.
-     * </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
-     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
-     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
-     *				  function object.
-     *
-     * @return <code>true</code> if the range [<i>first</i>, <i>last</i>) is a heap (as if constructed with
-     *		   {@link make_heap}), <code>false</code> otherwise. If the range [<i>first</i>, <i>last</i>) contains less
-     *		   than two elements, the function always returns <code>true</code>.
-     */
-    function is_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): boolean;
-    /**
-     * <p> Find first element not in heap order. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which is not in a valid
-     * position if the range is considered a heap (as if constructed with {@link make_heap}). </p>
-     *
-     * <p> The range between first and the iterator returned is a heap. </p>
-     *
-     * <p> If the entire range is a valid heap, the function returns <i>last</i>. </p>
-     *
-     * <p> The elements are compared using {@link less}. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     */
-    function is_heap_until<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): RandomAccessIterator;
-    /**
-     * <p> Find first element not in heap order. </p>
-     *
-     * <p> Returns an iterator to the first element in the range [<i>first</i>, <i>last</i>) which is not in a valid
-     * position if the range is considered a heap (as if constructed with {@link make_heap}). </p>
-     *
-     * <p> The range between first and the iterator returned is a heap. </p>
-     *
-     * <p> If the entire range is a valid heap, the function returns <i>last</i>. </p>
-     *
-     * <p> The elements are compared using {@link less}. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
-     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
-     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
-     *				  function object.
-     */
-    function is_heap_until<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): RandomAccessIterator;
-    /**
-     * <p> Sort elements of heap. </p>
-     *
-     * <p> Sorts the elements in the heap range [<i>first</i>, <i>last</i>) into ascending order. </p>
-     *
-     * <p> The elements are compared using {@link less}, which shall be the same as used to construct the heap. </p>
-     *
-     * <p> The range loses its properties as a heap. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
-     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     */
-    function sort_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator): void;
-    /**
-     * <p> Sort elements of heap. </p>
-     *
-     * <p> Sorts the elements in the heap range [<i>first</i>, <i>last</i>) into ascending order. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>, which shall be the same as used to construct the heap. </p>
-     *
-     * <p> The range loses its properties as a heap. </p>
-     *
-     * @param first {@link IArrayIterator Random-access iterator} to the initial position of the sequence to be sorted.
-     * @param last {@link IArrayIterator Random-access iterator} to the final position of the sequence to be sorted.
-     *			   The range used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *			   {@link IArrayIterator RandomAccessIterator} shall point to a type for which {@link Iterator.swap swap}
-     *			   is properly defined.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value
-     *				  convertible to <code>boolean</code>. The value returned indicates whether the element passed as
-     *				  first argument is considered to go before the second in the specific strict weak ordering it defines.
-     *				  The function shall not modify any of its arguments. This can either be a function pointer or a
-     *				  function object.
-     */
-    function sort_heap<T, RandomAccessIterator extends base.IArrayIterator<T>>(first: RandomAccessIterator, last: RandomAccessIterator, compare: (x: T, y: T) => boolean): void;
-}
-declare namespace std {
-    /**
-     * <p> Return iterator to lower bound. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which does not
-     * compare less than <i>val</i>. </p>
-     *
-     * <p> The elements are compared using {@link less}. The elements in the range shall already be {@link is_sorted sorted}
-     * according to this same criterion ({@link less}), or at least {@link is_partitioned partitioned} with respect to
-     * <i>val</i>. </p>
-     *
-     * <p> The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
-     * range, which is specially efficient for {@link IArrayIterator random-access iterators}. </p>
-     *
-     * <p> Unlike {@link upper_bound}, the value pointed by the iterator returned by this function may also be equivalent
-     * to <i>val</i>, and not only greater. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
-     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
-     *
-     * @return An iterator to the lower bound of <i>val</i> in the range. If all the element in the range compare less than
-     *		   <i>val</i>, the function returns <i>last</i>.
-     */
-    function lower_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): ForwardIterator;
-    /**
-     * <p> Return iterator to lower bound. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which does not
-     * compare less than <i>val</i>. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. The elements in the range shall already be
-     * {@link is_sorted sorted} according to this same criterion (<i>compare</i>), or at least
-     * {@link is_partitioned partitioned} with respect to <i>val</i>. </p>
-     *
-     * <p> The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
-     * range, which is specially efficient for {@link IArrayIterator random-access iterators}. </p>
-     *
-     * <p> Unlike {@link upper_bound}, the value pointed by the iterator returned by this function may also be equivalent
-     * to <i>val</i>, and not only greater. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range.
-     * @param compare Binary function that accepts two arguments (the first of the type pointed by <i>ForwardIterator</i>,
-     *				  and the second, always <i>val</i>), and returns a value convertible to <code>bool</code>. The value
-     *				  returned indicates whether the first argument is considered to go before the second. The function
-     *				  shall not modify any of its arguments.
-     *
-     * @return An iterator to the lower bound of <i>val</i> in the range. If all the element in the range compare less than
-     *		   <i>val</i>, the function returns <i>last</i>.
-     */
-    function lower_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): ForwardIterator;
-    /**
-     * <p> Return iterator to upper bound. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which compares
-     * greater than <i>val</i>. </p>
-     *
-     * <p> The elements are compared using {@link less}. The elements in the range shall already be {@link is_sorted sorted}
-     * according to this same criterion ({@link less}), or at least {@link is_partitioned partitioned} with respect to
-     * <i>val</i>. </p>
-     *
-     * <p> The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
-     * range, which is specially efficient for {@link IArrayIterator random-access iterators}. </p>
-     *
-     * <p> Unlike {@link lower_bound}, the value pointed by the iterator returned by this function cannot be equivalent to
-     * <i>val</i>, only greater. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
-     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
-     *
-     * @return An iterator to the upper bound of <i>val</i> in the range. If no element in the range comparse greater than
-     *		   <i>val</i>, the function returns <i>last</i>.
-     */
-    function upper_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): ForwardIterator;
-    /**
-     * <p> Return iterator to upper bound. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the range [<i>first</i>, <i>last</i>) which compares
-     * greater than <i>val</i>. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. The elements in the range shall already be
-     * {@link is_sorted sorted} according to this same criterion (<i>compare</i>), or at least
-     * {@link is_partitioned partitioned} with respect to <i>val</i>. </p>
-     *
-     * <p> The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
-     * range, which is specially efficient for {@link IArrayIterator random-access iterators}. </p>
-     *
-     * <p> Unlike {@link lower_bound}, the value pointed by the iterator returned by this function cannot be equivalent to
-     * <i>val</i>, only greater. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range.
-     * @param compare Binary function that accepts two arguments (the first of the type pointed by <i>ForwardIterator</i>,
-     *				  and the second, always <i>val</i>), and returns a value convertible to <code>bool</code>. The value
-     *				  returned indicates whether the first argument is considered to go before the second. The function
-     *				  shall not modify any of its arguments.
-     *
-     * @return An iterator to the upper bound of <i>val</i> in the range. If no element in the range comparse greater than
-     *		   <i>val</i>, the function returns <i>last</i>.
-     */
-    function upper_bound<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): ForwardIterator;
-    /**
-     * <p> Get subrange of equal elements. </p>
-     *
-     * <p> Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
-     * values equivalent to <i>val</i>. </p>
-     *
-     * <p> The elements are compared using {@link less}. Two elements, <i>ax/i> and <i>y</i> are considered equivalent
-     * <code>if (!std.less(x, y) && !std.less(y, x))</code>. </p>
-     *
-     * <p> The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
-     * ({@link less}), or at least {@link is_partitioned partitioned} with respect to <i>val</i>. </p>
-     *
-     * <p> If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
-     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
-     * greater than all the elements in the range. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
-     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
-     *
-     * @return A {@link Pair} object, whose member {@link Pair.first} is an iterator to the lower bound of the subrange of
-     *		   equivalent values, and {@link Pair.second} its upper bound. The values are the same as those that would be
-     *		   returned by functions {@link lower_bound} and {@link upper_bound} respectively.
-     */
-    function equal_range<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): Pair<ForwardIterator, ForwardIterator>;
-    /**
-     * <p> Get subrange of equal elements. </p>
-     *
-     * <p> Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
-     * values equivalent to <i>val</i>. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. Two elements, <i>ax/i> and <i>y</i> are considered equivalent
-     * <code>if (!compare(x, y) && !compare(y, x))</code>. </p>
-     *
-     * <p> The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
-     * (<i>compare</i>), or at least {@link is_partitioned partitioned} with respect to <i>val</i>. </p>
-     *
-     * <p> If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
-     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
-     * greater than all the elements in the range. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range.
-     * @param compare Binary function that accepts two arguments of the type pointed by <i>ForwardIterator</i> (and of type
-     *				  <i>T</i>), and returns a value convertible to <code>bool</code>. The value returned indicates whether
-     *				  the first argument is considered to go before the second. The function shall not modify any of its
-     *				  arguments.
-     *
-     * @return A {@link Pair} object, whose member {@link Pair.first} is an iterator to the lower bound of the subrange of
-     *		   equivalent values, and {@link Pair.second} its upper bound. The values are the same as those that would be
-     *		   returned by functions {@link lower_bound} and {@link upper_bound} respectively.
-     */
-    function equal_range<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): Pair<ForwardIterator, ForwardIterator>;
-    /**
-     * <p> Get subrange of equal elements. </p>
-     *
-     * <p> Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
-     * values equivalent to <i>val</i>. </p>
-     *
-     * <p> The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!std.less(x, y) && !std.less(y, x))</code>. </p>
-     *
-     * <p> The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
-     * ({@link less}), or at least {@link is_partitioned partitioned} with respect to <i>val</i>. </p>
-     *
-     * <p> If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
-     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
-     * greater than all the elements in the range. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range. <i>T</i> shall be a type supporting being compared
-     *			  with elements of the range [<i>first</i>, <i>last</i>) as the left-hand side operand of {@link less}.
-     *
-     * @return <code>true</code> if an element equivalent to <i>val</i> is found, and <code>false</code> otherwise.
-     */
-    function binary_search<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): boolean;
-    /**
-     * <p> Get subrange of equal elements. </p>
-     *
-     * <p> Returns the bounds of the subrange that includes all the elements of the range [<i>first</i>, <i>last</i>) with
-     * values equivalent to <i>val</i>. </p>
-     *
-     * <p> The elements are compared using {<i>compare</i>}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!compare(x, y) && !compare(y, x))</code>. </p>
-     *
-     * <p> The elements in the range shall already be {@link is_sorted sorted} according to this same criterion
-     * (<i>compare</i>), or at least {@link is_partitioned partitioned} with respect to <i>val</i>. </p>
-     *
-     * <p> If <i>val</i> is not equivalent to any value in the range, the subrange returned has a length of zero, with both
-     * iterators pointing to the nearest value greater than <i>val</i>, if any, or to <i>last</i>, if <i>val</i> compares
-     * greater than all the elements in the range. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of a {@link is_sorted sorted} (or properly
-     *				{@link is_partitioned partitioned}) sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of a {@link is_sorted sorted} (or properly
-     *			   {@link is_partitioned partitioned}) sequence. The range used is [<i>first</i>, <i>last</i>), which
-     *			   contains all the elements between <i>first</i> and <i>last</i>, including the element pointed by
-     *			   <i>first</i> but not the element pointed by <i>last</i>.
-     * @param val Value of the lower bound to search for in the range.
-     * @param compare Binary function that accepts two arguments of the type pointed by <i>ForwardIterator</i> (and of type
-     *				  <i>T</i>), and returns a value convertible to <code>bool</code>. The value returned indicates whether
-     *				  the first argument is considered to go before the second. The function shall not modify any of its
-     *				  arguments.
-     *
-     * @return <code>true</code> if an element equivalent to <i>val</i> is found, and <code>false</code> otherwise.
-     */
-    function binary_search<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T, compare: (x: T, y: T) => boolean): boolean;
-}
-declare namespace std {
-    /**
-     * <p> Test whether range is partitioned. </p>
-     *
-     * <p> Returns <code>true</code> if all the elements in the range [<i>first</i>, <i>last</i>) for which <i>pred</i>
-     * returns <code>true</code> precede those for which it returns <code>false</code>. </p>
-     *
-     * <p> If the range is {@link IContainer.empty empty}, the function returns <code>true</code>. </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position of the sequence.
-     * @param last {@link Iterator Input iterator} to the final position of the sequence. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element belongs to the first group (if
-     *			   <code>true</code>, the element is expected before all the elements for which it returns
-     *			   <code>false</code>). The function shall not modify its argument.
-     *
-     * @return <code>true</code> if all the elements in the range [<i>first</i>, <i>last</i>) for which <i>pred</i> returns
-     *		   <code>true</code> precede those for which it returns <code>false</code>. Otherwise it returns
-     *		   <code>false</code>. If the range is {@link IContainer.empty empty}, the function returns <code>true</code>.
-     */
-    function is_partitioned<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (x: T) => boolean): boolean;
-    /**
-     * <p> Partition range in two. </p>
-     *
-     * <p> Rearranges the elements from the range [<i>first</i>, <i>last</i>), in such a way that all the elements for
-     * which <i>pred</i> returns <code>true</code> precede all those for which it returns <code>false</code>. The iterator
-     * returned points to the first element of the second group. </p>
-     *
-     * <p> The relative ordering within each group is not necessarily the same as before the call. See
-     * {@link stable_partition} for a function with a similar behavior but with stable ordering within each group. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the sequence to partition.
-     * @param last {@link Iterator Forward iterator} to the final position of the sequence to partition. The range used is
-     *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element belongs to the first group (if
-     *			   <code>true</code>, the element is expected before all the elements for which it returns
-     *			   <code>false</code>). The function shall not modify its argument.
-     *
-     * @return An iterator that points to the first element of the second group of elements (those for which <i>pred</i>
-     *		   returns <code>false</code>), or <i>last</i> if this group is {@link IContainer.empty empty}.
-     */
-    function partition<T, BidirectionalIterator extends Iterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, pred: (x: T) => boolean): BidirectionalIterator;
-    /**
-     * <p> Partition range in two - stable ordering. </p>
-     *
-     * <p> Rearranges the elements in the range [<i>first</i>, <i>last</i>), in such a way that all the elements for which
-     * <i>pred</i> returns <code>true</code> precede all those for which it returns <code>false</code>, and, unlike
-     * function {@link partition}, the relative order of elements within each group is preserved. </p>
-     *
-     * <p> This is generally implemented using an internal temporary buffer. </p>
-     *
-     * @param first {@link Iterator Bidirectional iterator} to the initial position of the sequence to partition.
-     * @param last {@link Iterator Bidirectional iterator} to the final position of the sequence to partition. The range
-     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element belongs to the first group (if
-     *			   <code>true</code>, the element is expected before all the elements for which it returns
-     *			   <code>false</code>). The function shall not modify its argument.
-     *
-     * @return An iterator that points to the first element of the second group of elements (those for which <i>pred</i>
-     *		   returns <code>false</code>), or <i>last</i> if this group is {@link IContainer.empty empty}.
-     */
-    function stable_partition<T, BidirectionalIterator extends Iterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, pred: (x: T) => boolean): BidirectionalIterator;
-    /**
-     * <p> Partition range into two. </p>
-     *
-     * <p> Copies the elements in the range [<i>first</i>, <i>last</i>) for which <i>pred</i> returns <code>true</code>
-     * into the range pointed by <i>result_true</i>, and those for which it does not into the range pointed by
-     * <i>result_false</i>. </p>
-     *
-     * @param first {@link Iterator Input iterator} to the initial position of the range to be copy-partitioned.
-     * @param last {@link Iterator Input iterator} to the final position of the range to be copy-partitioned. The range
-     *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-     *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param result_true {@link Iterator Output iterator} to the initial position of the range where the elements for
-     *					  which <i>pred</i> returns <code>true</code> are stored.
-     * @param result_false {@link Iterator Output iterator} to the initial position of the range where the elements for
-     *					   which <i>pred</i> returns <code>false</code> are stored.
-     * @param pred Unary function that accepts an element pointed by <i>InputIterator</i> as argument, and returns a value
-     *			   convertible to <code>bool</code>. The value returned indicates on which result range the element is
-     *			   copied. The function shall not modify its argument.
-     *
-     * @return A {@link Pair} of iterators with the end of the generated sequences pointed by <i>result_true</i> and
-     *		   <i>result_false</i>, respectivelly. Its member {@link Pair.first first} points to the element that follows
-     *		   the last element copied to the sequence of elements for which <i>pred</i> returned <code>true</code>. Its
-     *		   member {@link Pair.second second} points to the element that follows the last element copied to the sequence
-     *		   of elements for which <i>pred</i> returned <code>false</code>.
-     */
-    function partition_copy<T, InputIterator extends Iterator<T>, OutputIterator1 extends base.ILinearIterator<T>, OutputIterator2 extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result_true: OutputIterator1, result_false: OutputIterator2, pred: (val: T) => T): Pair<OutputIterator1, OutputIterator2>;
-    /**
-     * <p> Get partition point. </p>
-     *
-     * <p> Returns an iterator to the first element in the partitioned range [<i>first</i>, <i>last</i>) for which
-     * <i>pred</i> is not <code>true</code>, indicating its partition point. </p>
-     *
-     * <p> The elements in the range shall already {@link is_partitioned be partitioned}, as if {@link partition} had been
-     * called with the same arguments. </p>
-     *
-     * <p> The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted
-     * range, which is specially efficient for {@link Iteartor random-access iterators}. </p>
-     *
-     * @param first {@link Iterator Forward iterator} to the initial position of the partitioned sequence.
-     * @param last {@link Iterator Forward iterator} to the final position of the partitioned sequence. The range checked
-     *		  is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> an <i>last</i>,
-     *		  including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible to
-     *			   <code>bool</code>. The value returned indicates whether the element goes before the partition point (if
-     *			   <code>true</code>, it goes before; if <code>false</code> goes at or after it). The function shall not
-     *			   modify its argument.
-     *
-     * @return An iterator to the first element in the partitioned range [<i>first</i>, <i>last</i>) for which <i>pred</i>
-     *		   is not <code>true</code>, or <i>last</i> if it is not <code>true</code> for any element.
-     */
-    function partition_point<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, pred: (x: T) => boolean): ForwardIterator;
-}
-declare namespace std {
-    /**
-     * <p> Merge sorted ranges. </p>
-     *
-     * <p> Combines the elements in the sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>), into
-     * a new range beginning at <i>result</i> with all its elements sorted. </p>
-     *
-     * <p> The elements are compared using {@link less}. The elements in both ranges shall already be ordered according to
-     * this same criterion ({@link less}). The resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting combined
-     *				 range is stored. Its size is equal to the sum of both ranges above.
-     *
-     * @return An iterator pointing to the past-the-end element in the resulting sequence.
-     */
-    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Merge sorted ranges. </p>
-     *
-     * <p> Combines the elements in the sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>), into
-     * a new range beginning at <i>result</i> with all its elements sorted. </p>
-     *
-     * <p> The elements are compared using {@link less}. The elements in both ranges shall already be ordered according to
-     * this same criterion (<i>compare</i>). The resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting combined
-     *				 range is stored. Its size is equal to the sum of both ranges above.
-     * @param compare Binary function that accepts two arguments of the types pointed by the iterators, and returns a value
-     *				  convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
-     *				  function shall not modify any of its arguments.
-     *
-     * @return An iterator pointing to the past-the-end element in the resulting sequence.
-     */
-    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
-    /**
-     * <p> Merge consecutive sorted ranges. </p>
-     *
-     * <p> Merges two consecutive sorted ranges: [<i>first</i>, <i>middle</i>) and [<i>middle</i>, <i>last</i>), putting
-     * the result into the combined sorted range [<i>first</i>, <i>last</i>). </p>
-     *
-     * <p> The elements are compared using {@link less}. The elements in both ranges shall already be ordered according to
-     * this same criterion ({@link less}). The resulting range is also sorted according to this. </p>
-     *
-     * <p> The function preserves the relative order of elements with equivalent values, with the elements in the first
-     * range preceding those equivalent in the second. </p>
-     *
-     * @param first {@link Iterator Bidirectional iterator} to the initial position in the first sorted sequence to merge.
-     *				This is also the initial position where the resulting merged range is stored.
-     * @param middle {@link Iterator Bidirectional iterator} to the initial position of the second sorted sequence, which
-     *				 because both sequences must be consecutive, matches the <i>past-the-end</i> position of the first
-     *				 sequence.
-     * @param last {@link Iterator Bidirectional iterator} to the <i>past-the-end</i> position of the second sorted
-     *			   sequence. This is also the <i>past-the-end</i> position of the range where the resulting merged range is
-     *			   stored.
-     */
-    function inplace_merge<T, BidirectionalIterator extends Iterator<T>>(first: BidirectionalIterator, middle: BidirectionalIterator, last: BidirectionalIterator): void;
-    /**
-     * <p> Merge consecutive sorted ranges. </p>
-     *
-     * <p> Merges two consecutive sorted ranges: [<i>first</i>, <i>middle</i>) and [<i>middle</i>, <i>last</i>), putting
-     * the result into the combined sorted range [<i>first</i>, <i>last</i>). </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. The elements in both ranges shall already be ordered according
-     * to this same criterion (<i>compare</i>). The resulting range is also sorted according to this. </p>
-     *
-     * <p> The function preserves the relative order of elements with equivalent values, with the elements in the first
-     * range preceding those equivalent in the second. </p>
-     *
-     * @param first {@link Iterator Bidirectional iterator} to the initial position in the first sorted sequence to merge.
-     *				This is also the initial position where the resulting merged range is stored.
-     * @param middle {@link Iterator Bidirectional iterator} to the initial position of the second sorted sequence, which
-     *				 because both sequences must be consecutive, matches the <i>past-the-end</i> position of the first
-     *				 sequence.
-     * @param last {@link Iterator Bidirectional iterator} to the <i>past-the-end</i> position of the second sorted
-     *			   sequence. This is also the <i>past-the-end</i> position of the range where the resulting merged range is
-     *			   stored.
-     * @param compare Binary function that accepts two arguments of the types pointed by the iterators, and returns a value
-     *				  convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
-     *				  function shall not modify any of its arguments.
-     */
-    function inplace_merge<T, BidirectionalIterator extends Iterator<T>>(first: BidirectionalIterator, middle: BidirectionalIterator, last: BidirectionalIterator, compare: (x: T, y: T) => boolean): void;
-    /**
-     * <p> Test whether sorted range includes another sorted range. </p>
-     *
-     * <p> Returns <code>true</code> if the sorted range [<i>first1</i>, <i>last1</i>) contains all the elements in the
-     * sorted range [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!std.less(x, y) && !std.less(y, x))</code>. </p>
-     *
-     * <p> The elements in the range shall already be ordered according to this same criterion ({@link less}). </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence (which is tested on
-     *				whether it contains the second sequence). The range used is [<i>first1</i>, <i>last1</i>), which
-     *				contains all the elements between <i>first1</i> and <i>last1</i>, including the element pointed by
-     *				<i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. (which is tested
-     *				on whether it is contained in the first sequence). The range used is [<i>first2</i>, <i>last2</i>).
-     *
-     * @return <code>true</code> if every element in the range [<i>first2</i>, <i>last2</i>) is contained in the range
-     *		   [<i>first1</i>, <i>last1</i>), <code>false</code> otherwise. If [<i>first2</i>, <i>last2</i>) is an empty
-     *		   range, the function returns <code>true</code>.
-     */
-    function includes<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2): boolean;
-    /**
-     * <p> Test whether sorted range includes another sorted range. </p>
-     *
-     * <p> Returns <code>true</code> if the sorted range [<i>first1</i>, <i>last1</i>) contains all the elements in the
-     * sorted range [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!compare(x, y) && !compare(y, x))</code>. </p>
-     *
-     * <p> The elements in the range shall already be ordered according to this same criterion (<i>compare</i>). </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence (which is tested on
-     *				whether it contains the second sequence). The range used is [<i>first1</i>, <i>last1</i>), which
-     *				contains all the elements between <i>first1</i> and <i>last1</i>, including the element pointed by
-     *				<i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. (which is tested
-     *				on whether it is contained in the first sequence). The range used is [<i>first2</i>, <i>last2</i>).
-     * @param compare Binary function that accepts two elements as arguments (one from each of the two sequences, in the
-     *				  same order), and returns a value convertible to <code>bool</code>. The value returned indicates
-     *				  whether the element passed as first argument is considered to go before the second in the specific
-     *				  <i>strict weak ordering</i> it defines. The function shall not modify any of its arguments.
-     *
-     * @return <code>true</code> if every element in the range [<i>first2</i>, <i>last2</i>) is contained in the range
-     *		   [<i>first1</i>, <i>last1</i>), <code>false</code> otherwise. If [<i>first2</i>, <i>last2</i>) is an empty
-     *		   range, the function returns <code>true</code>.
-     */
-    function includes<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, compare: (x: T, y: T) => boolean): boolean;
-    /**
-     * <p> Union of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set union</i> of the
-     * two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The <i>union</i> of two sets is formed by the elements that are present in either one of the sets, or in both.
-     * Elements from the second range that have an equivalent element in the first range are not copied to the resulting
-     * range. </p>
-     *
-     * <p> The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!std.less(x, y) && !std.less(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion ({@link less}). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Union of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set union</i> of the
-     * two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The <i>union</i> of two sets is formed by the elements that are present in either one of the sets, or in both.
-     * Elements from the second range that have an equivalent element in the first range are not copied to the resulting
-     * range. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!compare(x, y) && !compare(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
-     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
-     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
-     *				  function shall not modify any of its arguments.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
-    /**
-     * <p> Intersection of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set intersection</i> of
-     * the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The <i>intersection</i> of two sets is formed only by the elements that are present in both sets. The elements
-     * copied by the function come always from the first range, in the same order. </p>
-     *
-     * <p> The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!std.less(x, y) && !std.less(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion ({@link less}). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Intersection of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set intersection</i> of
-     * the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The <i>intersection</i> of two sets is formed only by the elements that are present in both sets. The elements
-     * copied by the function come always from the first range, in the same order. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!compare(x, y) && !compare(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
-     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
-     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
-     *				  function shall not modify any of its arguments.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
-    /**
-     * <p> Difference of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set difference</i> of
-     * the sorted range [<i>first1</i>, <i>last1</i>) with respect to the sorted range [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The <i>difference</i> of two sets is formed by the elements that are present in the first set, but not in the
-     * second one. The elements copied by the function come always from the first range, in the same order. </p>
-     *
-     * <p> For containers supporting multiple occurrences of a value, the <i>difference</i> includes as many occurrences of
-     * a given value as in the first range, minus the amount of matching elements in the second, preserving order. </p>
-     *
-     * <p> Notice that this is a directional operation - for a symmetrical equivalent, see {@link set_symmetric_difference}.
-     * </p>
-     *
-     * <p> The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!std.less(x, y) && !std.less(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion ({@link less}). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Difference of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by <i>result</i> with the <i>set difference</i> of
-     * the sorted range [<i>first1</i>, <i>last1</i>) with respect to the sorted range [<i>first2</i>, <i>last2</i>). </p>
-     *
-     * <p> The <i>difference</i> of two sets is formed by the elements that are present in the first set, but not in the
-     * second one. The elements copied by the function come always from the first range, in the same order. </p>
-     *
-     * <p> For containers supporting multiple occurrences of a value, the <i>difference</i> includes as many occurrences of
-     * a given value as in the first range, minus the amount of matching elements in the second, preserving order. </p>
-     *
-     * <p> Notice that this is a directional operation - for a symmetrical equivalent, see {@link set_symmetric_difference}.
-     * </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!compare(x, y) && !compare(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the first range.
-     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
-     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
-     *				  function shall not modify any of its arguments.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
-    /**
-     * <p> Symmetric difference of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by0 <i>result</i> with the set
-     * <i>symmetric difference</i> of the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
-     * </p>
-     *
-     * <p> The <i>symmetric difference</i> of two sets is formed by the elements that are present in one of the sets, but
-     * not in the other. Among the equivalent elements in each range, those discarded are those that appear before in the
-     * existent order before the call. The existing order is also preserved for the copied elements. </p>
-     *
-     * <p> The elements are compared using {@link less}. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!std.less(x, y) && !std.less(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion ({@link std.less}). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
-     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
-     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
-     *				  function shall not modify any of its arguments.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
-    /**
-     * <p> Symmetric difference of two sorted ranges. </p>
-     *
-     * <p> Constructs a sorted range beginning in the location pointed by0 <i>result</i> with the set
-     * <i>symmetric difference</i> of the two sorted ranges [<i>first1</i>, <i>last1</i>) and [<i>first2</i>, <i>last2</i>).
-     * </p>
-     *
-     * <p> The <i>symmetric difference</i> of two sets is formed by the elements that are present in one of the sets, but
-     * not in the other. Among the equivalent elements in each range, those discarded are those that appear before in the
-     * existent order before the call. The existing order is also preserved for the copied elements. </p>
-     *
-     * <p> The elements are compared using <i>compare</i>. Two elements, <i>x</i> and <i>y</i> are considered equivalent
-     * <code>if (!compare(x, y) && !compare(y, x))</code>. </p>
-     *
-     * <p> The elements in the ranges shall already be ordered according to this same criterion (<i>compare</i>). The
-     * resulting range is also sorted according to this. </p>
-     *
-     * @param first1 {@link Iterator Input iterator} to the initial position of the first sorted sequence.
-     * @param last1 {@link Iterator Input iterator} to the final position of the first sorted sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), which contains all the elements between <i>first1</i> and <i>last1</i>,
-     *				including the element pointed by <i>first1</i> but not the element pointed by <i>last1</i>.
-     * @param first2 {@link Iterator Input iterator} to the initial position of the second sorted sequence.
-     * @param last2 {@link Iterator Input iterator} to the final position of the second sorted sequence. The range used is
-     *				[<i>first2</i>, <i>last2</i>).
-     * @param result {@link Iterator Output iterator} to the initial position of the range where the resulting sequence is
-     *				 stored. The pointed type shall support being assigned the value of an element from the other ranges.
-     * @param compare Binary function that accepts two arguments of the types pointed by the input iterators, and returns a
-     *				  value convertible to <code>bool</code>. The value returned indicates whether the first argument is
-     *				  considered to go before the second in the specific <i>strict weak ordering</i> it defines. The
-     *				  function shall not modify any of its arguments.
-     *
-     * @return An iterator to the end of the constructed range.
-     */
-    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
-}
-declare namespace std {
-    /**
-     * <p> Return the smallest. </p>
-     *
-     * <p> Returns the smallest of all the elements in the <i>args</i>. </p>
-     *
-     * @param args Values to compare.
-     *
-     * @return The lesser of the values passed as arguments.
-     */
-    function min<T>(...args: T[]): T;
-    /**
-     * <p> Return the largest. </p>
-     *
-     * <p> Returns the largest of all the elements in the <i>args</i>. </p>
-     *
-     * @param args Values to compare.
-     *
-     * @return The largest of the values passed as arguments.
-     */
-    function max<T>(...args: T[]): T;
-    /**
-     * <p> Return smallest and largest elements. </p>
-     *
-     * <p> Returns a {@link Pair} with the smallest of all the elements in the <i>args</i> as first element (the first of
-     * them, if there are more than one), and the largest as second (the last of them, if there are more than one). </p>
-     *
-     * @param args Values to compare.
-     *
-     * @return The lesser and greatest of the values passed as arguments.
-     */
-    function minmax<T>(...args: T[]): Pair<T, T>;
-    /**
-     * <p> Return smallest element in range. </p>
-     *
-     * <p> Returns an iterator pointing to the element with the smallest value in the range  [<i>first</i>, <i>last</i>).
-     * </p>
-     *
-     * <p> The comparisons are performed using either {@link less}; An element is the smallest if no other element
-     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
-     * of such elements. </p>
-     *
-     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
-     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
-     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *
-     * @return An iterator to smallest value in the range, or <i>last</i> if the range is empty.
-     */
-    function min_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): ForwardIterator;
-    /**
-     * <p> Return smallest element in range. </p>
-     *
-     * <p> Returns an iterator pointing to the element with the smallest value in the range  [<i>first</i>, <i>last</i>).
-     * </p>
-     *
-     * <p> The comparisons are performed using either <i>compare</i>; An element is the smallest if no other element
-     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
-     * of such elements. </p>
-     *
-     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
-     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
-     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
-     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
-     *				  considered less than the second. The function shall not modify any of its arguments.
-     *
-     * @return An iterator to smallest value in the range, or <i>last</i> if the range is empty.
-     */
-    function min_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): ForwardIterator;
-    /**
-     * <p> Return largest element in range. </p>
-     *
-     * <p> Returns an iterator pointing to the element with the largest value in the range  [<i>first</i>, <i>last</i>).
-     * </p>
-     *
-     * <p> The comparisons are performed using either {@link greater}; An element is the largest if no other element
-     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
-     * of such elements. </p>
-     *
-     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
-     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
-     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     *
-     * @return An iterator to largest value in the range, or <i>last</i> if the range is empty.
-     */
-    function max_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): ForwardIterator;
-    /**
-     * <p> Return largest element in range. </p>
-     *
-     * <p> Returns an iterator pointing to the element with the largest value in the range  [<i>first</i>, <i>last</i>).
-     * </p>
-     *
-     * <p> The comparisons are performed using either <i>compare</i>; An element is the largest if no other element
-     * compares less than it. If more than one element fulfills this condition, the iterator returned points to the first
-     * of such elements. </p>
-     *
-     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
-     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
-     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
-     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
-     *				  considered less than the second. The function shall not modify any of its arguments.
-     *
-     * @return An iterator to largest value in the range, or <i>last</i> if the range is empty.
-     */
-    function max_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): ForwardIterator;
-    /**
-     * <p> Return smallest and largest elements in range. </p>
-     *
-     * <p> Returns a {@link Pair} with an iterator pointing to the element with the smallest value in the range
-     * [<i>first</i>, <i>last</i>) as first element, and the largest as second. </p>
-     *
-     * <p> The comparisons are performed using either {@link less} and {@link greater}. </p>
-     *
-     * <p> If more than one equivalent element has the smallest value, the first iterator points to the first of such
-     * elements. </p>
-     *
-     * <p> If more than one equivalent element has the largest value, the second iterator points to the last of such
-     * elements. </p>
-     *
-     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
-     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
-     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
-     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
-     *				  considered less than the second. The function shall not modify any of its arguments.
-     *
-     * @return A {@link Pair} with an iterator pointing to the element with the smallest value in the range
-     *		   [<i>first</i>, <i>last</i>) as first element, and the largest as second.
-     */
-    function minmax_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator): Pair<ForwardIterator, ForwardIterator>;
-    /**
-     * <p> Return smallest and largest elements in range. </p>
-     *
-     * <p> Returns a {@link Pair} with an iterator pointing to the element with the smallest value in the range
-     * [<i>first</i>, <i>last</i>) as first element, and the largest as second. </p>
-     *
-     * <p> The comparisons are performed using either <i>compare</i>. </p>
-     *
-     * <p> If more than one equivalent element has the smallest value, the first iterator points to the first of such
-     * elements. </p>
-     *
-     * <p> If more than one equivalent element has the largest value, the second iterator points to the last of such
-     * elements. </p>
-     *
-     * @param first {@link Iteartor Input iterator} to the initial final position of the sequence to compare.
-     * @param last {@link Iteartor Input iterator} to the final final position of the sequence to compare. The range used
-     *			   is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-     *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-     * @param compare Binary function that accepts two elements in the range as arguments, and returns a value convertible
-     *				  to <code>bool</code>. The value returned indicates whether the element passed as first argument is
-     *				  considered less than the second. The function shall not modify any of its arguments.
-     *
-     * @return A {@link Pair} with an iterator pointing to the element with the smallest value in the range
-     *		   [<i>first</i>, <i>last</i>) as first element, and the largest as second.
-     */
-    function minmax_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): Pair<ForwardIterator, ForwardIterator>;
-    /**
-     * <p> Test whether range is permutation of another. </p>
-     *
-     * <p> Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
-     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match, even in a different
-     * order. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
-     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
-     *
-     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
-     *		   of the range starting at <i>first2</i> in any order, and <code>false</code> otherwise.
-     */
-    function is_permutation<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2): boolean;
-    /**
-     * <p> Test whether range is permutation of another. </p>
-     *
-     * <p> Compares the elements in the range [<i>first1</i>, <i>last1</i>) with those in the range beginning at
-     * <i>first2</i>, and returns <code>true</code> if all of the elements in both ranges match, even in a different
-     * order. </p>
-     *
-     * @param first1 An {@link Iterator} to the initial position of the first sequence.
-     * @param last1 An {@link Iterator} to the final position in a sequence. The range used is
-     *				[<i>first1</i>, <i>last1</i>), including the element pointed by <i>first1</i>, but not the element
-     *				pointed by <i>last1</i>.
-     * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to
-     *				 as many elements of this sequence as those in the range [<i>first1</i>, <i>last1</i>).
-     * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same
-     *			   order), and returns a value convertible to <code>bool</code>. The value returned indicates whether
-     *			   the elements are considered to match in the context of this function.
-     *
-     * @return <code>true</code> if all the elements in the range [<i>first1</i>, <i>last1</i>) compare equal to those
-     *		   of the range starting at <i>first2</i> in any order, and <code>false</code> otherwise.
-     */
-    function is_permutation<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, pred: (x: T, y: T) => boolean): boolean;
-    /**
-     * Transform range to previous permutation.
-     *
-     * Rearranges the elements in the range [*first*, *last*) into the previous *lexicographically-ordered* permutation.
-     *
-     * A *permutation* is each one of the N! possible arrangements the elements can take (where *N* is the number of
-     * elements in the range). Different permutations can be ordered according to how they compare
-     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
-     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
-     * sorted in ascending order, and the largest has all its elements sorted in descending order.
-     *
-     * The comparisons of individual elements are performed using the {@link std.less std.less()} function.
-     *
-     * If the function can determine the previous permutation, it rearranges the elements as such and returns true. If
-     * that was not possible (because it is already at the lowest possible permutation), it rearranges the elements
-     * according to the last permutation (sorted in descending order) and returns false.
-     *
-     * @param first Bidirectional iterators to the initial positions of the sequence
-     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
-     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
-     *			   but not the element pointed by *last*.
-     *
-     * @return true if the function could rearrange the object as a lexicographicaly smaller permutation. Otherwise, the
-     *		   function returns false to indicate that the arrangement is not less than the previous, but the largest
-     *		   possible (sorted in descending order).
-     */
-    function prev_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator): boolean;
-    /**
-     * Transform range to previous permutation.
-     *
-     * Rearranges the elements in the range [*first*, *last*) into the previous *lexicographically-ordered* permutation.
-     *
-     * A *permutation* is each one of the N! possible arrangements the elements can take (where *N* is the number of
-     * elements in the range). Different permutations can be ordered according to how they compare
-     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
-     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
-     * sorted in ascending order, and the largest has all its elements sorted in descending order.
-     *
-     * The comparisons of individual elements are performed using the *compare*.
-     *
-     * If the function can determine the previous permutation, it rearranges the elements as such and returns true. If
-     * that was not possible (because it is already at the lowest possible permutation), it rearranges the elements
-     * according to the last permutation (sorted in descending order) and returns false.
-     *
-     * @param first Bidirectional iterators to the initial positions of the sequence
-     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
-     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
-     *			   but not the element pointed by *last*.
-     * @param compare Binary function that accepts two arguments of the type pointed by BidirectionalIterator, and returns
-     *				  a value convertible to bool. The value returned indicates whether the first argument is considered
-     *				  to go before the second in the specific strict weak ordering it defines.
-     *
-     * @return true if the function could rearrange the object as a lexicographicaly smaller permutation. Otherwise, the
-     *		   function returns false to indicate that the arrangement is not less than the previous, but the largest
-     *		   possible (sorted in descending order).
-     */
-    function prev_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, compare: (x: T, y: T) => boolean): boolean;
-    /**
-     * Transform range to next permutation.
-     *
-     * Rearranges the elements in the range [*first*, *last*) into the next *lexicographically greater* permutation.
-     *
-     * A permutation is each one of the *N!* possible arrangements the elements can take (where *N* is the number of
-     * elements in the range). Different permutations can be ordered according to how they compare
-     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
-     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
-     * sorted in ascending order, and the largest has all its elements sorted in descending order.
-     *
-     * The comparisons of individual elements are performed using the {@link std.less} function.
-     *
-     * If the function can determine the next higher permutation, it rearranges the elements as such and returns true. If
-     * that was not possible (because it is already at the largest possible permutation), it rearranges the elements
-     * according to the first permutation (sorted in ascending order) and returns false.
-     *
-     * @param first Bidirectional iterators to the initial positions of the sequence
-     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
-     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
-     *			   but not the element pointed by *last*.
-     *
-     * @return true if the function could rearrange the object as a lexicographicaly greater permutation. Otherwise, the
-     *		   function returns false to indicate that the arrangement is not greater than the previous, but the lowest
-     *		   possible (sorted in ascending order).
-     */
-    function next_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator): boolean;
-    /**
-     * Transform range to next permutation.
-     *
-     * Rearranges the elements in the range [*first*, *last*) into the next *lexicographically greater* permutation.
-     *
-     * A permutation is each one of the *N!* possible arrangements the elements can take (where *N* is the number of
-     * elements in the range). Different permutations can be ordered according to how they compare
-     * {@link lexicographicaly lexicographical_compare} to each other; The first such-sorted possible permutation (the one
-     * that would compare *lexicographically smaller* to all other permutations) is the one which has all its elements
-     * sorted in ascending order, and the largest has all its elements sorted in descending order.
-     *
-     * The comparisons of individual elements are performed using the *compare*.
-     *
-     * If the function can determine the next higher permutation, it rearranges the elements as such and returns true. If
-     * that was not possible (because it is already at the largest possible permutation), it rearranges the elements
-     * according to the first permutation (sorted in ascending order) and returns false.
-     *
-     * @param first Bidirectional iterators to the initial positions of the sequence
-     * @param last Bidirectional iterators to the final positions of the sequence. The range used is [*first*, *last*),
-     *			   which contains all the elements between *first* and *last*, including the element pointed by *first*
-     *			   but not the element pointed by *last*.
-     * @param compare Binary function that accepts two arguments of the type pointed by BidirectionalIterator, and returns
-     *				  a value convertible to bool. The value returned indicates whether the first argument is considered
-     *				  to go before the second in the specific strict weak ordering it defines.
-     *
-     * @return true if the function could rearrange the object as a lexicographicaly greater permutation. Otherwise, the
-     *		   function returns false to indicate that the arrangement is not greater than the previous, but the lowest
-     *		   possible (sorted in ascending order).
-     */
-    function next_permutation<T, BidirectionalIterator extends base.IArrayIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, compare: (x: T, y: T) => boolean): boolean;
-}
-declare namespace std.base {
-    /**
-     * <p> Static class holding enumeration codes of color of Red-black tree. </p>
-     *
-     * <p> Color codes imposed to nodes of RB-Tree are following those rules: </p>
-     *
-     * <ol>
-     *	<li> A node is either <font color='red'>red</font> or <font color='darkBlue'>black</font>. </li>
-     *	<li> The root is <font color='darkBlue'>black</font>. This rule is sometimes omitted. Since the root can
-     *		 always be changed from <font color='red'>red</font> to <font color='darkBlue'>black</font>, but not
-     *		 necessarily vice versa, this rule has little effect on analysis. </li>
-     *	<li> All leaves (NIL; <code>null</code>) are <font color='darkBlue'>black</font>. </li>
-     *  <li> If a node is <font color='red'>red</font>, then both its children are
-     *		 <font color='darkBlue'>black</font>. </li>
-     *  <li> Every path from a given node to any of its descendant NIL nodes contains the same number of
-     *		 <font color='darkBlue'>black</font> nodes. Some definitions: the number of
-     *		 <font color='darkBlue'>black</font> nodes from the root to a node is the node's
-     *		 <font color='darkBlue'>black</font> depth; the uniform number of <font color='darkBlue'>black</font>
-     *		 nodes in all paths from root to the leaves is called the <font color='darkBlue'>black</font>-height of
-     *		 the red-black tree. </li>
-     * </ol>
-     *
-     * @author Migrated by Jeongho Nam <http://samchon.org>
-     */
-    enum Color {
-        /**
-         * <p> Code of color black. </p>
-         *
-         * <ul>
-         *	<li> Those are clearly black: root, leaf nodes or children nodes of red. </li>
-         *	<li> Every path from a given nodes containes the same number of black nodes exclude NIL(s). </li>
-         * </ul>
-         */
-        BLACK = 0,
-        /**
-         * <p> Code of color red. </p>
-         */
-        RED = 1,
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract container. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" />
-     * </a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Sequence </dt>
-     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
-     *		 accessed by their position in this sequence. </dd>
-     *
-     * 	<dt> Doubly-linked list </dt>
-     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing
-     *		 constant time insert and erase operations before or after a specific element (even of entire ranges),
-     *		 but no direct random access. </dd>
-     * </dl>
-     *
-     * @param <T> Type of elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Container<T> implements IContainer<T> {
-        /**
-         * Default Constructor.
-         */
-        protected constructor();
-        /**
-         * @inheritdoc
-         */
-        abstract assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        abstract begin(): Iterator<T>;
-        /**
-         * @inheritdoc
-         */
-        abstract end(): Iterator<T>;
-        /**
-         * @inheritdoc
-         */
-        abstract rbegin(): base.IReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        abstract rend(): base.IReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        abstract size(): number;
-        /**
-         * @inheritdoc
-         */
-        empty(): boolean;
-        /**
-         * @inheritdoc
-         */
-        abstract push(...items: T[]): number;
-        /**
-         * @inheritdoc
-         */
-        abstract insert(position: Iterator<T>, val: T): Iterator<T>;
-        /**
-         * @inheritdoc
-         */
-        abstract erase(position: Iterator<T>): Iterator<T>;
-        /**
-         * @inheritdoc
-         */
-        abstract erase<U extends T>(begin: Iterator<U>, end: Iterator<U>): Iterator<T>;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: IContainer<T>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract error instance. </p>
-     *
-     * <p> {@link ErrorInstance} is an abstract class of {@link ErrorCode} and {@link ErrorCondition}
-     * holding an error instance's identifier {@link value}, associated with a {@link category}. </p>
-     *
-     * <p> The operating system and other low-level applications and libraries generate numerical error codes to
-     * represent possible results. These numerical values may carry essential information for a specific platform,
-     * but be non-portable from one platform to another. </p>
-     *
-     * <p> Objects of this class associate such numerical codes to {@link ErrorCategory error categories},
-     * so that they can be interpreted when needed as more abstract (and portable)
-     * {@link ErrorCondition error conditions}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ErrorInstance {
-        /**
-         * @hidden
-         */
-        protected category_: ErrorCategory;
-        /**
-         * @hidden
-         */
-        protected value_: number;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from a numeric value and error category.
-         *
-         * @param val A numerical value identifying an error instance.
-         * @param category A reference to an {@link ErrorCategory} object.
-         */
-        constructor(val: number, category: ErrorCategory);
-        /**
-         * <p> Assign error instance. </p>
-         *
-         * <p> Assigns the {@link ErrorCode} object a value of val associated with the {@link ErrorCategory}. </p>
-         *
-         * @param val A numerical value identifying an error instance.
-         * @param category A reference to an {@link ErrorCategory} object.
-         */
-        assign(val: number, category: ErrorCategory): void;
-        /**
-         * <p> Clear error instance. </p>
-         *
-         * <p> Clears the value in the {@link ErrorCode} object so that it is set to a value of <i>0</i> of the
-         * {@link ErrorCategory.systemCategory ErrorCategory.systemCategory()} (indicating no error). </p>
-         */
-        clear(): void;
-        /**
-         * <p> Get category. </p>
-         *
-         * <p> Returns a reference to the {@link ErrorCategory} associated with the {@link ErrorCode} object. </p>
-         *
-         * @return A reference to a non-copyable object of a type derived from {@link ErrorCategory}.
-         */
-        category(): ErrorCategory;
-        /**
-         * <p> Error value. </p>
-         *
-         * <p> Returns the error value associated with the {@link ErrorCode} object. </p>
-         *
-         * @return The error value.
-         */
-        value(): number;
-        /**
-         * <p> Get message. </p>
-         *
-         * <p> Returns the message associated with the error instance. </p>
-         *
-         * <p> Error messages are defined by the {@link category} the error instance belongs to. </p>
-         *
-         * <p> This function returns the same as if the following member was called: </p>
-         *
-         * <p> <code>category().message(value())</code> </p>
-         *
-         * @return A string object with the message associated with the {@link ErrorCode}.
-         */
-        message(): string;
-        /**
-         * <p> Default error condition. </p>
-         *
-         * <p> Returns the default {@link ErrorCondition}object associated with the {@link ErrorCode} object. </p>
-         *
-         * <p> This function returns the same as if the following member was called: </p>
-         *
-         * <p> <code>category().default_error_condition(value())</code> </p>
-         *
-         * <p> {@link ErrorCategory.default_error_condition ErrorCategory.default_error_condition()}
-         * is a virtual member function, that can operate differently for each category. </p>
-         *
-         * @return An {@link ErrorCondition}object that corresponds to the {@link ErrorCode} object.
-         */
-        default_error_condition(): ErrorCondition;
-        /**
-         * <p> Convert to bool. </p>
-         *
-         * <p> Returns whether the error instance has a numerical {@link value} other than 0. </p>
-         *
-         * <p> If it is zero (which is generally used to represent no error), the function returns false, otherwise it returns true. </p>
-         *
-         * @return <code>true</code> if the error's numerical value is not zero.
-         *		   <code>false</code> otherwise.
-         */
-        to_bool(): boolean;
-    }
-}
-declare namespace std.base {
-    enum Hash {
-        MIN_SIZE = 10,
-        RATIO = 1,
-        MAX_RATIO = 2,
-    }
-    /**
-     * <p> Hask buckets. </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class HashBuckets<T> {
-        /**
-         * @hidden
-         */
-        private buckets_;
-        /**
-         * @hidden
-         */
-        private item_size_;
-        /**
-         * Default Constructor.
-         */
-        protected constructor();
-        /**
-         * <p> Reconstruction of hash table. </p>
-         *
-         * <p> All the elements in the hash buckets are rearranged according to their hash value into the new set of
-         * buckets. This may alter the order of iteration of elements within the container. </p>
-         *
-         * <p> Notice that {@link rehash rehashes} are automatically performed whenever its number of elements is going
-         * to greater than its own {@link capacity}. </p>
-         *
-         * @param size Number of bucket size to rehash.
-         */
-        rehash(size: number): void;
-        clear(): void;
-        size(): number;
-        item_size(): number;
-        capacity(): number;
-        at(index: number): Vector<T>;
-        hash_index(val: T): number;
-        insert(val: T): void;
-        erase(val: T): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> Common interface for hash map. </p>
-     *
-     * <p> {@link IHashMap}s are associative containers that store elements formed by the combination of
-     * a <i>key value</i> and a <i>mapped value</i>. </p>
-     *
-     * <p> In an {@link IHashMap}, the <i>key value</i> is generally used to uniquely identify the
-     * element, while the <i>mapped value</i> is an object with the content associated to this <i>key</i>.
-     * Types of <i>key</i> and <i>mapped value</i> may differ. </p>
-     *
-     * <p> Internally, the elements in the {@link IHashMap} are not sorted in any particular order with
-     * respect to either their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on
-     * their hash values to allow for fast access to individual elements directly by their <i>key values</i>
-     * (with a constant average time complexity on average). </p>
-     *
-     * <p> Elements with equivalent <i>keys</i> are grouped together in the same bucket and in such a way that
-     * an iterator can iterate through all of them. Iterators in the container are doubly linked iterators. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the key values.
-     *				Each element in an {@link IHashMap} is identified by a key value.
-     * @param <T> Type of the mapped value.
-     *			  Each element in an {@link IHashMap} is used to store some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_map
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IHashMap<Key, T> {
-        /**
-         * <p> Return iterator to beginning. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the {@link IHashMap}. </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which specific element is considered its
-         * first element. But, in any case, the range that goes from its begin to its end covers all the elements in the
-         * container, until invalidated. </p>
-         *
-         * @return An iterator to the first element in the container.
-         */
-        begin(): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to beginning. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in one of buckets in the {@link IHashMap}. </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which specific element is considered its
-         * first element. But, in any case, the range that goes from its begin to its end covers all the elements in the
-         * bucket, until invalidated. </p>
-         *
-         * @param index Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return An iterator to the first element in the bucket.
-         */
-        begin(index: number): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to end. </p>
-         *
-         * <p> Returns an iterator pointing to the past-the-end element in the {@link HaspMap} container. </p>
-         *
-         * <p> The iterator returned by end does not point to any element, but to the position that follows the last
-         * element in the {@link HaspMap} container (its <i>past-the-end</i> position). Thus, the value returned shall
-         * not be dereferenced - it is generally used to describe the open-end of a range, such as
-         * [<i>begin</i>, <i>end</i>). </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which order its elements follow. But, in any
-         * case, the range that goes from its begin to its end covers all the elements in the container (or the bucket),
-         * until invalidated. </p>
-         *
-         * @return An iterator to the element past the end of the container.
-         */
-        end(): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to end. </p>
-         *
-         * <p> Returns an iterator pointing to the past-the-end element in the {@link HaspMap} container. </p>
-         *
-         * <p> The iterator returned by end does not point to any element, but to the position that follows the last
-         * element in the {@link HaspMap} container (its <i>past-the-end</i> position). Thus, the value returned shall
-         * not be dereferenced - it is generally used to describe the open-end of a range, such as
-         * [<i>begin</i>, <i>end</i>). </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which order its elements follow. But, in any
-         * case, the range that goes from its begin to its end covers all the elements in the container (or the bucket),
-         * until invalidated. </p>
-         *
-         * @param index Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return An iterator to the element past the end of the bucket.
-         */
-        end(index: number): MapIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse beginning</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the last element in the {@link IHashMap}
-         * (i.e., its <i>reverse beginning</i>). </p>
-         *
-         * {@link MapReverseIterator Reverse iterators} iterate backwards: increasing them moves them towards the
-         * beginning of the container. </p>
-         *
-         * <p> {@link rbegin} points to the element preceding the one that would be pointed to by member {@link end}. </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which specific element is considered its
-         * first element. But, in any case, the range that goes from its begin to its end covers all the elements in the
-         * bucket, until invalidated. </p>
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
-         */
-        rbegin(): MapReverseIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse beginning</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the last element in one of buckets in the
-         * {@link IHashMap} (i.e., its <i>reverse beginning</i>). </p>
-         *
-         * {@link MapReverseIterator Reverse iterators} iterate backwards: increasing them moves them towards the
-         * beginning of the container. </p>
-         *
-         * <p> {@link rbegin} points to the element preceding the one that would be pointed to by member {@link end}. </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which specific element is considered its
-         * first element. But, in any case, the range that goes from its begin to its end covers all the elements in the
-         * bucket, until invalidated. </p>
-         *
-         * @param index Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
-         */
-        rbegin(index: number): MapReverseIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse end</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the theoretical element right before
-         * the first element in the {@link IHashMap hash map container} (which is considered its <i>reverse end</i>). </p>
-         *
-         * <p> The range between {@link IHashMap}.{@link rbegin} and {@link IHashMap}.{@link rend} contains all the
-         * elements of the container (in reverse order). </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which order its elements follow. But, in any
-         * case, the range that goes from its begin to its end covers all the elements in the container (or the bucket),
-         * until invalidated. </p>
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence.
-         */
-        rend(): MapReverseIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse end</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the theoretical element right before
-         * the first element in one of buckets in the {@link IHashMap hash map container} (which is considered its
-         * <i>reverse end</i>). </p>
-         *
-         * <p> The range between {@link IHashMap}.{@link rbegin} and {@link IHashMap}.{@link rend} contains all the
-         * elements of the container (in reverse order). </p>
-         *
-         * <p> Notice that an {@link IHashMap} object makes no guarantees on which order its elements follow. But, in any
-         * case, the range that goes from its begin to its end covers all the elements in the container (or the bucket),
-         * until invalidated. </p>
-         *
-         * @param index Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence.
-         */
-        rend(index: number): MapReverseIterator<Key, T>;
-        /**
-         * <p> Return number of buckets. </p>
-         *
-         * <p> Returns the number of buckets in the {@link IHashMap} container. </p>
-         *
-         * <p> A bucket is a slot in the container's internal hash table to which elements are assigned based on the
-         * hash value of their key. </p>
-         *
-         * <p> The number of buckets influences directly the {@link load_factor load factor} of the container's hash
-         * table (and thus the probability of collision). The container automatically increases the number of buckets to
-         * keep the load factor below a specific threshold (its {@link max_load_factor}), causing a {@link rehash} each
-         * time the number of buckets needs to be increased. </p>
-         *
-         * @return The current amount of buckets.
-         */
-        bucket_count(): number;
-        /**
-         * <p> Return bucket size. </p>
-         *
-         * <p> Returns the number of elements in bucket <i>n</i>. </p>
-         *
-         * <p> A bucket is a slot in the container's internal hash table to which elements are assigned based on the hash
-         * value of their key. </p>
-         *
-         * <p> The number of elements in a bucket influences the time it takes to access a particular element in the
-         * bucket. The container automatically increases the number of buckets to keep the {@link load_cator load factor}
-         * (which is the average bucket size) below its {@link max_load_factor}. </p>
-         *
-         * @param n Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return The number of elements in bucket <i>n</i>.
-         */
-        bucket_size(n: number): number;
-        /**
-         * <p> Get maximum load factor. </p>
-         *
-         * <p> Returns the current maximum load factor for the {@link HashMultiMap} container. </p>
-         *
-         * <p> The load factor is the ratio between the number of elements in the container (its {@link size}) and the
-         * number of buckets ({@link bucket_count}). </p>
-         *
-         * <p> By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0. </p>
-         *
-         * <p> The load factor influences the probability of collision in the hash table (i.e., the probability of two
-         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
-         * that forces an increase in the number of buckets (and thus causing a {@link rehash}). </p>
-         *
-         * <p> Note though, that implementations may impose an upper limit on the number of buckets (see
-         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}. </p>
-         *
-         * @return The current load factor.
-         */
-        max_load_factor(): number;
-        /**
-         * <p> Set maximum load factor. </p>
-         *
-         * <p> Sets <i>z</i> as the cnew maximum load factor for the {@link HashMultiMap} container. </p>
-         *
-         * <p> The load factor is the ratio between the number of elements in the container (its {@link size}) and the
-         * number of buckets ({@link bucket_count}). </p>
-         *
-         * <p> By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0. </p>
-         *
-         * <p> The load factor influences the probability of collision in the hash table (i.e., the probability of two
-         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
-         * that forces an increase in the number of buckets (and thus causing a {@link rehash}). </p>
-         *
-         * <p> Note though, that implementations may impose an upper limit on the number of buckets (see
-         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}. </p>
-         *
-         * @param z The new maximum load factor.
-         */
-        max_load_factor(z: number): void;
-        /**
-         * <p> Locate element's bucket. </p>
-         *
-         * <p> Returns the bucket number where the element with <i>key</i> is located. </p>
-         *
-         * <p> A bucket is a slot in the container's internal hash table to which elements are assigned based on the
-         * hash value of their <i>key</i>. Buckets are numbered from 0 to ({@link bucket_count} - 1). </p>
-         *
-         * <p> Individual elements in a bucket can be accessed by means of the range iterators returned by
-         * {@link begin} and {@link end}. </p>
-         *
-         * @param key Key whose bucket is to be located.
-         */
-        bucket(key: Key): number;
-        /**
-         * <p> Request a capacity change. </p>
-         *
-         * <p> Sets the number of buckets in the container ({@link bucket_count}) to the most appropriate to contain at
-         * least <i>n</i> elements. </p>
-         *
-         * <p> If <i>n</i> is greater than the current {@link bucket_count} multiplied by the {@link max_load_factor},
-         * the container's {@link bucket_count} is increased and a {@link rehash} is forced. </p>
-         *
-         * <p> If <i>n</i> is lower than that, the function may have no effect. </p>
-         *
-         * @param n The number of elements requested as minimum capacity.
-         */
-        reserve(n: number): void;
-        /**
-         * <p> Set number of buckets. </p>
-         *
-         * <p> Sets the number of buckets in the container to <i>n</i> or more. </p>
-         *
-         * <p> If <i>n</i> is greater than the current number of buckets in the container ({@link bucket_count}), a
-         * {@link HashBuckets.rehash rehash} is forced. The new {@link bucket_count bucket count} can either be equal or
-         * greater than <i>n</i>. </p>
-         *
-         * <p> If <i>n</i> is lower than the current number of buckets in the container ({@link bucket_count}), the
-         * function may have no effect on the {@link bucket_count bucket count} and may not force a
-         * {@link HashBuckets.rehash rehash}. </p>
-         *
-         * <p> A {@link HashBuckets.rehash rehash} is the reconstruction of the hash table: All the elements in the
-         * container are rearranged according to their hash value into the new set of buckets. This may alter the order
-         * of iteration of elements within the container. </p>
-         *
-         * <p> {@link HashBuckets.rehash Rehashes} are automatically performed by the container whenever its
-         * {@link load_factor load factor} is going to surpass its {@link max_load_factor} in an operation. </p>
-         *
-         * <p> Notice that this function expects the number of buckets as argument. A similar function exists,
-         * {@link reserve}, that expects the number of elements in the container as argument. </p>
-         *
-         * @param n The minimum number of buckets for the container hash table.
-         */
-        rehash(n: number): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> Hash buckets storing {@link MapIterator MapIterators}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MapHashBuckets<K, T> extends HashBuckets<MapIterator<K, T>> {
-        private map;
-        constructor(map: MapContainer<K, T>);
-        find(key: K): MapIterator<K, T>;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> A common interface for hash set. </p>
-     *
-     * <p> {@link IHashSet}s are containers that store unique elements in no particular order, and which
-     * allow for fast retrieval of individual elements based on their value. </p>
-     *
-     * <p> In an {@link IHashSet}, the value of an element is at the same time its <i>key</i>, that
-     * identifies it uniquely. Keys are immutable, therefore, the elements in an {@link IHashSet} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> Internally, the elements in the {@link IHashSet} are not sorted in any particular order, but
-     * organized into buckets depending on their hash values to allow for fast access to individual elements
-     * directly by their <i>values</i> (with a constant average time complexity on average). </p>
-     *
-     * <p> {@link IHashSet} containers are faster than {@link TreeSet} containers to access individual
-     * elements by their <i>key</i>, although they are generally less efficient for range iteration through a
-     * subset of their elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *			  Each element in an {@link IHashSet} is also uniquely identified by this value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IHashSet<T> {
-        /**
-         * <p> Return iterator to beginning. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the {@link IHashSet}. </p>
-         *
-         * <p> Notice that an {@link IHashSet} object makes no guarantees on which specific element is considered its
-         * first element. But, in any case, the range that goes from its begin to its end covers all the elements in the
-         * container, until invalidated. </p>
-         *
-         * @return An iterator to the first element in the container.
-         */
-        begin(): SetIterator<T>;
-        /**
-         * <p> Return iterator to beginning. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in one of buckets in the {@link IHashSet}. </p>
-         *
-         * <p> Notice that an {@link IHashSet} object makes no guarantees on which specific element is considered its
-         * first element. But, in any case, the range that goes from its begin to its end covers all the elements in the
-         * bucket, until invalidated. </p>
-         *
-         * @param index Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return An iterator to the first element in the bucket.
-         */
-        begin(index: number): SetIterator<T>;
-        /**
-         * <p> Return iterator to end. </p>
-         *
-         * <p> Returns an iterator pointing to the past-the-end element in the {@link HaspMap} container. </p>
-         *
-         * <p> The iterator returned by end does not point to any element, but to the position that follows the last
-         * element in the {@link HaspMap} container (its <i>past-the-end</i> position). Thus, the value returned shall
-         * not be dereferenced - it is generally used to describe the open-end of a range, such as
-         * [<i>begin</i>, <i>end</i>). </p>
-         *
-         * <p> Notice that an {@link IHashSet} object makes no guarantees on which order its elements follow. But, in any
-         * case, the range that goes from its begin to its end covers all the elements in the container (or the bucket),
-         * until invalidated. </p>
-         *
-         * @return An iterator to the element past the end of the container.
-         */
-        end(): SetIterator<T>;
-        /**
-         * <p> Return iterator to end. </p>
-         *
-         * <p> Returns an iterator pointing to the past-the-end element in the {@link HaspMap} container. </p>
-         *
-         * <p> The iterator returned by end does not point to any element, but to the position that follows the last
-         * element in the {@link HaspMap} container (its <i>past-the-end</i> position). Thus, the value returned shall
-         * not be dereferenced - it is generally used to describe the open-end of a range, such as
-         * [<i>begin</i>, <i>end</i>). </p>
-         *
-         * <p> Notice that an {@link IHashSet} object makes no guarantees on which order its elements follow. But, in any
-         * case, the range that goes from its begin to its end covers all the elements in the container (or the bucket),
-         * until invalidated. </p>
-         *
-         * @param index Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return An iterator to the element past the end of the bucket.
-         */
-        end(index: number): SetIterator<T>;
-        rbegin(): SetReverseIterator<T>;
-        rbegin(index: number): SetReverseIterator<T>;
-        rend(): SetReverseIterator<T>;
-        rend(index: number): SetReverseIterator<T>;
-        /**
-         * <p> Return number of buckets. </p>
-         *
-         * <p> Returns the number of buckets in the {@link IHashSet} container. </p>
-         *
-         * <p> A bucket is a slot in the container's internal hash table to which elements are assigned based on the
-         * hash value of their key. </p>
-         *
-         * <p> The number of buckets influences directly the {@link load_factor load factor} of the container's hash
-         * table (and thus the probability of collision). The container automatically increases the number of buckets to
-         * keep the load factor below a specific threshold (its {@link max_load_factor}), causing a {@link rehash} each
-         * time the number of buckets needs to be increased. </p>
-         *
-         * @return The current amount of buckets.
-         */
-        bucket_count(): number;
-        /**
-         * <p> Return bucket size. </p>
-         *
-         * <p> Returns the number of elements in bucket <i>n</i>. </p>
-         *
-         * <p> A bucket is a slot in the container's internal hash table to which elements are assigned based on the hash
-         * value of their key. </p>
-         *
-         * <p> The number of elements in a bucket influences the time it takes to access a particular element in the
-         * bucket. The container automatically increases the number of buckets to keep the {@link load_cator load factor}
-         * (which is the average bucket size) below its {@link max_load_factor}. </p>
-         *
-         * @param n Bucket number. This shall be lower than {@link bucket_count}.
-         *
-         * @return The number of elements in bucket <i>n</i>.
-         */
-        bucket_size(n: number): number;
-        /**
-         * <p> Get maximum load factor. </p>
-         *
-         * <p> Returns the current maximum load factor for the {@link HashMultiMap} container. </p>
-         *
-         * <p> The load factor is the ratio between the number of elements in the container (its {@link size}) and the
-         * number of buckets ({@link bucket_count}). </p>
-         *
-         * <p> By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0. </p>
-         *
-         * <p> The load factor influences the probability of collision in the hash table (i.e., the probability of two
-         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
-         * that forces an increase in the number of buckets (and thus causing a {@link rehash}). </p>
-         *
-         * <p> Note though, that implementations may impose an upper limit on the number of buckets (see
-         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}. </p>
-         *
-         * @return The current load factor.
-         */
-        max_load_factor(): number;
-        /**
-         * <p> Set maximum load factor. </p>
-         *
-         * <p> Sets <i>z</i> as the cnew maximum load factor for the {@link HashMultiMap} container. </p>
-         *
-         * <p> The load factor is the ratio between the number of elements in the container (its {@link size}) and the
-         * number of buckets ({@link bucket_count}). </p>
-         *
-         * <p> By default, {@link HashMultiMap} containers have a {@link max_load_factor} of 1.0. </p>
-         *
-         * <p> The load factor influences the probability of collision in the hash table (i.e., the probability of two
-         * elements being located in the same bucket). The container uses the value of max_load_factor as the threshold
-         * that forces an increase in the number of buckets (and thus causing a {@link rehash}). </p>
-         *
-         * <p> Note though, that implementations may impose an upper limit on the number of buckets (see
-         * {@link max_bucket_count}), which may force the container to ignore the {@link max_load_factor}. </p>
-         *
-         * @param z The new maximum load factor.
-         */
-        max_load_factor(z: number): void;
-        /**
-         * <p> Locate element's bucket. </p>
-         *
-         * <p> Returns the bucket number where the element with <i>key</i> is located. </p>
-         *
-         * <p> A bucket is a slot in the container's internal hash table to which elements are assigned based on the
-         * hash value of their <i>key</i>. Buckets are numbered from 0 to ({@link bucket_count} - 1). </p>
-         *
-         * <p> Individual elements in a bucket can be accessed by means of the range iterators returned by
-         * {@link begin} and {@link end}. </p>
-         *
-         * @param key Key whose bucket is to be located.
-         */
-        bucket(key: T): number;
-        /**
-         * <p> Request a capacity change. </p>
-         *
-         * <p> Sets the number of buckets in the container ({@link bucket_count}) to the most appropriate to contain at
-         * least <i>n</i> elements. </p>
-         *
-         * <p> If <i>n</i> is greater than the current {@link bucket_count} multiplied by the {@link max_load_factor},
-         * the container's {@link bucket_count} is increased and a {@link rehash} is forced. </p>
-         *
-         * <p> If <i>n</i> is lower than that, the function may have no effect. </p>
-         *
-         * @param n The number of elements requested as minimum capacity.
-         */
-        reserve(n: number): void;
-        /**
-         * <p> Set number of buckets. </p>
-         *
-         * <p> Sets the number of buckets in the container to <i>n</i> or more. </p>
-         *
-         * <p> If <i>n</i> is greater than the current number of buckets in the container ({@link bucket_count}), a
-         * {@link HashBuckets.rehash rehash} is forced. The new {@link bucket_count bucket count} can either be equal or
-         * greater than <i>n</i>. </p>
-         *
-         * <p> If <i>n</i> is lower than the current number of buckets in the container ({@link bucket_count}), the
-         * function may have no effect on the {@link bucket_count bucket count} and may not force a
-         * {@link HashBuckets.rehash rehash}. </p>
-         *
-         * <p> A {@link HashBuckets.rehash rehash} is the reconstruction of the hash table: All the elements in the
-         * container are rearranged according to their hash value into the new set of buckets. This may alter the order
-         * of iteration of elements within the container. </p>
-         *
-         * <p> {@link HashBuckets.rehash Rehashes} are automatically performed by the container whenever its
-         * {@link load_factor load factor} is going to surpass its {@link max_load_factor} in an operation. </p>
-         *
-         * <p> Notice that this function expects the number of buckets as argument. A similar function exists,
-         * {@link reserve}, that expects the number of elements in the container as argument. </p>
-         *
-         * @param n The minimum number of buckets for the container hash table.
-         */
-        rehash(n: number): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> Hash buckets storing {@link SetIterator SetIterators}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SetHashBuckets<T> extends HashBuckets<SetIterator<T>> {
-        private set;
-        constructor(set: SetContainer<T>);
-        find(val: T): SetIterator<T>;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> Array  </p>
-     *
-     * <p> {@link IArray} is an interface for sequence containers representing <i>arrays</i> that can change in
-     * {@link size}. However, compared to <i>arrays</i>, {@link IArray} objectss consume more memory in exchange for
-     * the ability to manage storage and grow dynamically in an efficient way. </p> </p>
-     *
-     * <p> Both {@link Vector Vectors} and {@link Deque Deques} who implemented {@link IArray} provide a very
-     * similar interface and can be used for similar purposes, but internally both work in quite different ways:
-     * While {@link Vector Vectors} use a single array that needs to be occasionally reallocated for growth, the
-     * elements of a {@link Deque} can be scattered in different chunks of storage, with the container keeping the
-     * necessary information internally to provide direct access to any of its elements in constant time and with a
-     * uniform sequential interface (through iterators). Therefore, {@link Deque Deques} are a little more complex
-     * internally than {@link Vector Vectors}, but this allows them to grow more efficiently under certain
-     * circumstances, especially with very long sequences, where reallocations become more expensive. </p>
-     *
-     * <p> Both {@link Vector Vectors} and {@link Deque Deques} provide a very similar interface and can be used for
-     * similar purposes, but internally both work in quite different ways: While {@link Vector Vectors} use a single
-     * array that needs to be occasionally reallocated for growth, the elements of a {@link Deque} can be scattered
-     * in different chunks of storage, with the container keeping the necessary information internally to provide
-     * direct access to any of its elements in constant time and with a uniform sequential interface (through
-     * iterators). Therefore, {@link Deque Deques} are a little more complex internally than {@link Vector Vectors},
-     * but this allows them to grow more efficiently under certain circumstances, especially with very long
-     * sequences, where reallocations become more expensive. </p>
-     *
-     * <p> For operations that involve frequent insertion or removals of elements at positions other than the
-     * beginning or the end, {@link IArray} objects perform worse and have less consistent iterators and references
-     * than {@link List Lists} </p>.
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Sequence </dt>
-     *	<dd>
-     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
-     *		accessed by their position in this sequence.
-     *	</dd>
-     *
-     *	<dt> Dynamic array </dt>
-     *	<dd>
-     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
-     *		relatively fast addition/removal of elements at the end of the sequence.
-     *	</dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IArrayContainer<T> extends ILinearContainer<T> {
-        /**
-         * <p> Request a change in capacity. </p>
-         *
-         * <p> Requests that the {@link IArray container} {@link capacity} be at least enough to contain
-         * <i>n</i> elements. </p>
-         *
-         * <p> If <i>n</i> is greater than the current {@link IArray container} {@link capacity}, the
-         * function causes the {@link IArray container} to reallocate its storage increasing its
-         * {@link capacity} to <i>n</i> (or greater). </p>
-         *
-         * <p> In all other cases, the function call does not cause a reallocation and the
-         * {@link IArray container} {@link capacity} is not affected. </p>
-         *
-         * <p> This function has no effect on the {@link IArray container} {@link size} and cannot alter
-         * its elements. </p>
-         *
-         * @param n Minimum {@link capacity} for the {@link IArray container}.
-         *			Note that the resulting {@link capacity} may be equal or greater than <i>n</i>.
-         */
-        reserve(n: number): void;
-        /**
-         * <p> Return size of allocated storage capacity. </p>
-         *
-         * <p> Returns the size of the storage space currently allocated for the {@link IArray container},
-         * expressed in terms of elements. </p>
-         *
-         * <p> This {@link capacity} is not necessarily equal to the {@link IArray container} {@link size}.
-         * It can be equal or greater, with the extra space allowing to accommodate for growth without the
-         * need to reallocate on each insertion. </p>
-         *
-         * <p> Notice that this {@link capacity} does not suppose a limit on the {@link size} of the
-         * {@link IArray container}. When this {@link capacity} is exhausted and more is needed, it is
-         * automatically expanded by the {@link IArray container} (reallocating it storage space).
-         * The theoretical limit on the {@link size} of a {@link IArray container} is given by member
-         * {@link max_size}. </p>
-         *
-         * <p> The {@link capacity} of a {@link IArray container} can be explicitly altered by calling member
-         * {@link IArray.reserve}. </p>
-         *
-         * @return The size of the currently allocated storage capacity in the {@link IArray container},
-         *		   measured in terms of the number elements it can hold.
-         */
-        capacity(): number;
-        /**
-         * <p> Access element. </p>
-         * <p> Returns a value to the element at position <i>index</i> in the {@link IArray container}.</p>
-         *
-         * <p> The function automatically checks whether <i>index</i> is within the bounds of valid elements
-         * in the {@link IArray container}, throwing an {@link OutOfRange} exception if it is not (i.e.,
-         * if <i>index</i> is greater or equal than its {@link size}). </p>
-         *
-         * @param index Position of an element in the
-         *				If this is greater than or equal to the {@link IArray container} {@link size}, an
-         *				exception of type {@link OutOfRange} is thrown. Notice that the first
-         *				element has a position of 0 (not 1).
-         *
-         * @return The element at the specified position in the
-         */
-        at(index: number): T;
-        /**
-         * <p> Modify element. </p>
-         * <p> Replaces an element at the specified position (<i>index</i>) in this {@link IArray container}
-         * with the specified element (<i>val</i>). </p>
-         *
-         * <p> The function automatically checks whether <i>index</i> is within the bounds of valid elements
-         * in the {@link IArray container}, throwing an {@link OutOfRange} exception if it is not (i.e., if
-         * <i>index</i> is greater or equal than its {@link size}). </p>
-         *
-         * @.param index A specified position of the value to replace.
-         * @param val A value to be stored at the specified position.
-         *
-         * @return The previous element had stored at the specified position.
-         */
-        set(index: number, val: T): void;
-    }
-    /**
-     * <p> Random-access iterator. </p>
-     *
-     * <p> {@link IArrayIterator Random-access iterators} are iterators that can be used to access elements at an
-     * arbitrary offset position relative to the element they point to, offering the same functionality as pointers.
-     * </p>
-     *
-     * <p> {@link IArrayIterator Random-access iterators} are the most complete iterators in terms of functionality.
-     * All pointer types are also valid {@link IArrayIterator random-access iterators}. </p>
-     *
-     * <p> There is not a single type of {@link IArrayIterator random-access iterator}: Each container may define its
-     * own specific iterator type able to iterate through it and access its elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/iterator/RandomAccessIterator
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IArrayIterator<T> extends ILinearIterator<T> {
-        /**
-         * Get index, sequence number of the iterator in the source {@link IArray array}.
-         *
-         * @return Sequence number of the iterator in the source {@link IArray array}.
-         */
-        index: number;
-        /**
-         * @inheritdoc
-         */
-        prev(): IArrayIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): IArrayIterator<T>;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An interface of containers. </p>
-     *
-     * <p> {@link IContainer} is an interface designed for sequence containers. Sequence containers of STL
-     * (Standard Template Library) are based on the {@link IContainer}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" />
-     * </a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Sequence </dt>
-     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
-     *		 accessed by their position in this sequence. </dd>
-     *
-     * 	<dt> Doubly-linked list </dt>
-     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing
-     *		 constant time insert and erase operations before or after a specific element (even of entire ranges),
-     *		 but no direct random access. </dd>
-     * </dl>
-     *
-     * @param <T> Type of elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IContainer<T> {
-        /**
-         * <p> Assign new content to content. </p>
-         *
-         * <p> Assigns new contents to the container, replacing its current contents, and modifying its
-         * {@link size} accordingly. </p>
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * <p> Clear content. </p>
-         *
-         * <p> Removes all elements from the Container, leaving the container with a size of 0. </p>
-         */
-        clear(): void;
-        /**
-         * <p> Return iterator to beginning. </p>
-         *
-         * <p> Returns an iterator referring the first element in the  </p>
-         *
-         * <h4> Note </h4>
-         * <p> If the container is {@link empty}, the returned iterator is same with {@link end end()}. </p>
-         *
-         * @return An iterator to the first element in the  The iterator containes the first element's value.
-         */
-        begin(): Iterator<T>;
-        /**
-         * <p> Return iterator to end. </p>
-         * <p> Returns an iterator referring to the past-the-end element in the  </p>
-         *
-         * <p> The past-the-end element is the theoretical element that would follow the last element in the
-         * It does not point to any element, and thus shall not be dereferenced. </p>
-         *
-         * <p> Because the ranges used by functions of the Container do not include the element reference by their
-         * closing iterator, this function is often used in combination with {@link IContainer}.{@link begin} to
-         * specify a range including all the elements in the container. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Returned iterator from {@link IContainer}.{@link end} does not refer any element. Trying to accessing
-         * element by the iterator will cause throwing exception ({@link OutOfRange}). </p>
-         *
-         * <p> If the container is {@link empty}, this function returns the same as {@link Container}.{@link begin}.
-         * </p>
-         *
-         * @return An iterator to the end element in the
-         */
-        end(): Iterator<T>;
-        /**
-         * <p> Return {@link ReverseIterator reverse iterator} to <i>reverse beginning</i>. </p>
-         *
-         * <p> Returns a {@link ReverseIterator reverse iterator} pointing to the last element in the container (i.e.,
-         * its <i>reverse beginning</i>). </p>
-         *
-         * <p> {@link ReverseIterator reverse iterators} iterate backwards: increasing them moves them towards the
-         * beginning of the  </p>
-         *
-         * <p> {@link rbegin} points to the element right before the one that would be pointed to by member {@link end}.
-         * </p>
-         *
-         * @return A {@link ReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
-         */
-        rbegin(): base.IReverseIterator<T>;
-        /**
-         * <p> Return {@link ReverseIterator reverse iterator} to <i>reverse end</i>. </p>
-         *
-         * <p> Returns a {@link ReverseIterator reverse iterator} pointing to the theoretical element preceding the
-         * first element in the container (which is considered its <i>reverse end</i>). </p>
-         *
-         * <p> The range between {@link IContainer}.{@link rbegin} and {@link IContainer}.{@link rend} contains all
-         * the elements of the container (in reverse order).
-         *
-         * @return A {@link ReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence
-         */
-        rend(): base.IReverseIterator<T>;
-        /**
-         * Return the number of elements in the Container.
-         *
-         * @return The number of elements in the
-         */
-        size(): number;
-        /**
-         * <p> Test whether the container is empty. </p>
-         * <p> Returns whether the container is empty (i.e. whether its size is 0). </p>
-         *
-         * <p> This function does not modify the container in any way. To clear the content of the container,
-         * see {@link clear clear()}. </p>
-         *
-         * @return <code>true</code> if the container size is 0, <code>false</code> otherwise.
-         */
-        empty(): boolean;
-        /**
-         * <p> Insert elements. </p>
-         *
-         * <p> Appends new elements to the container, and returns the new size of the  </p>
-         *
-         * @param items New elements to insert.
-         *
-         * @return New size of the Container.
-         */
-        push(...items: T[]): number;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link IContainer.size container size} by the amount of
-         * elements inserted. </p>
-         *
-         * @param position Position in the {@link IContainer} where the new element is inserted.
-         *				   {@link iterator} is a member type, defined as a {@link Iterator random access iterator}
-         *				   type that points to elements.
-         * @param val Value to be copied to the inserted element.
-         *
-         * @return An iterator that points to the newly inserted element.
-         */
-        insert(position: Iterator<T>, val: T): Iterator<T>;
-        /**
-         * <p> Erase an element. </p>
-         *
-         * <p> Removes from the container a single element. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the Container.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function
-         *		   call. This is the {@link end Container.end} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(position: Iterator<T>): Iterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         *
-         * <p> Removes from the container a range of elements. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function
-         *		   call. This is the {@link end Container.end} if the operation erased the last element in
-         *		   the sequence.
-         */
-        erase(begin: Iterator<T>, end: Iterator<T>): Iterator<T>;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link IContainer container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link IContainer container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container IContainer}.
-         */
-        swap(obj: IContainer<T>): void;
-    }
-    interface IReverseIterator<T> extends ReverseIterator<T, Iterator<T>, IReverseIterator<T>> {
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An interface for deque  </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IDequeContainer<T> extends ILinearContainer<T> {
-        /**
-         * <p> Insert element at beginning. </p>
-         *
-         * <p> Inserts a new element at the beginning of the {@link IDeque container}, right before its
-         * current first element. This effectively increases the {@link IDeque container} {@link size} by
-         * one. </p>
-         *
-         * @param val Value to be inserted as an element.
-         */
-        push_front(val: T): void;
-        /**
-         * <p> Delete first element. </p>
-         *
-         * <p> Removes the first element in the {@link IDeque container}, effectively reducing its
-         * {@link size} by one. </p>
-         */
-        pop_front(): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An interface for linear containers.  </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @author Jeonngho Nam
-     */
-    interface ILinearContainer<T> extends IContainer<T> {
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * <p> Assign container content. </p>
-         *
-         * <p> Assigns new contents to the {@link IList container}, replacing its current contents,
-         * and modifying its {@link size} accordingly. </p>
-         *
-         * @param n New size for the
-         * @param val Value to fill the container with. Each of the <u>n</u> elements in the container will
-         *			  be initialized to a copy of this value.
-         */
-        assign(n: number, val: T): void;
-        /**
-         * <p> Access first element. </p>
-         * <p> Returns a value of the first element in the {@link IList container}. </p>
-         *
-         * <p> Unlike member {@link end end()}, which returns an iterator just past this element,
-         * this function returns a direct value. </p>
-         *
-         * <p> Calling this function on an {@link empty} {@link IList container} causes undefined behavior. </p>
-         *
-         * @return A value of the first element of the {@link IList container}.
-         */
-        front(): T;
-        /**
-         * <p> Access last element. </p>
-         * <p> Returns a value of the last element in the {@link IList container}. </p>
-         *
-         * <p> Unlike member {@link end end()}, which returns an iterator just past this element,
-         * this function returns a direct value. </p>
-         *
-         * <p> Calling this function on an {@link empty} {@link IList container} causes undefined behavior. </p>
-         *
-         * @return A value of the last element of the {@link IList container}.
-         */
-        back(): T;
-        /**
-         * <p> Add element at the end. </p>
-         *
-         * <p> Adds a new element at the end of the {@link IList container}, after its current last element.
-         * This effectively increases the {@link IList container} {@link size} by one. </p>
-         *
-         * @param val Value to be copied to the new element.
-         */
-        push_back(val: T): void;
-        /**
-         * <p> Delete last element. </p>
-         *
-         * <p> Removes the last element in the {@link IList container}, effectively reducing the
-         * {@link IList container} {@link size} by one. </p>
-         */
-        pop_back(): void;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The {@link IList conatiner} is extended by inserting new element before the element at the
-         * specified <i>position</i>, effectively increasing the {@link IList container} {@link size} by
-         * one. </p>
-         *
-         * @param position Position in the {@link IList container} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a {@link iterator random access iterator}
-         *				   type that points to elements.
-         * @param val Value to be copied to the inserted element.
-         *
-         * @return An iterator that points to the newly inserted element.
-         */
-        insert(position: Iterator<T>, val: T): Iterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The {@link IList container} is extended by inserting new elements before the element at the
-         * specified <i>position</i>, effectively increasing the {@link IList container} {@link size} by
-         * the number of repeating elements </i>n</i>. </p>
-         *
-         * @param position Position in the {@link IList container} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a {@link iterator random access iterator}
-         *				   type that points to elements.
-         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
-         * @param val Value to be copied (or moved) to the inserted elements.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: Iterator<T>, n: number, val: T): Iterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The {@link IList container} is extended by inserting new elements before the element at the
-         * specified <i>position</i>, effectively increasing the {@link IList container} {@link size} by
-         * the number of elements inserted by range iterators. </p>
-         *
-         * @param position Position in the {@link IList container} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a {@link iterator random access iterator}
-         *				   type that points to elements.
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: Iterator<T>, begin: InputIterator, end: InputIterator): Iterator<T>;
-    }
-    /**
-     * An interface for iterators from linear containers.
-     *
-     * {@link ILieanerIterator} is an bi-directional iterator which is created from the related
-     * {@link ILinearContainer linear containers}. Not only accessing to {@link value} of the pointed element from
-     * this {@link ILieanerIterator}, but also modifying the {@link value} is possible.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface ILinearIterator<T> extends Iterator<T> {
-        /**
-         * @inheritdoc
-         */
-        value: T;
-        /**
-         * @inheritdoc
-         */
-        prev(): ILinearIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): ILinearIterator<T>;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Bi-directional iterator. </p>
-     *
-     * <p> {@link Iterator Bidirectional iterators} are iterators that can be used to access the sequence of elements
-     * in a range in both directions (towards the end and towards the beginning). </p>
-     *
-     * <p> All {@link IArrayIterator random-access iterators} are also valid {@link Iterrator bidirectional iterators}.
-     * </p>
-     *
-     * <p> There is not a single type of {@link Iterator bidirectional iterator}: {@link IContainer Each container}
-     * may define its own specific iterator type able to iterate through it and access its elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @reference http://www.cplusplus.com/reference/iterator/BidirectionalIterator
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Iterator<T> {
-        /**
-         * Source container of the iterator is directing for.
-         */
-        protected source_: base.IContainer<T>;
-        /**
-         * Construct from the source {@link IContainer container}.
-         *
-         * @param source The source container.
-         */
-        protected constructor(source: base.IContainer<T>);
-        /**
-         * <p> Get iterator to previous element. </p>
-         * <p> If current iterator is the first item(equal with {@link IContainer.begin IContainer.begin()}),
-         * returns {@link IContainer.end IContainer.end()}. </p>
-         *
-         * @return An iterator of the previous item.
-         */
-        abstract prev(): Iterator<T>;
-        /**
-         * <p> Get iterator to next element. </p>
-         * <p> If current iterator is the last item, returns {@link IContainer.end IContainer.end()}. </p>
-         *
-         * @return An iterator of the next item.
-         */
-        abstract next(): Iterator<T>;
-        /**
-         * Advances the {@link Iterator} by <i>n</i> element positions.
-         *
-         * @param n Number of element positions to advance.
-         * @return An advanced iterator.
-         */
-        advance(n: number): Iterator<T>;
-        /**
-         * Get source
-         */
-        get_source(): base.IContainer<T>;
-        /**
-         * <p> Whether an iterator is equal with the iterator. </p>
-         *
-         * <p> Compare two iterators and returns whether they are equal or not. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Iterator's {@link equals equals()} only compare souce container and index number. </p>
-         *
-         * <p> Although elements in a pair, key and value are {@link std.equal_to equal_to}, if the source map or
-         * index number is different, then the {@link equals equals()} will return false. If you want to
-         * compare the elements of a pair, compare them directly by yourself. </p>
-         *
-         * @param obj An iterator to compare
-         * @return Indicates whether equal or not.
-         */
-        equals(obj: Iterator<T>): boolean;
-        /**
-         * <p> Get value of the iterator is pointing. </p>
-         *
-         * @return A value of the iterator.
-         */
-        readonly abstract value: T;
-        abstract swap(obj: Iterator<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> This class reverses the direction in which a bidirectional or random-access iterator iterates through a range.
-     * </p>
-     *
-     * <p> A copy of the original iterator (the {@link Iterator base iterator}) is kept internally and used to reflect
-     * the operations performed on the {@link ReverseIterator}: whenever the {@link ReverseIterator} is incremented, its
-     * {@link Iterator base iterator} is decreased, and vice versa. A copy of the {@link Iterator base iterator} with the
-     * current state can be obtained at any time by calling member {@link base}. </p>
-     *
-     * <p> Notice however that when an iterator is reversed, the reversed version does not point to the same element in
-     * the range, but to <b>the one preceding it</b>. This is so, in order to arrange for the past-the-end element of a
-     * range: An iterator pointing to a past-the-end element in a range, when reversed, is pointing to the last element
-     * (not past it) of the range (this would be the first element of the reversed range). And if an iterator to the
-     * first element in a range is reversed, the reversed iterator points to the element before the first element (this
-     * would be the past-the-end element of the reversed range). </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @reference http://www.cplusplus.com/reference/iterator/reverse_iterator
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ReverseIterator<T, Base extends Iterator<T>, This extends ReverseIterator<T, Base, This>> extends Iterator<T> {
-        /**
-         * @hidden
-         */
-        protected base_: Base;
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        protected constructor(base: Base);
-        /**
-         * <p> Return base iterator. </p>
-         *
-         * <p> Return a reference of the base iteraotr. </p>
-         *
-         * <p> The base iterator is an iterator of the same type as the one used to construct the {@link ReverseIterator},
-         * but pointing to the element next to the one the {@link ReverseIterator} is currently pointing to
-         * (a {@link ReverseIterator} has always an offset of -1 with respect to its base iterator).
-         *
-         * @return A reference of the base iterator, which iterates in the opposite direction.
-         */
-        base(): Base;
-        /**
-         * @hidden
-         */
-        protected abstract _Create_neighbor(base: Base): This;
-        /**
-         * <p> Get value of the iterator is pointing. </p>
-         *
-         * @return A value of the reverse iterator.
-         */
-        readonly value: T;
-        /**
-         * @inheritdoc
-         */
-        prev(): This;
-        /**
-         * @inheritdoc
-         */
-        next(): This;
-        /**
-         * @inheritdoc
-         */
-        advance(n: number): This;
-        /**
-         * @inheritdoc
-         */
-        equals(obj: This): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: This): void;
-    }
-    /**
-     * <p> Return distance between {@link Iterator iterators}. </p>
-     *
-     * <p> Calculates the number of elements between <i>first</i> and <i>last</i>. </p>
-     *
-     * <p> If it is a {@link IArrayIterator random-access iterator}, the function uses operator- to calculate this.
-     * Otherwise, the function uses the increase operator {@link Iterator.next next()} repeatedly. </p>
-     *
-     * @param first Iterator pointing to the initial element.
-     * @param last Iterator pointing to the final element. This must be reachable from first.
-     *
-     * @return The number of elements between first and last.
-     */
-    function distance<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): number;
-    /**
-     * <p> Advance iterator. </p>
-     *
-     * <p> Advances the iterator <i>it</i> by <i>n</i> elements positions. </p>
-     *
-     * @param it Iterator to be advanced.
-     * @param n Number of element positions to advance.
-     *
-     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
-     */
-    function advance<T, InputIterator extends Iterator<T>>(it: InputIterator, n: number): InputIterator;
-    /**
-     * <p> Get iterator to previous element. </p>
-     *
-     * <p> Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>-n</i> positions. </p>
-     *
-     * @param it Iterator to base position.
-     * @param n Number of element positions offset (1 by default).
-     *
-     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
-     */
-    function prev<T, BidirectionalIterator extends Iterator<T>>(it: BidirectionalIterator, n?: number): BidirectionalIterator;
-    /**
-     * <p> Get iterator to next element. </p>
-     *
-     * <p> Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>n</i> positions. </p>
-     *
-     * @param it Iterator to base position.
-     * @param n Number of element positions offset (1 by default).
-     *
-     * @return An iterator to the element <i>n</i> positions away from <i>it</i>.
-     */
-    function next<T, ForwardIterator extends Iterator<T>>(it: ForwardIterator, n?: number): ForwardIterator;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: Vector<T>): VectorIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: List<T>): ListIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: Deque<T>): DequeIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: base.SetContainer<T>): SetIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: Vector<T>): VectorIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: List<T>): ListIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: Deque<T>): DequeIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: base.SetContainer<T>): SetIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
-}
-declare namespace std.base {
-    /**
-     * An abstract list.
-     *
-     * <p> {@link ListContainer}s are sequence containers that allow constant time insert and erase operations anywhere
-     * within the sequence, and iteration in both directions. </p>
-     *
-     * <p> List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they
-     * contain in different and unrelated storage locations. The ordering is kept internally by the association to each
-     * element of a link to the element preceding it and a link to the element following it. </p>
-     *
-     * <p> Compared to other base standard sequence containers (array, vector and deque), lists perform generally better
-     * in inserting, extracting and moving elements in any position within the container for which an iterator has already
-     * been obtained, and therefore also in algorithms that make intensive use of these, like sorting algorithms. </p>
-     *
-     * <p> The main drawback of lists and forward_lists compared to these other sequence containers is that they lack
-     * direct access to the elements by their position; For example, to access the sixth element in a list, one has to
-     * iterate from a known position (like the beginning or the end) to that position, which takes linear time in the
-     * distance between these. They also consume some extra memory to keep the linking information associated to each
-     * element (which may be an important factor for large lists of small-sized elements). </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Sequence </dt>
-     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
-     *		 their position in this sequence. </dd>
-     *
-     * 	<dt> Doubly-linked list </dt>
-     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing constant time
-     *		 insert and erase operations before or after a specific element (even of entire ranges), but no direct random
-     *		 access. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/list/list/
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ListContainer<T, BidirectionalIterator extends ListIteratorBase<T>> extends Container<T> implements IDequeContainer<T> {
-        /**
-         * @hidden
-         */
-        private begin_;
-        /**
-         * @hidden
-         */
-        private end_;
-        /**
-         * @hidden
-         */
-        private size_;
-        /**
-         * Default Constructor.
-         */
-        protected constructor();
-        /**
-         * @hidden
-         */
-        protected abstract _Create_iterator(prev: BidirectionalIterator, next: BidirectionalIterator, val: T): BidirectionalIterator;
-        /**
-         * @hidden
-         */
-        protected _Set_begin(it: BidirectionalIterator): void;
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        begin(): BidirectionalIterator;
-        /**
-         * @inheritdoc
-         */
-        end(): BidirectionalIterator;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        front(): T;
-        /**
-         * @inheritdoc
-         */
-        back(): T;
-        /**
-         * @inheritdoc
-         */
-        push_front(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        pop_front(): void;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * @inheritdoc
-         */
-        push(...items: T[]): number;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new element is inserted.
-         *				   {@link iterator}> is a member type, defined as a
-         *				   {@link ListIterator bidirectional iterator} type that points to elements.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the newly inserted element; <i>val</i>.
-         */
-        insert(position: BidirectionalIterator, val: T): BidirectionalIterator;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param size Number of elements to insert.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: BidirectionalIterator, size: number, val: T): BidirectionalIterator;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param begin An iterator specifying range of the begining element.
-         * @param end An iterator specifying range of the ending element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: BidirectionalIterator, begin: InputIterator, end: InputIterator): BidirectionalIterator;
-        /**
-         * @hidden
-         */
-        private insert_by_val(position, val);
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: BidirectionalIterator, size: number, val: T): BidirectionalIterator;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(position: BidirectionalIterator, begin: InputIterator, end: InputIterator): BidirectionalIterator;
-        /**
-         * <p> Erase an element. </p>
-         *
-         * <p> Removes from the {@link List} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link List}.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
-         */
-        erase(position: BidirectionalIterator): BidirectionalIterator;
-        /**
-         * <p> Erase elements. </p>
-         *
-         * <p> Removes from the {@link List} container a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
-         */
-        erase(begin: BidirectionalIterator, end: BidirectionalIterator): BidirectionalIterator;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: BidirectionalIterator, last: BidirectionalIterator): BidirectionalIterator;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link List container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link List container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container List}.
-         */
-        swap(obj: ListContainer<T, BidirectionalIterator>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * An iterator, node of a List-based container.
-     *
-     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     *	<img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ListIteratorBase<T> extends Iterator<T> {
-        /**
-         * @hidden
-         */
-        private prev_;
-        /**
-         * @hidden
-         */
-        private next_;
-        /**
-         * @hidden
-         */
-        protected value_: T;
-        /**
-         * Initializer Constructor.
-         *
-         * @param source The source {@link Container} to reference.
-         * @param prev A refenrece of previous node ({@link ListIterator iterator}).
-         * @param next A refenrece of next node ({@link ListIterator iterator}).
-         * @param value Value to be stored in the node (iterator).
-         */
-        protected constructor(source: Container<T>, prev: ListIteratorBase<T>, next: ListIteratorBase<T>, value: T);
-        /**
-         * @inheritdoc
-         */
-        prev(): ListIteratorBase<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): ListIteratorBase<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(step: number): ListIteratorBase<T>;
-        /**
-         * @inheritdoc
-         */
-        readonly value: T;
-        /**
-         * @inheritdoc
-         */
-        equals(obj: ListIteratorBase<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: ListIteratorBase<T>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract map. </p>
-     *
-     * <p> {@link MapContainer MapContainers} are associative containers that store elements formed by a combination
-     * of a <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval
-     * of individual elements based on their keys. </p>
-     *
-     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
-     * <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
-     * {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> {@link MapContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
-     *		in the container.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class MapContainer<Key, T> extends Container<Pair<Key, T>> {
-        /**
-         * <p> {@link List} storing elements. </p>
-         *
-         * <p> Storing elements and keeping those sequence of the {@link MapContainer} are implemented by
-         * {@link data_ this list container}. Implementing index-table is also related with {@link data_ this list}
-         * by storing {@link ListIterator iterators} ({@link MapIterator} references {@link ListIterator}) who are
-         * created from {@link data_ here}. </p>
-         */
-        private data_;
-        /**
-         * Default Constructor.
-         */
-        protected constructor();
-        /**
-         * @inheritdoc
-         */
-        assign<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * <p> Get iterator to element. </p>
-         *
-         * <p> Searches the container for an element with a identifier equivalent to <i>key</i> and returns an
-         * iterator to it if found, otherwise it returns an iterator to {@link end end()}. </p>
-         *
-         * <p> Two keys are considered equivalent if the container's comparison object returns false reflexively
-         * (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * <p> Another member functions, {@link has has()} and {@link count count()}, can be used to just check
-         * whether a particular <i>key</i> exists. </p>
-         *
-         * @param key Key to be searched for
-         * @return An iterator to the element, if an element with specified <i>key</i> is found, or
-         *		   {@link end end()} otherwise.
-         */
-        abstract find(key: Key): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to beginning. </p>
-         *
-         * <p> Returns an iterator referring the first element in the  </p>
-         *
-         * <h4> Note </h4>
-         * <p> If the container is {@link empty}, the returned iterator is same with {@link end end()}. </p>
-         *
-         * @return An iterator to the first element in the  The iterator containes the first element's value.
-         */
-        begin(): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to end. </p>
-         * <p> Returns an iterator referring to the past-the-end element in the  </p>
-         *
-         * <p> The past-the-end element is the theoretical element that would follow the last element in the
-         *  It does not point to any element, and thus shall not be dereferenced. </p>
-         *
-         * <p> Because the ranges used by functions of the container do not include the element reference by their
-         * closing iterator, this function is often used in combination with {@link MapContainer}.{@link begin} to
-         * specify a range including all the elements in the  </p>
-         *
-         * <h4> Note </h4>
-         * <p> Returned iterator from {@link MapContainer}.{@link end} does not refer any element. Trying to accessing
-         * element by the iterator will cause throwing exception ({@link OutOfRange}). </p>
-         *
-         * <p> If the container is {@link empty}, this function returns the same as {@link begin}. </p>
-         *
-         * @return An iterator to the end element in the
-         */
-        end(): MapIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse beginning</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the last element in the container
-         * (i.e., its <i>reverse beginning</i>). </p>
-         *
-         * {@link MapReverseIterator Reverse iterators} iterate backwards: increasing them moves them towards the
-         * beginning of the container. </p>
-         *
-         * <p> {@link rbegin} points to the element preceding the one that would be pointed to by member {@link end}.
-         * </p>7
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
-         *
-         */
-        rbegin(): MapReverseIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse end</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the theoretical element right before
-         * the first element in the {@link MapContainer map container} (which is considered its <i>reverse end</i>).
-         * </p>
-         *
-         * <p> The range between {@link MapContainer}.{@link rbegin} and {@link MapContainer}.{@link rend} contains
-         * all the elements of the container (in reverse order). </p>
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence
-         */
-        rend(): MapReverseIterator<Key, T>;
-        /**
-         * <p> Whether have the item or not. </p>
-         *
-         * <p> Indicates whether a map has an item having the specified identifier. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @return Whether the map has an item having the specified identifier.
-         */
-        has(key: Key): boolean;
-        /**
-         * <p> Count elements with a specific key. </p>
-         *
-         * <p> Searches the container for elements whose key is <i>key</i> and returns the number of elements found. </p>
-         *
-         * @param key Key value to be searched for.
-         *
-         * @return The number of elements in the container with a <i>key</i>.
-         */
-        abstract count(key: Key): number;
-        /**
-         * Return the number of elements in the map.
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        push(...args: Pair<Key, T>[]): number;
-        /**
-         * @inheritdoc
-         */
-        push(...args: [Key, T][]): number;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapIterator<Key, T>, key: Key, val: T): MapIterator<Key, T>;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
-         *		   that already had an equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapReverseIterator<Key, T>, key: Key, val: T): MapReverseIterator<Key, T>;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
-         *		   that already had an equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting a new element, effectively increasing the container {@link size}
-         * by the number of element inserted (zero or one). </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting a new element, effectively increasing the container {@link size}
-         * by the number of element inserted (zero or one). </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size}
-         * by the number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size}
-         * by the number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
-        /**
-         * <p> Insert elements from range iterators. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param begin Input iterator specifying initial position of a range of elements.
-         * @param end Input iterator specifying final position of a range of elements.
-         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
-         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_pair<L extends Key, U extends T>(pair: Pair<L, U>): any;
-        /**
-         * @hidden
-         */
-        private insert_by_tuple<L, U>(tuple);
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private insert_by_hint_with_tuple(hint, tuple);
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * <p> Erase an elemet by key. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a single element. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
-         * which are destroyed. </p>
-         *
-         * @param key Key of the element to be removed from the {@link MapContainer}.
-         */
-        erase(key: Key): number;
-        /**
-         * <p> Erase an elemet by iterator. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a single element. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
-         * which are destroyed. </p>
-         *
-         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
-         */
-        erase(it: MapIterator<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Erase elements by range iterators. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed, which are
-         * destroyed. </p>
-         *
-         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
-         *				to be removed.
-         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
-         *			  to be removed.
-         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
-         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        erase(begin: MapIterator<Key, T>, end: MapIterator<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Erase an elemet by iterator. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a single element. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
-         * which are destroyed. </p>
-         *
-         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
-         */
-        erase(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * <p> Erase elements by range iterators. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed, which are
-         * destroyed. </p>
-         *
-         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
-         *				to be removed.
-         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
-         *			  to be removed.
-         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
-         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        erase(begin: MapReverseIterator<Key, T>, end: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private erase_by_key(key);
-        /**
-         * @hidden
-         */
-        private erase_by_iterator(first, last?);
-        /**
-         * @hidden
-         */
-        private erase_by_range(first, last);
-        /**
-         * @hidden
-         */
-        protected _Swap(obj: MapContainer<Key, T>): void;
-        /**
-         * Merge two maps.
-         *
-         * Extracts and transfers elements from *source* to this container.
-         *
-         * @param source A {@link MapContainer map container} to transfer the elements from.
-         */
-        abstract merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
-        /**
-         * <p> Abstract method handling insertions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_insert} is designed to register the <i>first to last</i> to somewhere storing
-         * those {@link MapIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link insert} is called, new elements will be inserted into the {@link data_ list container} and new
-         * {@link MapIterator iterators} <i>first to last</i>, pointing the inserted elements, will be created and the
-         * newly created iterators <i>first to last</i> will be shifted into this method {@link _Handle_insert} after the
-         * insertions. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link MapIterator iterators}
-         * will be registered into the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first</i> to <i>last</i> will be
-         * registered into the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link MapIterator} to the initial position in a sequence.
-         * @param last An {@link MapIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Abstract method handling deletions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_erase} is designed to unregister the <i>first to last</i> to somewhere storing
-         * those {@link MapIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link erase} is called with <i>first to last</i>, {@link MapIterator iterators} positioning somewhere
-         * place to be deleted, is memorized and shifted to this method {@link _Handle_erase} after the deletion process is
-         * terminated. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link MapIterator iterators}
-         * will be unregistered from the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first to last</i> will be
-         * unregistered from the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link MapIterator} to the initial position in a sequence.
-         * @param last An {@link MapIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-    }
-    /**
-     * @hidden
-     */
-    class MapElementList<Key, T> extends ListContainer<Pair<Key, T>, MapIterator<Key, T>> {
-        private associative_;
-        private rend_;
-        constructor(associative: MapContainer<Key, T>);
-        protected _Create_iterator(prev: MapIterator<Key, T>, next: MapIterator<Key, T>, val: Pair<Key, T>): MapIterator<Key, T>;
-        protected _Set_begin(it: MapIterator<Key, T>): void;
-        get_associative(): MapContainer<Key, T>;
-        rbegin(): MapReverseIterator<Key, T>;
-        rend(): MapReverseIterator<Key, T>;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of {@link MapContainer map container}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MapIterator<Key, T> extends base.ListIteratorBase<Pair<Key, T>> implements IComparable<MapIterator<Key, T>> {
-        /**
-         * Construct from the {@link MapContainer source map} and {@link ListIterator list iterator}.
-         *
-         * @param source The source {@link MapContainer}.
-         * @param list_iterator A {@link ListIterator} pointing {@link Pair} of <i>key</i> and <i>value</i>.
-         */
-        constructor(source: base.MapElementList<Key, T>, prev: MapIterator<Key, T>, next: MapIterator<Key, T>, val: Pair<Key, T>);
-        /**
-         * Get iterator to previous element.
-         */
-        prev(): MapIterator<Key, T>;
-        /**
-         * Get iterator to next element.
-         */
-        next(): MapIterator<Key, T>;
-        /**
-         * Advances the Iterator by n element positions.
-         *
-         * @param step Number of element positions to advance.
-         * @return An advanced Iterator.
-         */
-        advance(step: number): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        get_source(): base.MapContainer<Key, T>;
-        /**
-         * Get first, key element.
-         */
-        readonly first: Key;
-        /**
-         * Get second, value element.
-         */
-        /**
-         * Set second value.
-         */
-        second: T;
-        /**
-         * @inheritdoc
-         */
-        less(obj: MapIterator<Key, T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        equals(obj: MapIterator<Key, T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        hashCode(): number;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: MapIterator<Key, T>): void;
-    }
-    /**
-     * <p> A reverse-iterator of {@link MapContainer map container}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MapReverseIterator<Key, T> extends ReverseIterator<Pair<Key, T>, MapIterator<Key, T>, MapReverseIterator<Key, T>> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: MapIterator<Key, T>);
-        /**
-         * @hidden
-         */
-        protected _Create_neighbor(base: MapIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * Get first, key element.
-         */
-        readonly first: Key;
-        /**
-         * Get second, value element.
-         */
-        /**
-         * Set second value.
-         */
-        second: T;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract multi-map. </p>
-     *
-     * <p> {@link MultiMap MultiMaps} are associative containers that store elements formed by a combination of a
-     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
-     * individual elements based on their keys. </p>
-     *
-     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
-     * <i>mapped values</i> store the content associated to this <i>key</i>. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
-     * {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
-     *		in the container.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class MultiMap<Key, T> extends MapContainer<Key, T> {
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
-         * as the arguments for the element's constructor.
-         *
-         * This effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An {@link MapIterator iterator} to the newly inserted element.
-         */
-        emplace(key: Key, value: T): MapIterator<Key, T>;
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
-         * as the arguments for the element's constructor.
-         *
-         * This effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         * @return An {@link MapIterator iterator} to the newly inserted element.
-         */
-        emplace(pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Insert elements. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to the newly inserted element.
-         */
-        insert(pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Insert elements. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return An iterator pointing to the newly inserted element.
-         */
-        insert<L extends Key, U extends T>(tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract set. </p>
-     *
-     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
-     * individual elements based on their value. </p>
-     *
-     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class SetContainer<T> extends Container<T> {
-        /**
-         * <p> {@link List} storing elements. </p>
-         *
-         * <p> Storing elements and keeping those sequence of the {@link SetContainer} are implemented by
-         * {@link data_ this list container}. Implementing index-table is also related with {@link data_ this list}
-         * by storing {@link ListIterator iterators} ({@link SetIterator} references {@link ListIterator}) who are
-         * created from {@link data_ here}. </p>
-         */
-        private data_;
-        /**
-         * Default Constructor.
-         */
-        protected constructor();
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: Iterator<U>, end: Iterator<U>): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * <p> Get iterator to element. </p>
-         *
-         * <p> Searches the container for an element with <i>key</i> as value and returns an iterator to it if found,
-         * otherwise it returns an iterator to {@link end end()} (the element past the end of the container). </p>
-         *
-         * <p> Another member function, {@link count count()}, can be used to just check whether a particular element
-         * exists. </p>
-         *
-         * @param key Key to be searched for.
-         *
-         * @return An iterator to the element, if the specified value is found, or {@link end end()} if it is not
-         *		   found in the
-         */
-        abstract find(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): SetReverseIterator<T>;
-        /**
-         * <p> Whether have the item or not. </p>
-         *
-         * <p> Indicates whether a set has an item having the specified identifier. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @return Whether the set has an item having the specified identifier.
-         */
-        has(val: T): boolean;
-        /**
-         * <p> Count elements with a specific key. </p>
-         *
-         * <p> Searches the container for elements with a value of k and returns the number of elements found. </p>
-         *
-         * @param key Value of the elements to be counted.
-         *
-         * @return The number of elements in the container with a <i>key</i>.
-         */
-        abstract count(val: T): number;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        push(...args: T[]): number;
-        /**
-         * <p> Insert an element with hint. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had its
-         *		   same value in the {@link SetContainer}.
-         */
-        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * <p> Insert an element with hint. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had its
-         *		   same value in the {@link SetContainer}.
-         */
-        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
-        /**
-         * <p> Insert elements with a range of a  </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * @param begin An iterator specifying range of the begining element.
-         * @param end An iterator specifying range of the ending element.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * <p> Erase an element. </p>
-         * <p> Removes from the set container the elements whose value is <i>key</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * @param key Value of the elements to be erased.
-         *
-         * @return Number of elements erased.
-         */
-        erase(val: T): number;
-        /**
-         * @inheritdoc
-         */
-        erase(it: SetIterator<T>): SetIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         * <p> Removes from the set container a range of elements.. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         */
-        erase(begin: SetIterator<T>, end: SetIterator<T>): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(it: SetReverseIterator<T>): SetReverseIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         * <p> Removes from the set container a range of elements.. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         */
-        erase(begin: SetReverseIterator<T>, end: SetReverseIterator<T>): SetReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private erase_by_iterator(first, last?);
-        /**
-         * @hidden
-         */
-        private erase_by_val(val);
-        /**
-         * @hidden
-         */
-        private erase_by_range(first, last);
-        /**
-         * @hidden
-         */
-        protected _Swap(obj: SetContainer<T>): void;
-        /**
-         * Merge two sets.
-         *
-         * Extracts and transfers elements from *source* to this container.
-         *
-         * @param source A {@link SetContainer set container} to transfer the elements from.
-         */
-        abstract merge<U extends T>(source: SetContainer<U>): void;
-        /**
-         * <p> Abstract method handling insertions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_insert} is designed to register the <i>first to last</i> to somewhere storing
-         * those {@link SetIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link insert} is called, new elements will be inserted into the {@link data_ list container} and new
-         * {@link SetIterator iterators} <i>first to last</i>, pointing the inserted elements, will be created and the
-         * newly created iterators <i>first to last</i> will be shifted into this method {@link _Handle_insert} after the
-         * insertions. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link SetIterator iterators}
-         * will be registered into the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first</i> to <i>last</i> will be
-         * registered into the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link SetIterator} to the initial position in a sequence.
-         * @param last An {@link SetIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Abstract method handling deletions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_erase} is designed to unregister the <i>first to last</i> to somewhere storing
-         * those {@link SetIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link erase} is called with <i>first to last</i>, {@link SetIterator iterators} positioning somewhere
-         * place to be deleted, is memorized and shifted to this method {@link _Handle_erase} after the deletion process is
-         * terminated. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link SetIterator iterators}
-         * will be unregistered from the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first to last</i> will be
-         * unregistered from the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link SetIterator} to the initial position in a sequence.
-         * @param last An {@link SetIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-    }
-    /**
-     * @hidden
-     */
-    class SetElementList<T> extends ListContainer<T, SetIterator<T>> {
-        private associative_;
-        private rend_;
-        constructor(associative: SetContainer<T>);
-        protected _Create_iterator(prev: SetIterator<T>, next: SetIterator<T>, val: T): SetIterator<T>;
-        protected _Set_begin(it: SetIterator<T>): void;
-        get_associative(): SetContainer<T>;
-        rbegin(): SetReverseIterator<T>;
-        rend(): SetReverseIterator<T>;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of a Set. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SetIterator<T> extends base.ListIteratorBase<T> implements IComparable<SetIterator<T>> {
-        /**
-         * <p> Construct from source and index number. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Do not create iterator directly. </p>
-         * <p> Use begin(), find() or end() in Map instead. </p>
-         *
-         * @param map The source Set to reference.
-         * @param index Sequence number of the element in the source Set.
-         */
-        constructor(source: base.SetElementList<T>, prev: SetIterator<T>, next: SetIterator<T>, val: T);
-        /**
-         * @inheritdoc
-         */
-        get_source(): base.SetContainer<T>;
-        /**
-         * @inheritdoc
-         */
-        prev(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(size: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        less(obj: SetIterator<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        equals(obj: SetIterator<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        hashCode(): number;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: SetIterator<T>): void;
-    }
-    /**
-     * <p> A reverse-iterator of Set. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SetReverseIterator<T> extends ReverseIterator<T, SetIterator<T>, SetReverseIterator<T>> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: SetIterator<T>);
-        /**
-         * @hidden
-         */
-        protected _Create_neighbor(base: SetIterator<T>): SetReverseIterator<T>;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract set. </p>
-     *
-     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
-     * individual elements based on their value. </p>
-     *
-     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class MultiSet<T> extends SetContainer<T> {
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param key Value to be inserted as an element.
-         *
-         * @return An iterator to the newly inserted element.
-         */
-        insert(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        merge<U extends T>(source: SetContainer<U>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> Red-black Tree. </p>
-     *
-     * <p> A red-black tree is a kind of self-balancing
-     * binary search tree. Each node of the binary tree has an extra bit, and that bit is often interpreted as the
-     * color (<font color='red'>red</font> or <font color='darkBlue'>black</font>) of the node. These color bits
-     * are used to ensure the tree remains approximately balanced during insertions and deletions. </p>
-     *
-     * <p> Balance is preserved by painting each node of the tree with one of two colors (typically called
-     * '<font color='red'>red</font>' and '<font color='darkBlue'>black</font>') in a way that satisfies certain
-     * properties, which collectively constrain how unbalanced the tree can become in the worst case. When the tree
-     * is modified, the new tree is subsequently rearranged and repainted to restore the coloring properties. The
-     * properties are designed in such a way that this rearranging and recoloring can be performed efficiently. </p>
-     *
-     * <p> The balancing of the tree is not perfect but it is good enough to allow it to guarantee searching in
-     * O(log n) time, where n is the total number of elements in the tree. The insertion and deletion operations,
-     * along with the tree rearrangement and recoloring, are also performed in O(log n) time. </p>
-     *
-     * <p> Tracking the color of each node requires only 1 bit of information per node because there are only two
-     * colors. The tree does not contain any other data specific to its being a
-     * red-black tree so its memory footprint is almost
-     * identical to a classic (uncolored) binary search tree. In many cases the additional bit of information can
-     * be stored at no additional memory cost. </p>
-     *
-     * <h4> Properties </h4>
-     * <p> In addition to the requirements imposed on a binary search tree the following must be satisfied by a
-     * red-black tree: </p>
-     *
-     * <ol>
-     *	<li> A node is either <font color='red'>red</font> or <font color='darkBlue'>black</font>. </li>
-     *	<li>
-     *		The root is <font color='darkBlue'>black</font>. This rule is sometimes omitted. Since the root can
-     *		always be changed from <font color='red'>red</font> to <font color='darkBlue'>black</font>, but not
-     *		necessarily vice versa, this rule has little effect on analysis.
-     *	</li>
-     *	<li> All leaves (NIL; <code>null</code>) are <font color='darkBlue'>black</font>. </li>
-     *  <li>
-     *		If a node is <font color='red'>red</font>, then both its children are
-     *		<font color='darkBlue'>black</font>.
-     *	</li>
-     *  <li>
-     *		Every path from a given node to any of its descendant NIL nodes contains the same number of
-     *		<font color='darkBlue'>black</font> nodes. Some definitions: the number of
-     *		<font color='darkBlue'>black</font> nodes from the root to a node is the node's
-     *		<font color='darkBlue'>black</font> depth; the uniform number of <font color='darkBlue'>black</font>
-     *		nodes in all paths from root to the leaves is called the <font color='darkBlue'>black</font>-height of
-     *		the red-black tree.
-     *	</li>
-     * </ol>
-     *
-     * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_example.svg"
-     *			style="max-width: 100%" /> </p>
-     *
-     * <p> These constraints enforce a critical property of red-black trees: the path from the root to the farthest
-     * leaf is no more than twice as long as the path from the root to the nearest leaf. The result is that the tree
-     * is roughly height-balanced. Since operations such as inserting, deleting, and finding values require
-     * worst-case time proportional to the height of the tree, this theoretical upper bound on the height allows
-     * red-black trees to be efficient in the worst case, unlike ordinary binary search trees. </p>
-     *
-     * <p> To see why this is guaranteed, it suffices to consider the effect of properties 4 and 5 together. For a
-     * red-black tree T, let B be the number of <font color='darkBlue'>black</font> nodes in property 5. Let the
-     * shortest possible path from the root of T to any leaf consist of B <font color='darkBlue'>black</font> nodes.
-     * Longer possible paths may be constructed by inserting <font color='red'>red</font> nodes. However, property 4
-     * makes it impossible to insert more than one consecutive <font color='red'>red</font> node. Therefore,
-     * ignoring any <font color='darkBlue'>black</font> NIL leaves, the longest possible path consists of 2*B nodes,
-     * alternating <font color='darkBlue'>black</font> and <font color='red'>red</font> (this is the worst case).
-     * Counting the <font color='darkBlue'>black</font> NIL leaves, the longest possible path consists of 2*B-1
-     * nodes. </p>
-     *
-     * <p> The shortest possible path has all <font color='darkBlue'>black</font> nodes, and the longest possible
-     * path alternates between <font color='red'>red</font> and <font color='darkBlue'>black</font> nodes. Since all
-     * maximal paths have the same number of <font color='darkBlue'>black</font> nodes, by property 5, this shows
-     * that no path is more than twice as long as any other path. </p>
-     *
-     * @param <T> Type of elements.
-     *
-     * @reference https://en.wikipedia.org/w/index.php?title=Red%E2%80%93black_tree
-     * @inventor Rudolf Bayer
-     * @author Migrated by Jeongho Nam <http://samchon.org>
-     */
-    abstract class XTree<T> {
-        /**
-         * Root node.
-         */
-        protected root_: XTreeNode<T>;
-        /**
-         * Default Constructor.
-         */
-        protected constructor();
-        /**
-         * Clear, removes all tree nodes.
-         */
-        clear(): void;
-        /**
-         * Find a node from its contained value.
-         *
-         * @param val Value to find.
-         */
-        find(val: T): XTreeNode<T>;
-        /**
-         * Fetch maximum (the rightes?) node from one.
-         *
-         * @param node A node to fetch its maximum node.
-         * @return The maximum node.
-         */
-        protected fetch_maximum(node: XTreeNode<T>): XTreeNode<T>;
-        abstract is_less(left: T, right: T): boolean;
-        abstract is_equal_to(left: T, right: T): boolean;
-        /**
-         * <p> Insert an element with a new node. </p>
-         *
-         * <p> Insertion begins by adding the node as any binary search tree insertion does and by coloring it
-         * <font color='red'>red</font>. Whereas in the binary search tree, we always add a leaf, in the red-black
-         * tree, leaves contain no information, so instead we add a <font color='red'>red</font> interior node, with
-         * two <font color='darkBlue'>black</font> leaves, in place of an existing
-         * <font color='darkBlue'>black</font> leaf. </p>
-         *
-         * <p> What happens next depends on the color of other nearby nodes. The term uncle node will be used to
-         * refer to the sibling of a node's parent, as in human family trees. Note that: </p>
-         *
-         * <ul>
-         *	<li> property 3 (all leaves are <font color='darkBlue'>black</font>) always holds. </li>
-         *	<li>
-         *		property 4 (both children of every <font color='red'>red</font> node are
-         *		<font color='darkBlue'>black</font>) is threatened only by adding a <font color='red'>red</font>
-         *		node, repainting a <font color='darkBlue'>black</font> node <font color='red'>red</font>, or a
-         *		rotation.
-         *	</li>
-         *	<li>
-         *		property 5 (all paths from any given node to its leaf nodes contain the same number of
-         *		<font color='darkBlue'>black</font> nodes) is threatened only by adding a
-         *		<font color='darkBlue'>black</font> node, repainting a <font color='red'>red</font> node
-         *		<font color='darkBlue'>black</font> (or vice versa), or a rotation.
-         *	</li>
-         * </ul>
-         *
-         * <h4> Notes </h4>
-         * <ol>
-         *	<li>
-         *		The label <i><b>N</b></i> will be used to denote the current node (colored
-         *		<font color='red'>red</font>). In the diagrams <i><b>N</b></i> carries a blue contour. At the
-         *		beginning, this is the new node being inserted, but the entire procedure may also be applied
-         *		recursively to other nodes (see case 3). {@link XTreeNode.parent <b>P</b>} will denote
-         *		<i><b>N</b></i>'s parent node, {@link XTreeNode.grand_parent <b>G</b>} will denote <i><b>N</b></i>'s
-         *		grandparent, and {@link XTreeNode.uncle <b>U</b>} will denote <i><b>N</b></i>'s uncle. In between
-         *		some cases, the roles and labels of the nodes are exchanged, but in each case, every label continues
-         *		to represent the same node it represented at the beginning of the case.
-         *	</li>
-         *	<li>
-         *		If a node in the right (target) half of a diagram carries a blue contour it will become the current
-         *		node in the next iteration and there the other nodes will be newly assigned relative to it. Any
-         *		color shown in the diagram is either assumed in its case or implied by those assumptions.
-         *	</li>
-         *	<li>
-         *		A numbered triangle represents a subtree of unspecified depth. A <font color='darkBlue'>black</font>
-         *		circle atop a triangle means that <font color='darkBlue'>black</font>-height of subtree is greater
-         *		by one compared to subtree without this circle. </li>
-         * </ol>
-         *
-         * <p> There are several cases of red-black tree insertion to handle: </p>
-         *
-         * <ul>
-         *	<li> <i><b>N</b></i> is the root node, i.e., first node of red-black tree. </li>
-         *	<li>
-         *		<i><b>N</b></i>'s parent ({@link XTreeNode.parent <b>P</b>}) is <font color='darkBlue'>black</font>.
-         *	</li>
-         *	<li>
-         *		<i><b>N</b></i>'s parent ({@link XTreeNode.parent <b>P</b>}) and uncle
-         *		({@link XTreeNode.uncle <b>U</b>}) are <font color='red'>red</font>.
-         *	</li>
-         *	<li>
-         *		<i><b>N</b></i> is added to right of left child of grandparent, or <i><b>N</b></i> is added to left
-         *		of right child of grandparent ({@link XTreeNode.parent <b>P</b>} is <font color='red'>red</font> and
-         *		{@link XTreeNode.uncle <b>U</b>} is <font color='darkBlue'>black</font>).
-         *	</li>
-         *	<li>
-         *		<i><b>N</b></i> is added to left of left child of grandparent, or <i><b>N</b></i> is added to right
-         *		of right child of grandparent ({@link XTreeNode.parent <b>P</b>} is <font color='red'>red</font> and
-         *		{@link XTreeNode.uncle <b>U</b>} is <font color='darkBlue'>black</font>).
-         *	</li>
-         * </ul>
-         *
-         * <h4> Note </h4>
-         * <p> Note that inserting is actually in-place, since all the calls above use tail recursion. </p>
-         *
-         * <p> In the algorithm above, all cases are chained in order, except in insert case 3 where it can recurse
-         * to case 1 back to the grandparent node: this is the only case where an iterative implementation will
-         * effectively loop. Because the problem of repair is escalated to the next higher level but one, it takes
-         * maximally h⁄2 iterations to repair the tree (where h is the height of the tree). Because the probability
-         * for escalation decreases exponentially with each iteration the average insertion cost is constant. </p>
-         *
-         * @param val An element to insert.
-         */
-        insert(val: T): void;
-        /**
-         * <p> <i><b>N</b></i> is the root node, i.e., first node of red-black tree. </p>
-         *
-         * <p> The current node <i><b>N</b></i> is at the {@link root_ root} of the tree. </p>
-         *
-         * <p> In this case, it is repainted <font color='darkBlue'>black</font> to satisfy property 2 (the root is
-         * <font color='darkBlue'>black</font>). Since this adds one <font color='darkBlue'>black</font> node to
-         * every path at once, property 5 (all paths from any given node to its leaf nodes contain the same number
-         * of <font color='darkBlue'>black</font> nodes) is not violated. </p>
-         *
-         * @param N A node to be inserted or swapped.
-         */
-        private insert_case1(N);
-        /**
-         * <p> <i><b>N</b></i>'s parent ({@link XTreeNode.parent <b>P</b>}) is <font color='darkBlue'>black</font>. </p>
-         *
-         * <p> The current node's parent {@link XTreeNode.parent <b>P</b>} is <font color='darkBlue'>black</font>,
-         * so property 4 (both children of every <font color='red'>red</font> node are
-         * <font color='darkBlue'>black</font>) is not invalidated. </p>
-         *
-         * <p> In this case, the tree is still valid. Property 5 (all paths from any given node to its leaf nodes
-         * contain the same number of <font color='darkBlue'>black</font> nodes) is not threatened, because the
-         * current node <i><b>N</b></i> has two <font color='darkBlue'>black</font> leaf children, but because
-         * <i><b>N</b></i> is <font color='red'>red</font>, the paths through each of its children have the same
-         * number of <font color='darkBlue'>black</font> nodes as the path through the leaf it replaced, which was
-         * <font color='darkBlue'>black</font>, and so this property remains satisfied. </p>
-         *
-         * @param N A node to be inserted or swapped.
-         */
-        private insert_case2(N);
-        /**
-         * <p> <i><b>N</b></i>'s parent ({@link XTreeNode.parent <b>P</b>}) and uncle
-         * (<i>{@link XTreeNode.uncle <b>U</b>}</i>) are <font color='red'>red</font>. </p>
-         *
-         * <p> If both the parent {@link XTreeNode.parent <b>P</b>} and the uncle {@link XTreeNode.uncle <b>U</b>}
-         * are <font color='red'>red</font>, then both of them can be repainted <font color='darkBlue'>black</font>
-         * and the grandparent {@link XTreeNode.grand_parent <b>G</b>} becomes <font color='red'>red</font> (to
-         * maintain property 5 (all paths from any given node to its leaf nodes contain the same number of
-         * <font color='darkBlue'>black</font> nodes)). </p>
-         *
-         * <p> Now, the current <font color='red'>red</font> node <i><b>N</b></i> has a
-         * <font color='darkBlue'>black</font> parent. Since any path through the parent or uncle must pass through
-         * the grandparent, the number of <font color='darkBlue'>black</font> nodes on these paths has not changed.
-         *
-         * <p> However, the grandparent {@link XTreeNode.grand_parent <b>G</b>} may now violate properties 2 (The
-         * root is <font color='darkBlue'>black</font>) or 4 (Both children of every <font color='red'>red</font>
-         * node are <font color='darkBlue'>black</font>) (property 4 possibly being violated since
-         * {@link XTreeNode.grand_parent <b>G</b>} may have a <font color='red'>red</font> parent). </p>
-         *
-         * <p> To fix this, the entire procedure is recursively performed on {@link XTreeNode.grand_parent <b>G</b>}
-         * from case 1. Note that this is a tail-recursive call, so it could be rewritten as a loop; since this is
-         * the only loop, and any rotations occur after this loop, this proves that a constant number of rotations
-         * occur. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_insert_case_3.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * @param N A node to be inserted or swapped.
-         */
-        private insert_case3(N);
-        /**
-         * <p> <i><b>N</b></i> is added to right of left child of grandparent, or <i><b>N</b></i> is added to left
-         * of right child of grandparent ({@link XTreeNode.parent <b>P</b>} is <font color='red'>red</font> and
-         * {@link XTreeNode.uncle <b>U</b>} is <font color='darkBlue'>black</font>). </p>
-         *
-         * <p> The parent {@link XTreeNode.parent <b>P</b>} is <font color='red'>red</font> but the uncle
-         * {@link XTreeNode.uncle <b>U</b>} is <font color='darkBlue'>black</font>; also, the current node
-         * <i><b>N</b></i> is the right child of {@link XTreeNode.parent <b>P</b>}, and
-         * {@link XTreeNode.parent <b>P</b>} in turn is the left child of its parent
-         * {@link XTreeNode.grand_parent <b>G</b>}. </p>
-         *
-         * <p> In this case, a left rotation on {@link XTreeNode.parent <b>P</b>} that switches the roles of the
-         * current node <i><b>N</b></i> and its parent {@link XTreeNode.parent <b>P</b>} can be performed; then,
-         * the former parent node {@link XTreeNode.parent <b>P</b>} is dealt with using case 5
-         * (relabeling <i><b>N</b></i> and {@link XTreeNode.parent <b>P</b>}) because property 4 (both children of
-         * every <font color='red'>red</font> node are <font color='darkBlue'>black</font>) is still violated. </p>
-         *
-         * <p> The rotation causes some paths (those in the sub-tree labelled "1") to pass through the node
-         * <i><b>N</b></i> where they did not before. It also causes some paths (those in the sub-tree labelled "3")
-         * not to pass through the node {@link XTreeNode.parent <b>P</b>} where they did before. However, both of
-         * these nodes are <font color='red'>red</font>, so property 5 (all paths from any given node to its leaf
-         * nodes contain the same number of <font color='darkBlue'>black</font> nodes) is not violated by the
-         * rotation. </p>
-         *
-         * <p> After this case has been completed, property 4 (both children of every <font color='red'>red</font>
-         * node are <font color='darkBlue'>black</font>) is still violated, but now we can resolve this by
-         * continuing to case 5. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_insert_case_4.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * @param N A node to be inserted or swapped.
-         */
-        private insert_case4(node);
-        /**
-         * <p> <i><b>N</b></i> is added to left of left child of grandparent, or <i><b>N</b></i> is added to right
-         * of right child of grandparent ({@link XTreeNode.parent <b>P</b>} is <font color='red'>red</font> and
-         * {@link XTreeNode.uncle <b>U</b>} is <font color='darkBlue'>black</font>). </p>
-         *
-         * <p> The parent {@link XTreeNode.parent <b>P</b>} is <font color='red'>red</font> but the uncle
-         * {@link XTreeNode.uncle <b>U</b>} is <font color='darkBlue'>black</font>, the current node <i><b>N</b></i>
-         * is the left child of {@link XTreeNode.parent <b>P</b>}, and {@link XTreeNode.parent <b>P</b>} is the left
-         * child of its parent {@link XTreeNode.grand_parent <b>G</b>}. </p>
-         *
-         * <p>In this case, a right rotation on {@link XTreeNode.grand_parent <b>G</b>} is performed; the result is a
-         * tree where the former parent {@link XTreeNode.parent <b>P</b>} is now the parent of both the current node
-         * <i><b>N</b></i> and the former grandparent {@link XTreeNode.grand_parent <b>G</b>}. </p>
-         *
-         * <p> {@link XTreeNode.grand_parent <b>G</b>} is known to be <font color='darkBlue'>black</font>, since its
-         * former child {@link XTreeNode.parent <b>P</b>} could not have been <font color='red'>red</font> otherwise
-         * (without violating property 4). Then, the colors of {@link XTreeNode.parent <b>P</b>} and
-         * {@link XTreeNode.grand_parent <b>G</b>} are switched, and the resulting tree satisfies property 4 (both
-         * children of every <font color='red'>red</font> node are <font color='darkBlue'>black</font>). Property 5
-         * (all paths from any given node to its leaf nodes contain the same number of
-         * <font color='darkBlue'>black</font> nodes) also remains satisfied, since all paths that went through any
-         * of these three nodes went through {@link XTreeNode.grand_parent <b>G</b>} before, and now they all go
-         * through {@link XTreeNode.parent <b>P</b>}. In each case, this is the only
-         * <font color='darkBlue'>black</font> node of the three. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_insert_case_5.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * @param N A node to be inserted or swapped.
-         */
-        private insert_case5(node);
-        /**
-         * <p> Erase an element with its node. </p>
-         *
-         * <p> In a regular binary search tree when deleting a node with two non-leaf children, we find either the
-         * maximum element in its left subtree (which is the in-order predecessor) or the minimum element in its
-         * right subtree (which is the in-order successor) and move its value into the node being deleted (as shown
-         * here). We then delete the node we copied the value from, which must have fewer than two non-leaf children.
-         * (Non-leaf children, rather than all children, are specified here because unlike normal binary search
-         * trees, red-black trees can have leaf nodes anywhere, so that all nodes are either internal nodes with
-         * two children or leaf nodes with, by definition, zero children. In effect, internal nodes having two leaf
-         * children in a red-black tree are like the leaf nodes in a regular binary search tree.) Because merely
-         * copying a value does not violate any red-black properties, this reduces to the problem of deleting a node
-         * with at most one non-leaf child. Once we have solved that problem, the solution applies equally to the
-         * case where the node we originally want to delete has at most one non-leaf child as to the case just
-         * considered where it has two non-leaf children. </p>
-         *
-         * <p> Therefore, for the remainder of this discussion we address the deletion of a node with at most one
-         * non-leaf child. We use the label <b>M</b> to denote the node to be deleted; <b>C</b> will denote a
-         * selected child of <b>M</b>, which we will also call "its child". If <b>M</b> does have a non-leaf child,
-         * call that its child, <b>C</b>; otherwise, choose either leaf as its child, <b>C</b>. </p>
-         *
-         * <p> If <b>M</b> is a <font color='red'>red</font> node, we simply replace it with its child <b>C</b>,
-         *  which must be <font color='darkBlue'>black</font> by property 4. (This can only occur when <b>M</b> has
-         * two leaf children, because if the <font color='red'>red</font> node <b>M</b> had a
-         * <font color='darkBlue'>black</font> non-leaf child on one side but just a leaf child on the other side,
-         * then the count of <font color='darkBlue'>black</font> nodes on both sides would be different, thus the
-         * tree would violate property 5.) All paths through the deleted node will simply pass through one fewer
-         * <font color='red'>red</font> node, and both the deleted node's parent and child must be
-         * <font color='darkBlue'>black</font>, so property 3 (all leaves are <font color='darkBlue'>black</font>)
-         * and property 4 (both children of every <font color='red'>red</font> node are
-         * <font color='darkBlue'>black</font>) still hold. </p>
-         *
-         * <p> Another simple case is when <b>M</b> is <font color='darkBlue'>black</font> and <b>C</b> is
-         * <font color='red'>red</font>. Simply removing a <font color='darkBlue'>black</font> node could break
-         * Properties 4 (“Both children of every <font color='red'>red</font> node are
-         * <font color='darkBlue'>black</font>”) and 5 (“All paths from any given node to its leaf nodes contain the
-         * same number of <font color='darkBlue'>black</font> nodes”), but if we repaint <b>C</b>
-         * <font color='darkBlue'>black</font>, both of these properties are preserved. </p>
-         *
-         * <p> The complex case is when both <b>M</b> and <b>C</b> are <font color='darkBlue'>black</font>. (This
-         * can only occur when deleting a <font color='darkBlue'>black</font> node which has two leaf children,
-         * because if the <font color='darkBlue'>black</font> node <b>M</b> had a <font color='darkBlue'>black</font>
-         * non-leaf child on one side but just a leaf child on the other side, then the count of
-         * <font color='darkBlue'>black</font> nodes on both sides would be different, thus the tree would have been
-         * an invalid red-black tree by violation of property 5.) We begin by replacing <b>M</b> with its child
-         * <b>C</b>. We will relabel this child <b>C</b> (in its new position) <i><b>N</b></i>, and its sibling (its
-         * new parent's other child) {@link XTreeNode.sibling <b>S</b>}. ({@link XTreeNode.sibling <b>S</b>} was
-         * previously the sibling of <b>M</b>.) </p>
-         *
-         * <p> In the diagrams below, we will also use {@link XTreeNode.parent <b>P</b>} for <i><b>N</b></i>'s new
-         * parent (<b>M</b>'s old parent), <b>SL</b> for {@link XTreeNode.sibling <b>S</b>}'s left child, and
-         * <b>SR</b> for {@link XTreeNode.sibling <b>S</b>}'s right child ({@link XTreeNode.sibling <b>S</b>} cannot
-         * be a leaf because if <b>M</b> and <b>C</b> were <font color='darkBlue'>black</font>, then
-         * {@link XTreeNode.parent <b>P</b>}'s one subtree which included <b>M</b> counted two
-         * <font color='darkBlue'>black</font>-height and thus {@link XTreeNode.parent <b>P</b>}'s other subtree
-         * which includes {@link XTreeNode.sibling <b>S</b>} must also count two
-         * <font color='darkBlue'>black</font>-height, which cannot be the case if {@link XTreeNode.sibling <b>S</b>}
-         * is a leaf node). </p>
-         *
-         * <h4> Notes </h4>
-         * <ol>
-         *	<li>
-         *		The label <i><b>N</b></i> will be used to denote the current node (colored
-         *		<font color='darkBlue'>black</font>). In the diagrams <i><b>N</b></i> carries a blue contour. At the
-         *		beginning, this is the replacement node and a leaf, but the entire procedure may also be applied
-         *		recursively to other nodes (see case 3). In between some cases, the roles and labels of the nodes
-         *		are exchanged, but in each case, every label continues to represent the same node it represented at
-         *		the beginning of the case.
-         *	</li>
-         *	<li>
-         *		If a node in the right (target) half of a diagram carries a blue contour it will become the current
-         *		node in the next iteration and there the other nodes will be newly assigned relative to it. Any
-         *		color shown in the diagram is either assumed in its case or implied by those assumptions.
-         *		White represents an arbitrary color (either <font color='red'>red</font> or
-         *		<font color='darkBlue'>black</font>), but the same in both halves of the diagram.
-         *	</li>
-         *	<li>
-         *		A numbered triangle represents a subtree of unspecified depth. A <font color='darkBlue'>black</font>
-         *		circle atop a triangle means that <font color='darkBlue'>black</font>-height of subtree is greater
-         *		by one compared to subtree without this circle.
-         *	</li>
-         * </ol>
-         *
-         * <p> If both <i><b>N</b></i> and its original parent are <font color='darkBlue'>black</font>, then
-         * deleting this original parent causes paths which proceed through <i><b>N</b></i> to have one fewer
-         * <font color='darkBlue'>black</font> node than paths that do not. As this violates property 5 (all paths
-         * from any given node to its leaf nodes contain the same number of <font color='darkBlue'>black</font>
-         * nodes), the tree must be rebalanced. There are several cases to consider: </p>
-         *
-         * <ol>
-         *	<li> <i><b>N</b></i> is the new root. </li>
-         *	<li> {@link XTreeNode.sibling <b>S</b>} is <font color='red'>red</font>. </li>
-         *	<li>
-         *		{@link XTreeNode.parent <b>P</b>}, {@link XTreeNode.sibling <b>S</b>}, and
-         *		{@link XTreeNode.sibling <b>S</b>}'s children are <font color='darkBlue'>black</font>. </li>
-         *	<li>
-         *		{@link XTreeNode.sibling <b>S</b>} and {@link XTreeNode.sibling <b>S</b>}'s children are
-         *		<font color='darkBlue'>black</font>, but {@link XTreeNode.parent <b>P</b>} is
-         *		<font color='red'>red</font>.
-         *	</li>
-         *	<li>
-         *		{@link XTreeNode.sibling <b>S</b>} is <font color='darkBlue'>black</font>,
-         *		{@link XTreeNode.sibling <b>S</b>}'s left child is <font color='red'>red</font>,
-         *		{@link XTreeNode.sibling <b>S</b>}'s right child is <font color='darkBlue'>black</font>, and
-         *		<i><b>N</b></i> is the left child of its parent.
-         *	</li>
-         *	<li>
-         *		{@link XTreeNode.sibling <b>S</b>} is <font color='darkBlue'>black</font>,
-         *		{@link XTreeNode.sibling <b>S</b>}'s right child is <font color='red'>red</font>, and
-         *		<i><b>N</b></i> is the left child of its parent {@link XTreeNode.parent <b>P</b>}.
-         *	</li>
-         * </ol>
-         *
-         * <p> Again, the function calls all use tail recursion, so the algorithm is in-place. </p>
-         *
-         * <p> In the algorithm above, all cases are chained in order, except in delete case 3 where it can recurse
-         * to case 1 back to the parent node: this is the only case where an iterative implementation will
-         * effectively loop. No more than h loops back to case 1 will occur (where h is the height of the tree).
-         * And because the probability for escalation decreases exponentially with each iteration the average
-         * removal cost is constant. </p>
-         *
-         * <p> Additionally, no tail recursion ever occurs on a child node, so the tail recursion loop can only
-         * move from a child back to its successive ancestors. If a rotation occurs in case 2 (which is the only
-         * possibility of rotation within the loop of cases 1–3), then the parent of the node <i><b>N</b></i>
-         * becomes <font color='red'>red</font> after the rotation and we will exit the loop. Therefore, at most one
-         * rotation will occur within this loop. Since no more than two additional rotations will occur after
-         * exiting the loop, at most three rotations occur in total. </p>
-         *
-         * @param val An element to erase.
-         */
-        erase(val: T): void;
-        /**
-         * <p> <i><b>N</b></i> is the new root. </p>
-         *
-         * <p> In this case, we are done. We removed one <font color='darkBlue'>black</font> node from every path,
-         * and the new root is <font color='darkBlue'>black</font>, so the properties are preserved. </p>
-         *
-         * <h4> Note </h4>
-         * <p> In cases 2, 5, and 6, we assume <i><b>N</b></i> is the left child of its parent
-         * {@link XTreeNode.parent <b>P</b>}. If it is the right child, left and right should be reversed throughout
-         * these three cases. Again, the code examples take both cases into account. </p>
-         *
-         * @param N A node to be erased or swapped.
-         */
-        private erase_case1(N);
-        /**
-         * <p> {@link XTreeNode.sibling <b>S</b>} is <font color='red'>red</font>. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_delete_case_2.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * <p> In this case we reverse the colors of {@link XTreeNode.parent <b>P</b>} and
-         * {@link XTreeNode.sibling <b>S</b>}, and then rotate left at {@link XTreeNode.parent <b>P</b>}, turning
-         * {@link XTreeNode.sibling <b>S</b>} into <i><b>N</b></i>'s grandparent. </p>
-         *
-         * <p> Note that {@link XTreeNode.parent <b>P</b>} has to be <font color='darkBlue'>black</font> as it had a
-         * <font color='red'>red</font> child. The resulting subtree has a path short one
-         * <font color='darkBlue'>black</font> node so we are not done. Now <i><b>N</b></i> has a
-         * <font color='darkBlue'>black</font> sibling and a <font color='red'>red</font> parent, so we can proceed
-         * to step 4, 5, or 6. (Its new sibling is <font color='darkBlue'>black</font> because it was once the child
-         * of the <font color='red'>red</font> {@link XTreeNode.sibling <b>S</b>}.) In later cases, we will re-label
-         * <i><b>N</b></i>'s new sibling as {@link XTreeNode.sibling <b>S</b>}. </p>
-         *
-         * @param N A node to be erased or swapped.
-         */
-        private erase_case2(N);
-        /**
-         * <p> {@link XTreeNode.parent <b>P</b>}, {@link XTreeNode.sibling <b>S</b>}, and {@link XTreeNode.sibling
-         * <b>S</b>}'s children are <font color='darkBlue'>black</font>. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_delete_case_3.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * <p> In this case, we simply repaint {@link XTreeNode.sibling <b>S</b>} <font color='red'>red</font>. The
-         * result is that all paths passing through {@link XTreeNode.sibling <b>S</b>}, which are precisely those
-         * paths not passing through <i><b>N</b></i>, have one less <font color='darkBlue'>black</font> node.
-         * Because deleting <i><b>N</b></i>'s original parent made all paths passing through <i><b>N</b></i> have
-         * one less <font color='darkBlue'>black</font> node, this evens things up. </p>
-         *
-         * <p> However, all paths through {@link XTreeNode.parent <b>P</b>} now have one fewer
-         * <font color='darkBlue'>black</font> node than paths that do not pass through
-         * {@link XTreeNode.parent <b>P</b>}, so property 5 (all paths from any given node to its leaf nodes contain
-         * the same number of <font color='darkBlue'>black</font> nodes) is still violated. </p>
-         *
-         * <p> To correct this, we perform the rebalancing procedure on {@link XTreeNode.parent <b>P</b>}, starting
-         * at case 1. </p>
-         *
-         * @param N A node to be erased or swapped.
-         */
-        private erase_case3(N);
-        /**
-         * <p> {@link XTreeNode.sibling <b>S</b>} and {@link XTreeNode.sibling <b>S</b>}'s children are
-         * <font color='darkBlue'>black</font>, but {@link XTreeNode.parent <b>P</b>} is <font color='red'>red</font>. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_delete_case_4.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * <p> In this case, we simply exchange the colors of {@link XTreeNode.sibling <b>S</b>} and
-         * {@link XTreeNode.parent <b>P</b>}. This does not affect the number of <font color='darkBlue'>black</font>
-         * nodes on paths going through {@link XTreeNode.sibling <b>S</b>}, but it does add one to the number of
-         * <font color='darkBlue'>black</font> nodes on paths going through <i><b>N</b></i>, making up for the
-         * deleted <font color='darkBlue'>black</font> node on those paths. </p>
-         *
-         * @param N A node to be erased or swapped.
-         */
-        private erase_case4(N);
-        /**
-         * <p> {@link XTreeNode.sibling <b>S</b>} is <font color='darkBlue'>black</font>, {@link XTreeNode.sibling <b>S</b>}'s
-         * left child is <font color='red'>red</font>, {@link XTreeNode.sibling <b>S</b>}'s right child is
-         * <font color='darkBlue'>black</font>, and <i><b>N</b></i> is the left child of its parent. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_delete_case_5.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * <p> In this case we rotate right at {@link XTreeNode.sibling <b>S</b>}, so that
-         * {@link XTreeNode.sibling <b>S</b>}'s left child becomes {@link XTreeNode.sibling <b>S</b>}'s parent and
-         * <i><b>N</b></i>'s new sibling. We then exchange the colors of {@link XTreeNode.sibling <b>S</b>} and its
-         * new parent. </p>
-         *
-         * <p> All paths still have the same number of <font color='darkBlue'>black</font> nodes, but now
-         * <i><b>N</b></i> has a <font color='darkBlue'>black</font> sibling whose right child is
-         * <font color='red'>red</font>, so we fall into case 6. Neither <i><b>N</b></i> nor its parent are affected
-         * by this transformation. (Again, for case 6, we relabel <i><b>N</b></i>'s new sibling as
-         * {@link XTreeNode.sibling <b>S</b>}.) </p>
-         *
-         * @param N A node to be erased or swapped.
-         */
-        private erase_case5(N);
-        /**
-         * <p> {@link XTreeNode.sibling <b>S</b>} is <font color='darkBlue'>black</font>,
-         * {@link XTreeNode.sibling <b>S</b>}'s right child is <font color='red'>red</font>, and <i><b>N</b></i> is
-         * the left child of its parent {@link XTreeNode.parent <b>P</b>}. </p>
-         *
-         * <p> In this case we rotate left at {@link XTreeNode.parent <b>P</b>}, so that
-         * {@link XTreeNode.sibling <b>S</b>} becomes the parent of {@link XTreeNode.parent <b>P</b>} and
-         * {@link XTreeNode.sibling <b>S</b>}'s right child. We then exchange the colors of
-         * {@link XTreeNode.parent <b>P</b>} and {@link XTreeNode.sibling <b>S</b>}, and make
-         * {@link XTreeNode.sibling <b>S</b>}'s right child <font color='darkBlue'>black</font>. </p>
-         *
-         * <p> The subtree still has the same color at its root, so Properties 4 (Both children of every
-         * <font color='red'>red</font> node are <font color='darkBlue'>black</font>) and 5 (All paths from any
-         * given node to its leaf nodes contain the same number of <font color='darkBlue'>black</font> nodes) are
-         * not violated. However, <i><b>N</b></i> now has one additional <font color='darkBlue'>black</font>
-         * ancestor: either {@link XTreeNode.parent <b>P</b>} has become <font color='darkBlue'>black</font>, or it
-         * was <font color='darkBlue'>black</font> and {@link XTreeNode.sibling <b>S</b>} was added as a
-         * <font color='darkBlue'>black</font> grandparent. </p>
-         *
-         * <p> Thus, the paths passing through <i><b>N</b></i> pass through one additional
-         * <font color='darkBlue'>black</font> node. </p>
-         *
-         * <p> <img src="http://samchon.github.io/typescript-stl/images/design/conceptual_diagram/Red-black_tree_delete_case_6.svg"
-                    style="max-width: 100%" /> </p>
-         *
-         * <p> Meanwhile, if a path does not go through <i><b>N</b></i>, then there are two possibilities: </p>
-         * <ol>
-         *	<li>
-         *		It goes through <i><b>N</b></i>'s new sibling <b>SL</b>, a node with arbitrary color and the root of
-         *		the subtree labeled 3 (s. diagram). Then, it must go through {@link XTreeNode.sibling <b>S</b>} and
-         *		{@link XTreeNode.parent <b>P</b>}, both formerly and currently, as they have only exchanged colors
-         *		and places. Thus the path contains the same number of <font color='darkBlue'>black</font> nodes.
-         *	</li>
-         *	<li>
-         *		It goes through <i><b>N</b></i>'s new uncle, {@link XTreeNode.sibling <b>S</b>}'s right child. Then,
-         *		it formerly went through {@link XTreeNode.sibling <b>S</b>}, {@link XTreeNode.sibling <b>S</b>}'s
-         *		parent, and {@link XTreeNode.sibling <b>S</b>}'s right child <b>SR</b> (which was
-         *		<font color='red'>red</font>), but now only goes through {@link XTreeNode.sibling <b>S</b>}, which
-         *		has assumed the color of its former parent, and {@link XTreeNode.sibling <b>S</b>}'s right child,
-         *		which has changed from <font color='red'>red</font> to <font color='darkBlue'>black</font> (assuming
-         *		{@link XTreeNode.sibling <b>S</b>}'s color: <font color='darkBlue'>black</font>). The net effect is
-         *		that this path goes through the same number of <font color='darkBlue'>black</font> nodes.
-         *	</li>
-         * </ol>
-         *
-         * <p> Either way, the number of <font color='darkBlue'>black</font> nodes on these paths does not change.
-         * Thus, we have restored Properties 4 (Both children of every <font color='red'>red</font> node are
-         * <font color='darkBlue'>black</font>) and 5 (All paths from any given node to its leaf nodes contain the
-         * same number of <font color='darkBlue'>black</font> nodes). The white node in the diagram can be either
-         * <font color='red'>red</font> or <font color='darkBlue'>black</font>, but must refer to the same color
-         * both before and after the transformation. </p>
-         *
-         * @param N A node to be erased or swapped.
-         */
-        private erase_case6(node);
-        /**
-         * Rotate a node left.
-         *
-         * @param node Node to rotate left.
-         */
-        protected rotate_left(node: XTreeNode<T>): void;
-        /**
-         * Rotate a node to right.
-         *
-         * @param node A node to rotate right.
-         */
-        protected rotate_right(node: XTreeNode<T>): void;
-        /**
-         * Replace a node.
-         *
-         * @param oldNode Ordinary node to be replaced.
-         * @param newNode Target node to replace.
-         */
-        protected replace_node(oldNode: XTreeNode<T>, newNode: XTreeNode<T>): void;
-        /**
-         * Fetch color from a node.
-         *
-         * @param node A node to fetch color.
-         * @retur color.
-         */
-        private fetch_color(node);
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> Common interface for tree-structured map. </p>
-     *
-     * <p> {@link ITreeMap ITreeMaps} are associative containers that store elements formed by a combination of
-     * a <i>key value</i> and a <i>mapped value</i>, following a specific order. </p>
-     *
-     * <p> In a {@link ITreeMap}, the <i>key values</i> are generally used to sort and uniquely identify
-     * the elements, while the <i>mapped values</i> store the content associated to this <i>key</i>. The types of
-     * <i>key</i> and <i>mapped value</i> may differ, and are grouped together in member type
-     * <code>value_type</code>, which is a {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef Pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> Internally, the elements in a {@link ITreeMap}are always sorted by its key following a
-     * strict weak ordering criterion indicated by its internal comparison method (of {@link less}). </p>
-     *
-     * <p> {@link ITreeMap}containers are generally slower than {@link IHashMap} containers
-     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based
-     * on their order. </p>
-     *
-     * <p> {@link ITreeMap TreeMultiMaps} are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
-     *		 given a position in this order. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/map
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface ITreeMap<Key, T> {
-        /**
-         * <p> Return key comparison function. </p>
-         *
-         * <p> Returns a references of the comparison function used by the container to compare <i>keys</i>. </p>
-         *
-         * <p> The <i>comparison object</i> of a {@link ITreeMap tree-map object} is set on
-         * {@link TreeMap.constructor construction}. Its type (<i>Key</i>) is the last parameter of the
-         * {@link ITreeMap.constructor constructors}. By default, this is a {@link less} function, which returns the same
-         * as <i>operator&lt;</i>. </p>
-         *
-         * <p> This function determines the order of the elements in the container: it is a function pointer that takes
-         * two arguments of the same type as the element <i>keys</i>, and returns <code>true</code> if the first argument
-         * is considered to go before the second in the strict weak ordering it defines, and <code>false</code> otherwise.
-         * </p>
-         *
-         * <p> Two keys are considered equivalent if {@link key_comp} returns <code>false</code> reflexively (i.e., no
-         * matter the order in which the keys are passed as arguments). </p>
-         *
-         * @return The comparison function.
-         */
-        key_comp(): (x: Key, y: Key) => boolean;
-        /**
-         * <p> Return value comparison function. </p>
-         *
-         * <p> Returns a comparison function that can be used to compare two elements to get whether the key of the first
-         * one goes before the second. </p>
-         *
-         * <p> The arguments taken by this function object are of member type <code>std.Pair<Key, T></code> (defined in
-         * {@link ITreeMap}), but the mapped type (<i>T</i>) part of the value is not taken into consideration in this
-         * comparison. </p>
-         *
-         * <p> This comparison class returns <code>true</code> if the {@link Pair.first key} of the <i>first argument</i>
-         * is considered to go before that of the <i>second</i> (according to the strict weak ordering specified by the
-         * container's comparison function, {@link key_comp}), and <code>false</code> otherwise. </p>
-         *
-         * @return The comparison function for element values.
-         */
-        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
-        /**
-         * <p> Return iterator to lower bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container whose key is not considered to
-         * go before <i>k</i> (i.e., either it is equivalent or goes after). </p>
-         *
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(<i>k</i>, element_key) would return false. </p>
-         *
-         * <p> If the {@link ITreeMap} class is instantiated with the default comparison type ({@link less}),
-         * the function returns an iterator to the first element whose key is not less than <i>k</i> </p>.
-         *
-         * <p> A similar member function, {@link upper_bound}, has the same behavior as {@link lower_bound}, except
-         * in the case that the {@link ITreeMap} contains an element with a key equivalent to <i>k</i>: In this
-         * case, {@link lower_bound} returns an iterator pointing to that element, whereas {@link upper_bound}
-         * returns an iterator pointing to the next element. </p>
-         *
-         * @param k Key to search for.
-         *
-         * @return An iterator to the the first element in the container whose key is not considered to go before
-         *		   <i>k</i>, or {@link ITreeMap.end} if all keys are considered to go before <i>k</i>.
-         */
-        lower_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to upper bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container whose key is considered to
-         * go after <i>k</i> </p>.
-         *
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(<i>k</i>, element_key) would return true. </p>
-         *
-         * <p> If the {@link ITreeMap} class is instantiated with the default comparison type ({@link less}),
-         * the function returns an iterator to the first element whose key is greater than <i>k</i> </p>.
-         *
-         * <p> A similar member function, {@link lower_bound}, has the same behavior as {@link upper_bound}, except
-         * in the case that the map contains an element with a key equivalent to <i>k</i>: In this case
-         * {@link lower_bound} returns an iterator pointing to that element, whereas {@link upper_bound} returns an
-         * iterator pointing to the next element. </p>
-         *
-         * @param k Key to search for.
-         *
-         * @return An iterator to the the first element in the container whose key is considered to go after
-         *		   <i>k</i>, or {@link TreeMap.end end} if no keys are considered to go after <i>k</i>.
-         */
-        upper_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * <p> Get range of equal elements. </p>
-         *
-         * <p> Returns the bounds of a range that includes all the elements in the container which have a key
-         * equivalent to <i>k</i> </p>.
-         *
-         * <p> If no matches are found, the range returned has a length of zero, with both iterators pointing to
-         * the first element that has a key considered to go after <i>k</i> according to the container's internal
-         * comparison object (key_comp). </p>
-         *
-         * <p> Two keys are considered equivalent if the container's comparison object returns false reflexively
-         * (i.e., no matter the order in which the keys are passed as arguments). </p>
-         *
-         * @param k Key to search for.
-         *
-         * @return The function returns a {@link Pair}, whose member {@link Pair.first} is the lower bound of
-         *		   the range (the same as {@link lower_bound}), and {@link Pair.second} is the upper bound
-         *		   (the same as {@link upper_bound}).
-         */
-        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> A red-black tree storing {@link MapIterator MapIterators}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class PairTree<Key, T> extends XTree<MapIterator<Key, T>> {
-        /**
-         * @hidden
-         */
-        private map_;
-        /**
-         * @hidden
-         */
-        private compare_;
-        /**
-         * Default Constructor.
-         */
-        constructor(map: TreeMap<Key, T> | TreeMultiMap<Key, T>, compare?: (x: Key, y: Key) => boolean);
-        find(key: Key): XTreeNode<MapIterator<Key, T>>;
-        find(it: MapIterator<Key, T>): XTreeNode<MapIterator<Key, T>>;
-        /**
-         * @hidden
-         */
-        private find_by_key(key);
-        /**
-         * <p> Return iterator to lower bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container whose key is not considered to
-         * go before <i>k</i> (i.e., either it is equivalent or goes after). </p>
-         *
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(<i>k</i>, element_key) would return false. </p>
-         *
-         * <p> If the {@link ITreeMap} class is instantiated with the default comparison type ({@link less}),
-         * the function returns an iterator to the first element whose key is not less than <i>k</i> </p>.
-         *
-         * <p> A similar member function, {@link upper_bound}, has the same behavior as {@link lower_bound}, except
-         * in the case that the {@link ITreeMap} contains an element with a key equivalent to <i>k</i>: In this
-         * case, {@link lower_bound} returns an iterator pointing to that element, whereas {@link upper_bound}
-         * returns an iterator pointing to the next element. </p>
-         *
-         * @param k Key to search for.
-         *
-         * @return An iterator to the the first element in the container whose key is not considered to go before
-         *		   <i>k</i>, or {@link ITreeMap.end} if all keys are considered to go before <i>k</i>.
-         */
-        lower_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to upper bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container whose key is considered to
-         * go after <i>k</i> </p>.
-         *
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(<i>k</i>, element_key) would return true. </p>
-         *
-         * <p> If the {@link ITreeMap} class is instantiated with the default comparison type ({@link less}),
-         * the function returns an iterator to the first element whose key is greater than <i>k</i> </p>.
-         *
-         * <p> A similar member function, {@link lower_bound}, has the same behavior as {@link upper_bound}, except
-         * in the case that the map contains an element with a key equivalent to <i>k</i>: In this case
-         * {@link lower_bound} returns an iterator pointing to that element, whereas {@link upper_bound} returns an
-         * iterator pointing to the next element. </p>
-         *
-         * @param k Key to search for.
-         *
-         * @return An iterator to the the first element in the container whose key is considered to go after
-         *		   <i>k</i>, or {@link TreeMap.end end} if no keys are considered to go after <i>k</i>.
-         */
-        upper_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * <p> Get range of equal elements. </p>
-         *
-         * <p> Returns the bounds of a range that includes all the elements in the container which have a key
-         * equivalent to <i>k</i> </p>.
-         *
-         * <p> If no matches are found, the range returned has a length of zero, with both iterators pointing to
-         * the first element that has a key considered to go after <i>k</i> according to the container's internal
-         * comparison object (key_comp). </p>
-         *
-         * <p> Two keys are considered equivalent if the container's comparison object returns false reflexively
-         * (i.e., no matter the order in which the keys are passed as arguments). </p>
-         *
-         * @param k Key to search for.
-         *
-         * @return The function returns a {@link Pair}, whose member {@link Pair.first} is the lower bound of
-         *		   the range (the same as {@link lower_bound}), and {@link Pair.second} is the upper bound
-         *		   (the same as {@link upper_bound}).
-         */
-        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
-        /**
-         * <p> Return key comparison function. </p>
-         *
-         * <p> Returns a references of the comparison function used by the container to compare <i>keys</i>. </p>
-         *
-         * <p> The <i>comparison object</i> of a {@link ITreeMap tree-map object} is set on
-         * {@link TreeMap.constructor construction}. Its type (<i>Key</i>) is the last parameter of the
-         * {@link ITreeMap.constructor constructors}. By default, this is a {@link less} function, which returns the same
-         * as <i>operator&lt;</i>. </p>
-         *
-         * <p> This function determines the order of the elements in the container: it is a function pointer that takes
-         * two arguments of the same type as the element <i>keys</i>, and returns <code>true</code> if the first argument
-         * is considered to go before the second in the strict weak ordering it defines, and <code>false</code> otherwise.
-         * </p>
-         *
-         * <p> Two keys are considered equivalent if {@link key_comp} returns <code>false</code> reflexively (i.e., no
-         * matter the order in which the keys are passed as arguments). </p>
-         *
-         * @return The comparison function.
-         */
-        key_comp(): (x: Key, y: Key) => boolean;
-        /**
-         * <p> Return value comparison function. </p>
-         *
-         * <p> Returns a comparison function that can be used to compare two elements to get whether the key of the first
-         * one goes before the second. </p>
-         *
-         * <p> The arguments taken by this function object are of member type <code>std.Pair<Key, T></code> (defined in
-         * {@link ITreeMap}), but the mapped type (<i>T</i>) part of the value is not taken into consideration in this
-         * comparison. </p>
-         *
-         * <p> This comparison class returns <code>true</code> if the {@link Pair.first key} of the <i>first argument</i>
-         * is considered to go before that of the <i>second</i> (according to the strict weak ordering specified by the
-         * container's comparison function, {@link key_comp}), and <code>false</code> otherwise. </p>
-         *
-         * @return The comparison function for element values.
-         */
-        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
-        /**
-         * @inheritdoc
-         */
-        is_equal_to(left: MapIterator<Key, T>, right: MapIterator<Key, T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        is_less(left: MapIterator<Key, T>, right: MapIterator<Key, T>): boolean;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> A common interface for tree-structured set. </p>
-     *
-     * <p> {@link ITreeSet TreeMultiSets} are containers that store elements following a specific order. </p>
-     *
-     * <p> In a {@link ITreeSet}, the value of an element also identifies it (the value is itself
-     * the <i>key</i>, of type <i>T</i>). The value of the elements in a {@link ITreeSet} cannot
-     * be modified once in the container (the elements are always const), but they can be inserted or removed
-     * from the  </p>
-     *
-     * <p> Internally, the elements in a {@link ITreeSet TreeMultiSets} are always sorted following a strict
-     * weak ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}). </p>
-     *
-     * <p> {@link ITreeSet} containers are generally slower than {@link IHashSet} containers
-     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on
-     * their order. </p>
-     *
-     * <p> {@link ITreeSet TreeMultiSets} are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link ITreeSet} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @reference http://www.cplusplus.com/reference/set
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface ITreeSet<T> {
-        /**
-         * <p> Return comparison function. </p>
-         *
-         * <p> Returns a copy of the comparison function used by the container. </p>
-         *
-         * <p> By default, this is a {@link less} object, which returns the same as <i>operator<</i>. </p>
-         *
-         * <p> This object determines the order of the elements in the container: it is a function pointer or a function
-         * object that takes two arguments of the same type as the container elements, and returns <code>true</code> if
-         * the <i>first argument</i> is considered to go before the <i>second</i> in the <i>strict weak ordering</i> it
-         * defines, and <code>false</code> otherwise. </p>
-         *
-         * <p> Two elements of a {@link ITreeSet} are considered equivalent if {@link key_comp} returns <code>false</code>
-         * reflexively (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * <p> In {@link ITreeSet} containers, the <i>keys</i> to sort the elements are the values (<i>T</i>) themselves,
-         * therefore {@link key_comp} and its sibling member function {@link value_comp} are equivalent. </p>
-         *
-         * @return The comparison function.
-         */
-        key_comp(): (x: T, y: T) => boolean;
-        /**
-         * <p> Return comparison function. </p>
-         *
-         * <p> Returns a copy of the comparison function used by the container. </p>
-         *
-         * <p> By default, this is a {@link less} object, which returns the same as <i>operator<</i>. </p>
-         *
-         * <p> This object determines the order of the elements in the container: it is a function pointer or a function
-         * object that takes two arguments of the same type as the container elements, and returns <code>true</code> if
-         * the <i>first argument</i> is considered to go before the <i>second</i> in the <i>strict weak ordering</i> it
-         * defines, and <code>false</code> otherwise. </p>
-         *
-         * <p> Two elements of a {@link ITreeSet} are considered equivalent if {@link key_comp} returns <code>false</code>
-         * reflexively (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * <p> In {@link ITreeSet} containers, the <i>keys</i> to sort the elements are the values (<i>T</i>) themselves,
-         * therefore {@link key_comp} and its sibling member function {@link value_comp} are equivalent. </p>
-         *
-         * @return The comparison function.
-         */
-        value_comp(): (x: T, y: T) => boolean;
-        /**
-         * <p> Return iterator to lower bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container which is not considered to
-         * go before <i>val</i> (i.e., either it is equivalent or goes after). </p>
-         *
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(element,val) would return false. </p>
-         *
-         * <p> If the {@link ITreeSet} class is instantiated with the default comparison type ({@link less}),
-         * the function returns an iterator to the first element that is not less than <i>val</i>. </p>
-
-         * <p> A similar member function, {@link upper_bound}, has the same behavior as {@link lower_bound}, except
-         * in the case that the {@link ITreeSet} contains elements equivalent to <i>val</i>: In this case
-         * {@link lower_bound} returns an iterator pointing to the first of such elements, whereas
-         * {@link upper_bound} returns an iterator pointing to the element following the last. </p>
-         *
-         * @param val Value to compare.
-         *
-         * @return An iterator to the the first element in the container which is not considered to go before
-         *		   <i>val</i>, or {@link ITreeSet.end} if all elements are considered to go before <i>val</i>.
-         */
-        lower_bound(val: T): SetIterator<T>;
-        /**
-         * <p> Return iterator to upper bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container which is considered to go after
-         * <i>val</i>. </p>
-
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(val,element) would return true. </p>
-
-         * <p> If the {@code ITreeSet} class is instantiated with the default comparison type (less), the
-         * function returns an iterator to the first element that is greater than <i>val</i>. </p>
-         *
-         * <p> A similar member function, {@link lower_bound}, has the same behavior as {@link upper_bound}, except
-         * in the case that the {@ITreeSet} contains elements equivalent to <i>val</i>: In this case
-         * {@link lower_bound} returns an iterator pointing to the first of such elements, whereas
-         * {@link upper_bound} returns an iterator pointing to the element following the last. </p>
-         *
-         * @param val Value to compare.
-         *
-         * @return An iterator to the the first element in the container which is considered to go after
-         *		   <i>val</i>, or {@link TreeSet.end end} if no elements are considered to go after <i>val</i>.
-         */
-        upper_bound(val: T): SetIterator<T>;
-        /**
-         * <p> Get range of equal elements. </p>
-         *
-         * <p> Returns the bounds of a range that includes all the elements in the container that are equivalent
-         * to <i>val</i>. </p>
-         *
-         * <p> If no matches are found, the range returned has a length of zero, with both iterators pointing to
-         * the first element that is considered to go after val according to the container's
-         * internal comparison object (key_comp). </p>
-         *
-         * <p> Two elements of a multiset are considered equivalent if the container's comparison object returns
-         * false reflexively (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * @param key Value to search for.
-         *
-         * @return The function returns a {@link Pair}, whose member {@link Pair.first} is the lower bound of
-         *		   the range (the same as {@link lower_bound}), and {@link Pair.second} is the upper bound
-         *		   (the same as {@link upper_bound}).
-         */
-        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> A red-black Tree storing {@link SetIterator SetIterators}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class AtomicTree<T> extends XTree<SetIterator<T>> {
-        /**
-         * @hidden
-         */
-        private set_;
-        /**
-         * @hidden
-         */
-        private compare_;
-        /**
-         * Default Constructor.
-         */
-        constructor(set: TreeSet<T> | TreeMultiSet<T>, compare?: (x: T, y: T) => boolean);
-        find(val: T): XTreeNode<SetIterator<T>>;
-        find(it: SetIterator<T>): XTreeNode<SetIterator<T>>;
-        /**
-         * @hidden
-         */
-        private find_by_val(val);
-        /**
-         * <p> Return iterator to lower bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container which is not considered to
-         * go before <i>val</i> (i.e., either it is equivalent or goes after). </p>
-         *
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(element,val) would return false. </p>
-         *
-         * <p> If the {@link ITreeSet} class is instantiated with the default comparison type ({@link less}),
-         * the function returns an iterator to the first element that is not less than <i>val</i>. </p>
-
-         * <p> A similar member function, {@link upper_bound}, has the same behavior as {@link lower_bound}, except
-         * in the case that the {@link ITreeSet} contains elements equivalent to <i>val</i>: In this case
-         * {@link lower_bound} returns an iterator pointing to the first of such elements, whereas
-         * {@link upper_bound} returns an iterator pointing to the element following the last. </p>
-         *
-         * @param val Value to compare.
-         *
-         * @return An iterator to the the first element in the container which is not considered to go before
-         *		   <i>val</i>, or {@link ITreeSet.end} if all elements are considered to go before <i>val</i>.
-         */
-        lower_bound(val: T): SetIterator<T>;
-        /**
-         * <p> Return iterator to upper bound. </p>
-         *
-         * <p> Returns an iterator pointing to the first element in the container which is considered to go after
-         * <i>val</i>. </p>
-
-         * <p> The function uses its internal comparison object (key_comp) to determine this, returning an
-         * iterator to the first element for which key_comp(val,element) would return true. </p>
-
-         * <p> If the {@code ITreeSet} class is instantiated with the default comparison type (less), the
-         * function returns an iterator to the first element that is greater than <i>val</i>. </p>
-         *
-         * <p> A similar member function, {@link lower_bound}, has the same behavior as {@link upper_bound}, except
-         * in the case that the {@ITreeSet} contains elements equivalent to <i>val</i>: In this case
-         * {@link lower_bound} returns an iterator pointing to the first of such elements, whereas
-         * {@link upper_bound} returns an iterator pointing to the element following the last. </p>
-         *
-         * @param val Value to compare.
-         *
-         * @return An iterator to the the first element in the container which is considered to go after
-         *		   <i>val</i>, or {@link TreeSet.end end} if no elements are considered to go after <i>val</i>.
-         */
-        upper_bound(val: T): SetIterator<T>;
-        /**
-         * <p> Get range of equal elements. </p>
-         *
-         * <p> Returns the bounds of a range that includes all the elements in the container that are equivalent
-         * to <i>val</i>. </p>
-         *
-         * <p> If no matches are found, the range returned has a length of zero, with both iterators pointing to
-         * the first element that is considered to go after val according to the container's
-         * internal comparison object (key_comp). </p>
-         *
-         * <p> Two elements of a multiset are considered equivalent if the container's comparison object returns
-         * false reflexively (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * @param key Value to search for.
-         *
-         * @return The function returns a {@link Pair}, whose member {@link Pair.first} is the lower bound of
-         *		   the range (the same as {@link lower_bound}), and {@link Pair.second} is the upper bound
-         *		   (the same as {@link upper_bound}).
-         */
-        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
-        /**
-         * <p> Return comparison function. </p>
-         *
-         * <p> Returns a copy of the comparison function used by the container. </p>
-         *
-         * <p> By default, this is a {@link less} object, which returns the same as <i>operator<</i>. </p>
-         *
-         * <p> This object determines the order of the elements in the container: it is a function pointer or a function
-         * object that takes two arguments of the same type as the container elements, and returns <code>true</code> if
-         * the <i>first argument</i> is considered to go before the <i>second</i> in the <i>strict weak ordering</i> it
-         * defines, and <code>false</code> otherwise. </p>
-         *
-         * <p> Two elements of a {@link ITreeSet} are considered equivalent if {@link key_comp} returns <code>false</code>
-         * reflexively (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * <p> In {@link ITreeSet} containers, the <i>keys</i> to sort the elements are the values (<i>T</i>) themselves,
-         * therefore {@link key_comp} and its sibling member function {@link value_comp} are equivalent. </p>
-         *
-         * @return The comparison function.
-         */
-        key_comp(): (x: T, y: T) => boolean;
-        /**
-         * <p> Return comparison function. </p>
-         *
-         * <p> Returns a copy of the comparison function used by the container. </p>
-         *
-         * <p> By default, this is a {@link less} object, which returns the same as <i>operator<</i>. </p>
-         *
-         * <p> This object determines the order of the elements in the container: it is a function pointer or a function
-         * object that takes two arguments of the same type as the container elements, and returns <code>true</code> if
-         * the <i>first argument</i> is considered to go before the <i>second</i> in the <i>strict weak ordering</i> it
-         * defines, and <code>false</code> otherwise. </p>
-         *
-         * <p> Two elements of a {@link ITreeSet} are considered equivalent if {@link key_comp} returns <code>false</code>
-         * reflexively (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * <p> In {@link ITreeSet} containers, the <i>keys</i> to sort the elements are the values (<i>T</i>) themselves,
-         * therefore {@link key_comp} and its sibling member function {@link value_comp} are equivalent. </p>
-         *
-         * @return The comparison function.
-         */
-        value_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        is_equal_to(left: SetIterator<T>, right: SetIterator<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        is_less(left: SetIterator<T>, right: SetIterator<T>): boolean;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract unique-map. </p>
-     *
-     * <p> {@link UniqueMap UniqueMaps} are associative containers that store elements formed by a combination of a
-     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
-     * individual elements based on their keys. </p>
-     *
-     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to uniquely identify the elements,
-     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
-     * {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
-     *		in the container.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class UniqueMap<Key, T> extends MapContainer<Key, T> {
-        /**
-         * @inheritdoc
-         */
-        count(key: Key): number;
-        /**
-         * <p> Get an element </p>
-         *
-         * <p> Returns a reference to the mapped value of the element identified with <i>key</i>. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @throw exception out of range
-         *
-         * @return A reference object of the mapped value (_Ty)
-         */
-        get(key: Key): T;
-        /**
-         * <p> Set an item as the specified identifier. </p>
-         *
-         * <p>If the identifier is already in map, change value of the identifier. If not, then insert the object
-         * with the identifier. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         * @param val Value, the item.
-         */
-        set(key: Key, val: T): void;
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
-         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
-         * {@link Pair} type).
-         *
-         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
-         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
-         *
-         * If inserted, this effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return If the function successfully inserts the element (because no equivalent element existed already in
-         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
-         *		   the newly inserted element and a value of true. Otherwise, it returns an
-         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
-         */
-        emplace(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
-         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
-         * {@link Pair} type).
-         *
-         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
-         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
-         *
-         * If inserted, this effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return If the function successfully inserts the element (because no equivalent element existed already in
-         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
-         *		   the newly inserted element and a value of true. Otherwise, it returns an
-         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
-         */
-        emplace(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * one. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is not inserted, returning an iterator to this existing element (if the function
-         * returns a value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent key already existed.
-         */
-        insert(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting a new element, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is not inserted, returning an iterator to this existing element (if the function
-         * returns a value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent key already existed.
-         */
-        insert<L extends Key, U extends T>(tuple: [L, U]): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * <p> Insert or assign an element. </p>
-         *
-         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
-         * value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent key already existed so the <i>value</i> is assigned.
-         */
-        insert_or_assign(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * <p> Insert or assign an element. </p>
-         *
-         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
-         * value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link UniqueMap}.
-         */
-        insert_or_assign(hint: MapIterator<Key, T>, key: Key, value: T): MapIterator<Key, T>;
-        /**
-         * <p> Insert or assign an element. </p>
-         *
-         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
-         * value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link UniqueMap}.
-         */
-        insert_or_assign(hint: MapReverseIterator<Key, T>, key: Key, value: T): MapReverseIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private insert_or_assign_with_key_value(key, value);
-        /**
-         * @hidden
-         */
-        private insert_or_assign_with_hint(hint, key, value);
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @return A {@link Pair} containing the value pointed to by <i>key</i>.
-         */
-        extract(key: Key): Pair<Key, T>;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: MapIterator<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private extract_by_key(key);
-        /**
-         * @hidden
-         */
-        private extract_by_iterator(it);
-        /**
-         * @hidden
-         */
-        private extract_by_reverse_iterator(it);
-        /**
-         * Merge two maps.
-         *
-         * Attempts to extract each element in *source* and insert it into this container. If there's an element in this
-         * container with key equivalent to the key of an element from *source*, tnen that element is not extracted from
-         * the *source*. Otherwise, no element with same key exists in this container, then that element will be
-         * transfered from the *source* to this container.
-         *
-         * @param source A {@link MapContainer map container} to transfer the elements from.
-         */
-        merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract set. </p>
-     *
-     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
-     * individual elements based on their value. </p>
-     *
-     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to uniquely
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be modified
-     * once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class UniqueSet<T> extends SetContainer<T> {
-        /**
-         * @inheritdoc
-         */
-        count(key: T): number;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of element inserted (zero or one). </p>
-         *
-         * <p> Because elements in a {@link UniqueSet UniqueSets} are unique, the insertion operation checks whether
-         * each inserted element is equivalent to an element already in the container, and if so, the element is not
-         * inserted, returning an iterator to this existing element (if the function returns a value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiSet}. </p>
-         *
-         * @param key Value to be inserted as an element.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the equivalent element already in the {@link UniqueSet}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent element already existed.
-         */
-        insert(val: T): Pair<SetIterator<T>, boolean>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>val</i> and erases it from the {@link UniqueSet}. </p>
-         *
-         * @param val Value to be extracted.
-         *
-         * @return A value.
-         */
-        extract(val: T): T;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: SetIterator<T>): SetIterator<T>;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: SetReverseIterator<T>): SetReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private extract_by_key(val);
-        /**
-         * @hidden
-         */
-        private extract_by_iterator(it);
-        /**
-         * @hidden
-         */
-        private extract_by_reverse_iterator(it);
-        /**
-         * Merge two sets.
-         *
-         * Attempts to extract each element in *source* and insert it into this container. If there's an element in this
-         * container with key equivalent to the key of an element from *source*, tnen that element is not extracted from
-         * the *source*. Otherwise, no element with same key exists in this container, then that element will be
-         * transfered from the *source* to this container.
-         *
-         * @param source A {@link SetContainer set container} to transfer the elements from.
-         */
-        merge<U extends T>(source: SetContainer<U>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> A node in an XTree. </p>
-     *
-     * @param <T> Type of elements.
-     *
-     * @inventor Rudolf Bayer
-     * @author Migrated by Jeongho Nam <http://samchon.org>
-     */
-    class XTreeNode<T> {
-        /**
-         * Parent of the node.
-         */
-        parent: XTreeNode<T>;
-        /**
-         * Left child in the node.
-         */
-        left: XTreeNode<T>;
-        /**
-         * Right child in the node.
-         */
-        right: XTreeNode<T>;
-        /**
-         * Value stored in the node.
-         */
-        value: T;
-        /**
-         * Color of the node.
-         */
-        color: Color;
-        /**
-         * Construct from value and color of node.
-         *
-         * @param value Value to be stored in.
-         * @param color Color of the node, red or black.
-         */
-        constructor(value: T, color: Color);
-        /**
-         * Get grand-parent.
-         */
-        readonly grand_parent: XTreeNode<T>;
-        /**
-         * Get sibling, opposite side node in same parent.
-         */
-        readonly sibling: XTreeNode<T>;
-        /**
-         * Get uncle, parent's sibling.
-         */
-        readonly uncle: XTreeNode<T>;
-    }
-}
-declare namespace std.Deque {
-    type iterator<T> = std.DequeIterator<T>;
-    type reverse_iterator<T> = std.DequeReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Double ended queue. </p>
-     *
-     * <p> {@link Deque} (usually pronounced like "<i>deck</i>") is an irregular acronym of
-     * <b>d</b>ouble-<b>e</b>nded <b>q</b>ueue. Double-ended queues are sequence containers with dynamic sizes that can be
-     * expanded or contracted on both ends (either its front or its back). </p>
-     *
-     * <p> Specific libraries may implement deques in different ways, generally as some form of dynamic array. But in any
-     * case, they allow for the individual elements to be accessed directly through random access iterators, with storage
-     * handled automatically by expanding and contracting the container as needed. </p>
-     *
-     * <p> Therefore, they provide a functionality similar to vectors, but with efficient insertion and deletion of
-     * elements also at the beginning of the sequence, and not only at its end. But, unlike {@link Vector Vectors},
-     * {@link Deque Deques} are not guaranteed to store all its elements in contiguous storage locations: accessing
-     * elements in a <u>deque</u> by offsetting a pointer to another element causes undefined behavior. </p>
-     *
-     * <p> Both {@link Vector}s and {@link Deque}s provide a very similar interface and can be used for similar purposes,
-     * but internally both work in quite different ways: While {@link Vector}s use a single array that needs to be
-     * occasionally reallocated for growth, the elements of a {@link Deque} can be scattered in different chunks of
-     * storage, with the container keeping the necessary information internally to provide direct access to any of its
-     * elements in constant time and with a uniform sequential interface (through iterators). Therefore,
-     * {@link Deque Deques} are a little more complex internally than {@link Vector}s, but this allows them to grow more
-     * efficiently under certain circumstances, especially with very long sequences, where reallocations become more
-     * expensive. </p>
-     *
-     * <p> For operations that involve frequent insertion or removals of elements at positions other than the beginning or
-     * the end, {@link Deque Deques} perform worse and have less consistent iterators and references than
-     * {@link List Lists}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Sequence </dt>
-     *	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements
-     *		 are accessed by their position in this sequence. </dd>
-     *
-     *	<dt> Dynamic array </dt>
-     *	<dd> Generally implemented as a dynamic array, it allows direct access to any element in the
-     *		 sequence and provides relatively fast addition/removal of elements at the beginning or the end
-     *		 of the sequence. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/deque/deque/
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Deque<T> extends base.Container<T> implements base.IArrayContainer<T>, base.IDequeContainer<T> {
-        /**
-         * @hidden
-         */
-        private static readonly ROW;
-        /**
-         * @hidden
-         */
-        private static readonly MIN_CAPACITY;
-        /**
-         * @hidden
-         */
-        private matrix_;
-        /**
-         * @hidden
-         */
-        private size_;
-        /**
-         * @hidden
-         */
-        private capacity_;
-        /**
-         * @hidden
-         */
-        private get_col_size();
-        /**
-         * @hidden
-         */
-        private end_;
-        /**
-         * @hidden
-         */
-        private rend_;
-        /**
-         * <p> Default Constructor. </p>
-         *
-         * <p> Constructs an empty container, with no elements. </p>
-         */
-        constructor();
-        /**
-         * <p> Initializer list Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
-         *
-         * @param array An array containing elements to be copied and contained.
-         */
-        constructor(items: Array<T>);
-        /**
-         * <p> Fill Constructor. </p>
-         *
-         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
-         *
-         * @param n Initial container size (i.e., the number of elements in the container at construction).
-         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
-         *			  initialized to a copy of this value.
-         */
-        constructor(size: number, val: T);
-        /**
-         * <p> Copy Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
-         *
-         * @param container Another container object of the same type (with the same class template
-         *					arguments <i>T</i>), whose contents are either copied or acquired.
-         */
-        constructor(container: Deque<T>);
-        /**
-         * <p> Range Constructor. </p>
-         *
-         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
-         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        assign(n: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        reserve(capacity: number): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        begin(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        empty(): boolean;
-        /**
-         * @inheritdoc
-         */
-        capacity(): number;
-        /**
-         * @inheritdoc
-         */
-        at(index: number): T;
-        /**
-         * @inheritdoc
-         */
-        set(index: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        front(): T;
-        /**
-         * @inheritdoc
-         */
-        back(): T;
-        /**
-        // Fetch row and column's index.
-        /**
-         * @hidden
-         */
-        private fetch_index(index);
-        /**
-         * @inheritdoc
-         */
-        push(...items: T[]): number;
-        /**
-         * @inheritdoc
-         */
-        push_front(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        pop_front(): void;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeIterator<T>, val: T): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeIterator<T>, n: number, val: T): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeIterator<T>, begin: InputIterator, end: InputIterator): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeReverseIterator<T>, val: T): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeReverseIterator<T>, n: number, val: T): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeReverseIterator<T>, begin: InputIterator, end: InputIterator): DequeReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private insert_by_val(position, val);
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: DequeIterator<T>, n: number, val: T): DequeIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(position: DequeIterator<T>, begin: InputIterator, end: InputIterator): DequeIterator<T>;
-        /**
-         * @hidden
-         */
-        private insert_by_items(position, items);
-        /**
-         * @inheritdoc
-         */
-        erase(position: DequeIterator<T>): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(position: DequeReverseIterator<T>): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(first: DequeReverseIterator<T>, last: DequeReverseIterator<T>): DequeReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link Deque container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link Deque container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container Deque}.
-         */
-        swap(obj: Deque<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of {@link Deque}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DequeIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
-        /**
-         * Sequence number of iterator in the source {@link Deque}.
-         */
-        private index_;
-        /**
-         * <p> Construct from the source {@link Deque container}. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Do not create the iterator directly, by yourself. </p>
-         * <p> Use {@link Deque.begin begin()}, {@link Deque.end end()} in {@link Deque container} instead. </p>
-         *
-         * @param source The source {@link Deque container} to reference.
-         * @param index Sequence number of the element in the source {@link Deque}.
-         */
-        constructor(source: Deque<T>, index: number);
-        /**
-         * @hidden
-         */
-        private readonly deque;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * @inheritdoc
-         */
-        readonly index: number;
-        /**
-         * @inheritdoc
-         */
-        prev(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(n: number): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        equals(obj: DequeIterator<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: DequeIterator<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> A reverse-iterator of Deque. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DequeReverseIterator<T> extends ReverseIterator<T, DequeIterator<T>, DequeReverseIterator<T>> implements base.IArrayIterator<T> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: DequeIterator<T>);
-        /**
-         * @hidden
-         */
-        protected _Create_neighbor(base: DequeIterator<T>): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * Get index.
-         */
-        readonly index: number;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Function handling termination on exception </p>
-     *
-     * <p> Calls the current terminate handler. </p>
-     *
-     * <p> By default, the terminate handler calls abort. But this behavior can be redefined by calling
-     * {@link set_terminate}. </p>
-     *
-     * <p> This function is automatically called when no <code>catch</code> handler can be found for a thrown exception,
-     * or for some other exceptional circumstance that makes impossible to continue the exception handling process. </p>
-     *
-     * <p> This function is provided so that the terminate handler can be explicitly called by a program that needs to
-     * abnormally terminate, and works even if {@link set_terminate} has not been used to set a custom terminate handler
-     * (calling abort in this case). </p>
-     */
-    function terminate(): void;
-    /**
-     * <p> Set <i>terminate handler</i> function. </p>
-     *
-     * <p> A <i>terminate handler</i> function is a function automatically called when the exception handling process has
-     * to be abandoned for some reason. This happens when no catch handler can be found for a thrown exception, or for
-     * some other exceptional circumstance that makes impossible to continue the exception handling process. </p>
-     *
-     * <p> Before this function is called by the program for the first time, the default behavior is to call abort. </p>
-     *
-     * <p> A program may explicitly call the current terminate handler function by calling {@link terminate}. </p>
-     *
-     * @param f Function that takes no parameters and returns no value (<i>void</i>).
-     */
-    function set_terminate(f: () => void): void;
-    /**
-     * <p> Get <i>terminate handler</i> function. </p>
-     *
-     * <p> The <i>terminate handler</i> function is automatically called when no <code>catch</code> handler can be found
-     * for a thrown exception, or for some other exceptional circumstance that makes impossible to continue the exception
-     * handling process. </p>
-     *
-     * <p> If no such function has been set by a previous call to {@link set_terminate}, the function returns a
-     * <i>null-pointer</i>. </p>
-     *
-     * @return If {@link set_terminate} has previously been called by the program, the function returns the current
-     *		   <i>terminate handler</i> function. Otherwise, it returns a <i>null-pointer</i>.
-     */
-    function get_terminate(): () => void;
-    /**
-     * <p> Standard exception class. </p>
-     *
-     * <p> Base class for standard exceptions. </p>
-     *
-     * <p> All objects thrown by components of the standard library are derived from this class.
-     * Therefore, all standard exceptions can be caught by catching this type by reference. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/exception/exception
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Exception extends Error {
-        /**
-         * A message representing specification about the Exception.
-         */
-        private description;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-        /**
-         * <p> Get string identifying exception. </p>
-         * <p> Returns a string that may be used to identify the exception. </p>
-         *
-         * <p> The particular representation pointed by the returned value is implementation-defined.
-         * As a virtual function, derived classes may redefine this function so that specify value are
-         * returned. </p>
-         */
-        what(): string;
-        /**
-         * @inheritdoc
-         */
-        readonly message: string;
-        /**
-         * @inheritdoc
-         */
-        readonly name: string;
-    }
-    /**
-     * <p> Logic error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report errors in the internal
-     * logical of the program, such as violation of logical preconditions or class invariants. </p>
-     *
-     * <p> These errors are presumably detectable before the program executes. </p>
-     *
-     * <p> It is used as a base class for several logical error exceptions. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/logic_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class LogicError extends Exception {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Domain error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report domain errors. </p>
-     *
-     * <p> Generally, the domain of a mathematical function is the subset of values that it is defined for.
-     * For example, the square root function is only defined for non-negative numbers. Thus, a negative number
-     * for such a function would qualify as a domain error. </p>
-     *
-     * <p> No component of the standard library throws exceptions of this type. It is designed as a standard
-     * exception to be thrown by programs. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a></p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/domain_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DomainError extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Invalid argument exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report an invalid argument. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
-     * also throw exceptions of this type to signal invalid arguments. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/invalid_argument
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class InvalidArgument extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Length error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report a length error. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library,
-     * such as vector and string also throw exceptions of this type to signal errors resizing. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/length_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class LengthError extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Out-of-range exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report an out-of-range error. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library,
-     * such as vector, deque, string and bitset also throw exceptions of this type to signal arguments
-     * out of range. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/out_of_range
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class OutOfRange extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Runtime error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report errors that can only be
-     * detected during runtime. </p>
-     *
-     * <p> It is used as a base class for several runtime error exceptions. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/runtime_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class RuntimeError extends Exception {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Overflow error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to arithmetic overflow errors. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
-     * also throw exceptions of this type to signal range errors. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/overflow_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class OverflowError extends RuntimeError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Underflow error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to arithmetic underflow errors. </p>
-     *
-     * <p> No component of the standard library throws exceptions of this type. It is designed as a standard
-     * exception to be thrown by programs. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/underflow_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class UnderflowError extends RuntimeError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Range error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report range errors in internal
-     * computations. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
-     * also throw exceptions of this type to signal range errors. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/range_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class RangeError extends RuntimeError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-}
-declare namespace std {
-    /**
-     * <p> Function object class for equality comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether its two arguments compare <i>equal</i> (as returned by
-     * operator ==). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
-     * defined. This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element to compare.
-     * @param y Second element to compare.
-     *
-     * @return Whether the arguments are equal.
-     */
-    function equal_to<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function object class for non-equality comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether its two arguments compare <i>not equal</i> (as returned
-     * by operator operator!=). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
-     * defined. This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element to compare.
-     * @param y Second element to compare.
-     *
-     * @return Whether the arguments are not equal.
-     */
-    function not_equal_to<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function for less-than inequality comparison. </p>
-     *
-     * <p> Binary function returns whether the its first argument compares less than the second. </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.less less}
-     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
-     * This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * <p> Objects of this class can be used on standard algorithms such as {@link sort sort()}</code>,
-     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}. </p>
-     *
-     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
-     *			  <i>operator<()</i> or method {@link IComparable.less less}.
-     *
-     * @param x First element, the standard of comparison.
-     * @param y Second element compare with the first.
-     *
-     * @return Whether the first parameter is less than the second.
-     */
-    function less<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function object class for less-than-or-equal-to comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether the its first argument compares {@link less less than} or
-     * {@link equal_to equal to} the second (as returned by operator <=). </p>
-     *
-     * <p> Generically, <i>function objects</i> are instances of a class with member function {@link IComparable.less less}
-     * and {@link IComparable.equal_to equal_to} defined. This member function allows the object to be used with the same
-     * syntax as a function call. </p>
-     *
-     * @param x First element, the standard of comparison.
-     * @param y Second element compare with the first.
-     *
-     * @return Whether the <i>x</i> is {@link less less than} or {@link equal_to equal to} the <i>y</i>.
-     */
-    function less_equal<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function for greater-than inequality comparison. </p>
-     *
-     * <p> Binary function returns whether the its first argument compares greater than the second. </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link less} and
-     * {@link equal_to equal_to()} defined. If an object doesn't have those methods, then its own uid will be used
-     * to compare insteadly. This member function allows the object to be used with the same syntax as a function
-     * call. </p>
-     *
-     * <p> Objects of this class can be used on standard algorithms such as {@link sort sort()},
-     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}. </p>
-     *
-     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
-     *			  <i>operator>()</i> or method {@link IComparable.greater greater}.
-     *
-     * @return Whether the <i>x</i> is greater than the <i>y</i>.
-     */
-    function greater<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function object class for greater-than-or-equal-to comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether the its first argument compares
-     * {@link greater greater than} or {@link equal_to equal to} the second (as returned by operator >=). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.less less}
-     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
-     * This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element, the standard of comparison.
-     * @param y Second element compare with the first.
-     *
-     * @return Whether the <i>x</i> is {@link greater greater than} or {@link equal_to equal to} the <i>y</i>.
-     */
-    function greater_equal<T>(x: T, y: T): boolean;
-    /**
-     * <p> Logical AND function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of the <i>logical "and"</i> operation between its two
-     * arguments (as returned by operator &&). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
-     * function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of logical AND operation.
-     */
-    function logical_and<T>(x: T, y: T): boolean;
-    /**
-     * <p> Logical OR function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of the <i>logical "or"</i> operation between its two
-     * arguments (as returned by operator ||). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
-     * function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of logical OR operation.
-     */
-    function logical_or<T>(x: T, y: T): boolean;
-    /**
-     * <p> Logical NOT function object class. </p>
-     *
-     * <p> Unary function object class whose call returns the result of the <i>logical "not"</i> operation on its argument
-     * (as returned by operator !). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
-     * function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x Target element.
-     *
-     * @return Result of logical NOT operation.
-     */
-    function logical_not<T>(x: T): boolean;
-    /**
-     * <p> Bitwise AND function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
-     * its two arguments (as returned by operator &). </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of bitwise AND operation.
-     */
-    function bit_and(x: number, y: number): number;
-    /**
-     * <p> Bitwise OR function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
-     * its two arguments (as returned by operator &). </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of bitwise OR operation.
-     */
-    function bit_or(x: number, y: number): number;
-    /**
-     * <p> Bitwise XOR function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "exclusive or"</i>
-     * operation between its two arguments (as returned by operator ^). </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of bitwise XOR operation.
-     */
-    function bit_xor(x: number, y: number): number;
-    /**
-     * <p> Default hash function for number. </p>
-     *
-     * <p> Unary function that defines the default hash function used by the standard library. </p>
-     *
-     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
-     * its argument, returning always the same value for the same argument (for a given execution of a program). The
-     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
-     * </p>
-     *
-     * @param val Value to be hashed.
-     *
-     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
-     */
-    function hash(val: number): number;
-    /**
-     * <p> Default hash function for string. </p>
-     *
-     * <p> Unary function that defines the default hash function used by the standard library. </p>
-     *
-     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
-     * its argument, returning always the same value for the same argument (for a given execution of a program). The
-     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
-     * </p>
-     *
-     * @param str A string to be hashed.
-     *
-     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
-     */
-    function hash(str: string): number;
-    /**
-     * <p> Default hash function for Object. </p>
-     *
-     * <p> Unary function that defines the default hash function used by the standard library. </p>
-     *
-     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
-     * its argument, returning always the same value for the same argument (for a given execution of a program). The
-     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
-     * </p>
-     *
-     * <p> The default {@link hash} function of Object returns a value returned from {@link hash hash(number)} with
-     * an <b>unique id</b> of each Object. If you want to specify {@link hash} function of a specific class, then
-     * define a member function <code>public hash(): number</code> in the class. </p>
-     *
-     * @param obj Object to be hashed.
-     *
-     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
-     */
-    function hash(obj: Object): number;
-    /**
-     * <p> Exchange contents of {@link IContainers containers}. </p>
-     *
-     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must have
-     * same type of elements (same template parameters), although sizes may differ. </p>
-     *
-     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i> before
-     * the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references and
-     * pointers remain valid for the swapped objects. </p>
-     *
-     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
-     * ownership over their assets to the other container (i.e., the containers exchange references to their data, without
-     * actually performing any element copy or movement): It behaves as if <i>left</i>.
-     * {@link IContainer.swap swap}(<i>right</i>) was called. </p>
-     *
-     * @param left A {@link IContainer container} to swap its contents.
-     * @param right A {@link IContainer container} to swap its contents.
-     */
-    function swap<T>(left: base.IContainer<T>, right: base.IContainer<T>): void;
-    /**
-     * <p> Exchange contents of queues. </p>
-     *
-     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
-     *
-     * @param left A {@link Queue} container of the same type. Size may differ.
-     * @param right A {@link Queue} container of the same type. Size may differ.
-     */
-    function swap<T>(left: Queue<T>, right: Queue<T>): void;
-    /**
-     * <p> Exchange contents of {@link PriorityQueue PriorityQueues}. </p>
-     *
-     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
-     *
-     * @param left A {@link PriorityQueue} container of the same type. Size may differ.
-     * @param right A {@link PriorityQueue} container of the same type. Size may differ.
-     */
-    function swap<T>(left: PriorityQueue<T>, right: PriorityQueue<T>): void;
-    /**
-     * <p> Exchange contents of {@link Stack Stacks}. </p>
-     *
-     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
-     *
-     * @param left A {@link Stack} container of the same type. Size may differ.
-     * @param right A {@link Stack} container of the same type. Size may differ.
-     */
-    function swap<T>(left: Stack<T>, right: Stack<T>): void;
-    /**
-     * <p> Exchanges the contents of two {@link UniqueMap unique maps}. </p>
-     *
-     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
-     * be of the same type (same template parameters), although sizes may differ. </p>
-     *
-     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
-     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
-     * and pointers remain valid for the swapped objects. </p>
-     *
-     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
-     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
-     * without actually performing any element copy or movement): It behaves as if
-     * <i>left</i>.{@link UniqueMap.swap swap}(<i>right</i>) was called. </p>
-     *
-     * @param left An {@link UniqueMap unique map} to swap its conents.
-     * @param right An {@link UniqueMap unique map} to swap its conents.
-     */
-    function swap<Key, T>(left: base.UniqueMap<Key, T>, right: base.UniqueMap<Key, T>): void;
-    /**
-     * <p> Exchanges the contents of two {@link MultiMap multi maps}. </p>
-     *
-     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
-     * be of the same type (same template parameters), although sizes may differ. </p>
-     *
-     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
-     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
-     * and pointers remain valid for the swapped objects. </p>
-     *
-     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
-     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
-     * without actually performing any element copy or movement): It behaves as if
-     * <i>left</i>.{@link MultiMap.swap swap}(<i>right</i>) was called. </p>
-     *
-     * @param left A {@link MultiMap multi map} to swap its conents.
-     * @param right A {@link MultiMap multi map} to swap its conents.
-     */
-    function swap<Key, T>(left: base.MultiMap<Key, T>, right: base.MultiMap<Key, T>): void;
-}
-declare namespace std {
-    /**
-     * <p> Bind function arguments. </p>
-     *
-     * <p> Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>. </p>
-     *
-     * <p> Each argument may either be bound to a value or be a {@link placeholders placeholder}: </p>
-     * <ul>
-     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
-     *	<li>
-     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
-     *		call (the one whose order number is specified by the placeholder).
-     *	</li>
-     * </ul>
-     *
-     * <p> Calling the returned object returns the same type as fn. </p>
-     *
-     * @param fn A function object, pointer to function or pointer to member.
-     * @param args List of arguments to bind: either values, or {@link placeholders}.
-     *
-     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
-     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
-     *		   is a member.
-     */
-    function bind<Ret>(fn: (...args: any[]) => Ret, ...args: any[]): (...args: any[]) => Ret;
-    /**
-     * <p> Bind function arguments. </p>
-     *
-     * <p> Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>. </p>
-     *
-     * <p> Each argument may either be bound to a value or be a {@link placeholders placeholder}: </p>
-     * <ul>
-     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
-     *	<li>
-     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
-     *		call (the one whose order number is specified by the placeholder).
-     *	</li>
-     * </ul>
-     *
-     * <p> Calling the returned object returns the same type as fn. </p>
-     *
-     * @param fn A function object, pointer to function or pointer to member.
-     * @param thisArg This argument, owner object of the member method <i>fn</i>.
-     * @param args List of arguments to bind: either values, or {@link placeholders}.
-     *
-     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
-     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
-     *		   is a member.
-     */
-    function bind<Ret, T>(fn: (...args: any[]) => Ret, thisArg: T, ...args: any[]): (...args: any[]) => Ret;
-}
-/**
- * <p> Bind argument placeholders. </p>
- *
- * <p> This namespace declares an unspecified number of objects: <i>_1</i>, <i>_2</i>, <i>_3</i>, ...</i>, which are
- * used to specify placeholders in calls to function {@link std.bind}. </p>
- *
- * <p> When the function object returned by bind is called, an argument with placeholder {@link _1} is replaced by the
- * first argument in the call, {@link _2} is replaced by the second argument in the call, and so on... For example: </p>
- *
- * <code>
- * let vec: Vector<number> = new Vector<number>();
- *
- * let bind = std.bind(Vector.insert, _1, vec.end(), _2, _3);
- * bind.apply(vec, 5, 1); // vec.insert(vec.end(), 5, 1);
- * // [1, 1, 1, 1, 1]
- * </code>
- *
- * <p> When a call to {@link bind} is used as a subexpression in another call to <i>bind</i>, the {@link placeholders}
- * are relative to the outermost {@link bind} expression. </p>
- *
- * @reference http://www.cplusplus.com/reference/functional/placeholders/
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace std.placeholders {
-    /**
-     * @hidden
-     */
-    class PlaceHolder {
-        private index_;
-        constructor(index: number);
-        readonly index: number;
-    }
-    /**
-     * Replaced by the first argument in the function call.
-     */
-    const _1: PlaceHolder;
-    /**
-     * Replaced by the second argument in the function call.
-     */
-    const _2: PlaceHolder;
-    /**
-     * Replaced by the third argument in the function call.
-     */
-    const _3: PlaceHolder;
-    const _4: PlaceHolder;
-    const _5: PlaceHolder;
-    const _6: PlaceHolder;
-    const _7: PlaceHolder;
-    const _8: PlaceHolder;
-    const _9: PlaceHolder;
-    const _10: PlaceHolder;
-    const _11: PlaceHolder;
-    const _12: PlaceHolder;
-    const _13: PlaceHolder;
-    const _14: PlaceHolder;
-    const _15: PlaceHolder;
-    const _16: PlaceHolder;
-    const _17: PlaceHolder;
-    const _18: PlaceHolder;
-    const _19: PlaceHolder;
-    const _20: PlaceHolder;
-}
-declare namespace std.HashMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered map. </p>
-     *
-     * <p> {@link HashMap}s are associative containers that store elements formed by the combination of a <i>key value</i>
-     * and a <i>mapped value</i>, and which allows for fast retrieval of individual elements based on their <i>keys</i>.
-     * </p>
-     *
-     * <p> In an {@link HashMap}, the <i>key value</i> is generally used to uniquely identify the element, while the
-     * <i>mapped value</i> is an object with the content associated to this <i>key</i>. Types of <i>key</i> and
-     * <i>mapped value</i> may differ. </p>
-     *
-     * <p> Internally, the elements in the {@link HashMap} are not sorted in any particular order with respect to either
-     * their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on their hash values to allow
-     * for fast access to individual elements directly by their <i>key values</i> (with a constant average time complexity
-     * on average). </p>
-     *
-     * <p> {@link HashMap} containers are faster than {@link TreeMap} containers to access individual elements by their
-     * <i>key</i>, although they are generally less efficient for range iteration through a subset of their elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Associative </dt>
-     * 	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     * 	<dt> Hashed </dt>
-     * 	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     * 	<dt> Map </dt>
-     * 	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     *
-     * 	<dt> Unique keys </dt>
-     * 	<dd> No two elements in the container can have equivalent keys. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the key values.
-     *				Each element in an {@link HashMap} is uniquely identified by its key value.
-     * @param <T> Type of the mapped value.
-     *			  Each element in an {@link HashMap} is used to store some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_map
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMap<Key, T> extends base.UniqueMap<Key, T> implements base.IHashMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: Pair<Key, T>[]);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: [Key, T][]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashMap<Key, T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        begin(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(index: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashMap map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashMap map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashMap container}.
-         */
-        swap(obj: HashMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std.HashMultiMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered Multimap. </p>
-     *
-     * <p> {@link HashMultiMap}s are associative containers that store elements formed by the combination of
-     * a <i>key value</i> and a <i>mapped value</i>, much like {@link HashMultiMap} containers, but allowing
-     * different elements to have equivalent <i>keys</i>. </p>
-     *
-     * <p> In an {@link HashMultiMap}, the <i>key value</i> is generally used to uniquely identify the
-     * element, while the <i>mapped value</i> is an object with the content associated to this <i>key</i>.
-     * Types of <i>key</i> and <i>mapped value</i> may differ. </p>
-     *
-     * <p> Internally, the elements in the {@link HashMultiMap} are not sorted in any particular order with
-     * respect to either their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on
-     * their hash values to allow for fast access to individual elements directly by their <i>key values</i>
-     * (with a constant average time complexity on average). </p>
-     *
-     * <p> Elements with equivalent <i>keys</i> are grouped together in the same bucket and in such a way that
-     * an iterator can iterate through all of them. Iterators in the container are doubly linked iterators. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the key values.
-     *				Each element in an {@link HashMultiMap} is identified by a key value.
-     * @param <T> Type of the mapped value.
-     *			  Each element in an {@link HashMultiMap} is used to store some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_multimap
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMultiMap<Key, T> extends base.MultiMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: Pair<Key, T>[]);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: [Key, T][]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashMultiMap<Key, T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        count(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        begin(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(n: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashMultiMap map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashMultiMap map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashMultiMap container}.
-         */
-        swap(obj: HashMultiMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std.HashMultiSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered Multiset. </p>
-     *
-     * <p> {@link HashMultiSet HashMultiSets} are containers that store elements in no particular order, allowing fast
-     * retrieval of individual elements based on their value, much like {@link HashMultiSet} containers,
-     * but allowing different elements to have equivalent values. </p>
-     *
-     * <p> In an {@link HashMultiSet}, the value of an element is at the same time its <i>key</i>, used to
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link HashMultiSet} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> Internally, the elements in the {@link HashMultiSet} are not sorted in any particular, but
-     * organized into <i>buckets</i> depending on their hash values to allow for fast access to individual
-     * elements directly by their <i>values</i> (with a constant average time complexity on average). </p>
-     *
-     * <p> Elements with equivalent values are grouped together in the same bucket and in such a way that an
-     * iterator can iterate through all of them. Iterators in the container are doubly linked iterators. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *		   Each element in an {@link UnorderedMultiSet} is also identified by this value..
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_multiset
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMultiSet<T> extends base.MultiSet<T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: T[]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashMultiSet<T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        count(key: T): number;
-        /**
-         * @inheritdoc
-         */
-        begin(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(n: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: T): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashMultiSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashMultiSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashMultiSet container}.
-         */
-        swap(obj: HashMultiSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std.HashSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered set. </p>
-     *
-     * <p> {@link HashSet}s are containers that store unique elements in no particular order, and which
-     * allow for fast retrieval of individual elements based on their value. </p>
-     *
-     * <p> In an {@link HashSet}, the value of an element is at the same time its <i>key</i>, that
-     * identifies it uniquely. Keys are immutable, therefore, the elements in an {@link HashSet} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> Internally, the elements in the {@link HashSet} are not sorted in any particular order, but
-     * organized into buckets depending on their hash values to allow for fast access to individual elements
-     * directly by their <i>values</i> (with a constant average time complexity on average). </p>
-     *
-     * <p> {@link HashSet} containers are faster than {@link TreeSet} containers to access individual
-     * elements by their <i>key</i>, although they are generally less efficient for range iteration through a
-     * subset of their elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *			  Each element in an {@link HashSet} is also uniquely identified by this value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashSet<T> extends base.UniqueSet<T> implements base.IHashSet<T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: T[]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashSet<T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(n: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: T): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashSet container}.
-         */
-        swap(obj: HashSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Comparable instance. </p>
-     *
-     * <p> {@link IComparable} is a common interface for objects who can compare each other. </p>
-     *
-     * @reference https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IComparable<T> extends Object {
-        /**
-         * <p> Indicates whether some other object is &quot;equal to&quot; this one. </p>
-         *
-         * <p> The {@link equal_to} method implements an equivalence relation on non-null object references: </p>
-         *
-         * <ul>
-         *	<li>
-         *		It is <b>reflexive</b>: for any non-null reference value <code>x</code>, <code>x.equal_to(x)</code>
-         *		should return <code>true</code>.
-         *	</li>
-         *	<li>
-         *		It is <b>symmetric</b>: for any non-null reference values <code>x</code> and <code>y</code>,
-         *		<code>x.equal_to(y)</code> should return <code>true</code> if and only if <code>y.equal_to(x)</code>
-         *		returns <code>true</code>. </li>
-         *	<li>
-         *		It is <b>transitive</b>: for any non-null reference values <code>x</code>, <code>y</code>, and
-         *		<code>z</code>, if <code>x.equal_to(y)</code> returns <code>true</code> and <code>y.equal_to(z)</code>
-         *		returns <code>true</code>, then <code>x.equal_to(z)</code> should return <code>true</code>.
-         *	</li>
-         *	<li>
-         *		It is <b>consistent</b>: for any non-null reference values <code>x</code> and <code>y</code>, multiple
-         *		invocations of <code>x.equal_to(y)</code> consistently return <code>true</code> or consistently return
-         *		<code>false</code>, provided no information used in equal_to comparisons on the objects is modified.
-         *	</li>
-         *	<li>
-         *		For any non-null reference value <code>x</code>, <code>x.equal_to(null)</code> should return
-         *		<code>false</code>.
-         *	</li>
-         * </ul>
-         *
-         * <p> The {@link equal_to} method for interface {@link IComparable} implements the most discriminating possible
-         * equivalence relation on objects; that is, for any non-null reference values <code>x</code> and
-         * <code>y</code>, this method returns <code>true</code> if and only if <code>x</code> and <code>y</code>
-         * refer to the same object (<code>x == y</code> has the value <code>true</code>). </p>
-         *
-         * <p> Note that it is generally necessary to override the {@link hash_code} method whenever this method is
-         * overridden, so as to maintain the general contract for the {@link hash_code} method, which states that
-         * equal objects must have equal hash codes. </p>
-         *
-         * <ul>
-         *	<li> {@link IComparable.equal_to} is called by {@link std.equal_to}. </li>
-         * </ul>
-         *
-         * @param obj the reference object with which to compare.
-         *
-         * @return <code>true</code> if this object is the same as the obj argument; <code>false</code> otherwise.
-         */
-        equals(obj: T): boolean;
-        /**
-         * <p> Less-than inequality comparison. </p>
-         *
-         * <p> Binary method returns whether the the instance compares less than the <i>obj</i>. </p>
-         *
-         * <ul>
-         *	<li>
-         *		{@link IComparable.less} is called by {@link std.less}. Also, this method can be used on standard
-         *		algorithms such as {@link sort sort()}</code>, {@link merge merge()} or
-         *		{@link TreeMap.lower_bound lower_bound()}.
-         *	</li>
-         * </ul>
-         *
-         * @param obj the reference object with which to compare.
-         *
-         * @return Whether the first parameter is less than the second.
-         */
-        less(obj: T): boolean;
-        /**
-         * <p> Issue a hash code. </p>
-         *
-         * <p> Returns a hash code value for the object. This method is supported for the benefit of hash tables such
-         * as those provided by hash containers; {@link HashSet}, {@link HashMap}, {@link MultiHashSet} and
-         * {@link MultiHashMap}. </p>
-         *
-         * <p> As much as is reasonably practical, the {@link hash_code} method defined by interface
-         * {@link IComparable} does return distinct integers for distinct objects. (This is typically implemented by
-         * converting the internal address of the object into an integer, but this implementation technique is not
-         * required by the JavaScript programming language.) </p>
-         *
-         * <ul>
-         *	<li>
-         *		{@link IComparable.hash_code} is called by {@link std.hash_code}. If you want to keep basically
-         *		provided hash function, then returns {@link std.Hash.code}; <code>return std.Hash.code(this);</code>
-         *	</li>
-         * </ul>
-         *
-         * @return An hash code who represents the object.
-         */
-        hashCode?(): number;
-    }
-}
-declare namespace std.List {
-    type iterator<T> = std.ListIterator<T>;
-    type reverse_iterator<T> = std.ListReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Doubly linked list. </p>
-     *
-     * <p> {@link List}s are sequence containers that allow constant time insert and erase operations anywhere within the
-     * sequence, and iteration in both directions. </p>
-     *
-     * <p> List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they
-     * contain in different and unrelated storage locations. The ordering is kept internally by the association to each
-     * element of a link to the element preceding it and a link to the element following it. </p>
-     *
-     * <p> Compared to other base standard sequence containers (array, vector and deque), lists perform generally better
-     * in inserting, extracting and moving elements in any position within the container for which an iterator has already
-     * been obtained, and therefore also in algorithms that make intensive use of these, like sorting algorithms. </p>
-     *
-     * <p> The main drawback of lists and forward_lists compared to these other sequence containers is that they lack
-     * direct access to the elements by their position; For example, to access the sixth element in a list, one has to
-     * iterate from a known position (like the beginning or the end) to that position, which takes linear time in the
-     * distance between these. They also consume some extra memory to keep the linking information associated to each
-     * element (which may be an important factor for large lists of small-sized elements). </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Sequence </dt>
-     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
-     *		 their position in this sequence. </dd>
-     *
-     * 	<dt> Doubly-linked list </dt>
-     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing constant time
-     *		 insert and erase operations before or after a specific element (even of entire ranges), but no direct random
-     *		 access. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/list/list/
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class List<T> extends base.ListContainer<T, ListIterator<T>> {
-        private rend_;
-        /**
-         * <p> Default Constructor. </p>
-         *
-         * <p> Constructs an empty container, with no elements. </p>
-         */
-        constructor();
-        /**
-         * <p> Initializer list Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
-         *
-         * @param array An array containing elements to be copied and contained.
-         */
-        constructor(items: Array<T>);
-        /**
-         * <p> Fill Constructor. </p>
-         *
-         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
-         *
-         * @param n Initial container size (i.e., the number of elements in the container at construction).
-         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
-         *			  initialized to a copy of this value.
-         */
-        constructor(size: number, val: T);
-        /**
-         * <p> Copy Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
-         *
-         * @param container Another container object of the same type (with the same class template
-         *					arguments <i>T</i>), whose contents are either copied or acquired.
-         */
-        constructor(container: List<T>);
-        /**
-         * <p> Range Constructor. </p>
-         *
-         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
-         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @hidden
-         */
-        protected _Create_iterator(prev: ListIterator<T>, next: ListIterator<T>, val: T): ListIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Set_begin(it: ListIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        assign(n: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): ListReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): ListReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        front(): T;
-        /**
-         * @inheritdoc
-         */
-        back(): T;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new element is inserted.
-         *				   {@link iterator}> is a member type, defined as a
-         *				   {@link ListIterator bidirectional iterator} type that points to elements.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the newly inserted element; <i>val</i>.
-         */
-        insert(position: ListIterator<T>, val: T): ListIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param size Number of elements to insert.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: ListIterator<T>, size: number, val: T): ListIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param begin An iterator specifying range of the begining element.
-         * @param end An iterator specifying range of the ending element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: ListIterator<T>, begin: InputIterator, end: InputIterator): ListIterator<T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new element is inserted.
-         *				   {@link iterator}> is a member type, defined as a
-         *				   {@link ListReverseIterator bidirectional iterator} type that points to elements.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the newly inserted element; <i>val</i>.
-         */
-        insert(position: ListReverseIterator<T>, val: T): ListReverseIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param size Number of elements to insert.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: ListReverseIterator<T>, size: number, val: T): ListReverseIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param begin An iterator specifying range of the begining element.
-         * @param end An iterator specifying range of the ending element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: ListReverseIterator<T>, begin: InputIterator, end: InputIterator): ListReverseIterator<T>;
-        /**
-         * <p> Erase an element. </p>
-         *
-         * <p> Removes from the {@link List} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link List}.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
-         */
-        erase(position: ListIterator<T>): ListIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         *
-         * <p> Removes from the {@link List} container a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
-         */
-        erase(begin: ListIterator<T>, end: ListIterator<T>): ListIterator<T>;
-        /**
-         * <p> Erase an element. </p>
-         *
-         * <p> Removes from the {@link List} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link List}.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
-         */
-        erase(position: ListReverseIterator<T>): ListReverseIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         *
-         * <p> Removes from the {@link List} container a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
-         */
-        erase(begin: ListReverseIterator<T>, end: ListReverseIterator<T>): ListReverseIterator<T>;
-        /**
-         * <p> Remove duplicate values. </p>
-         *
-         * <p> Removes all but the first element from every consecutive group of equal elements in the  </p>
-         *
-         * <p> Notice that an element is only removed from the {@link List} container if it compares equal to the
-         * element immediately preceding it. Thus, this function is especially useful for sorted lists. </p>
-         */
-        unique(): void;
-        /**
-         * <p> Remove duplicate values. </p>
-         *
-         * <p> Removes all but the first element from every consecutive group of equal elements in the  </p>
-         *
-         * <p> The argument <i>binary_pred</i> is a specific comparison function that determine the <u>uniqueness</u>
-         * of an element. In fact, any behavior can be implemented (and not only an equality comparison), but notice
-         * that the function will call <code>binary_pred(it.value, it.prev().value)</code> for all pairs of elements
-         * (where <code>it</code> is an iterator to an element, starting from the second) and remove <code>it</code>
-         * from the {@link List} if the predicate returns <code>true</code>.
-         *
-         * <p> Notice that an element is only removed from the {@link List} container if it compares equal to the
-         * element immediately preceding it. Thus, this function is especially useful for sorted lists. </p>
-         *
-         * @param binary_pred Binary predicate that, taking two values of the same type than those contained in the
-         *					  {@link List}, returns <code>true</code> to remove the element passed as first argument
-         *					  from the container, and <code>false</code> otherwise. This shall be a function pointer
-         *					  or a function object.
-         */
-        unique(binary_pred: (left: T, right: T) => boolean): void;
-        /**
-         * <p> Remove elements with specific value. </p>
-         *
-         * <p> Removes from the container all the elements that compare equal to <i>val</i>. This calls the
-         * destructor of these objects and reduces the container {@link size} by the number of elements removed. </p>
-         *
-         * <p> Unlike member function {@link List.erase}, which erases elements by their position (using an
-         * iterator), this function ({@link List.remove}) removes elements by their value. </p>
-         *
-         * <p> A similar function, {@link List.remove_if}, exists, which allows for a condition other than an
-         * equality comparison to determine whether an element is removed. </p>
-         *
-         * @param val Value of the elements to be removed.
-         */
-        remove(val: T): void;
-        /**
-         * <p> Remove elements fulfilling condition. </p>
-         *
-         * <p> Removes from the container all the elements for which <i>pred</i> returns <code>true</code>. This
-         * calls the destructor of these objects and reduces the container {@link size} by the number of elements
-         * removed. </p>
-         *
-         * <p> The function calls <code>pred(it.value)</code> for each element (where <code>it</code> is an iterator
-         * to that element). Any of the elements in the list for which this returns <code>true</code>, are removed
-         * from the  </p>
-         *
-         * @param pred Unary predicate that, taking a value of the same type as those contained in the forward_list
-         *			   object, returns <code>true</code> for those values to be removed from the container, and
-         *			   <code>false</code> for those remaining. This can either be a function pointer or a function
-         *			   object.
-         */
-        remove_if(pred: (val: T) => boolean): void;
-        /**
-         * <p> Merge sorted {@link List Lists}. </p>
-         *
-         * <p> Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
-         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
-         * </p>
-         *
-         * <p> This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
-         * them into their ordered position within container (which expands in {@link size} by the number of elements
-         * transferred). The operation is performed without constructing nor destroying any element: they are
-         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
-         * move-construction or not. </p>
-         *
-         * <p> This function requires that the {@link List} containers have their elements already ordered by value
-         * ({@link less}) before the call. For an alternative on unordered {@link List Lists}, see
-         * {@link List.splice}. </p>
-         *
-         * <p> Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
-         * value according to the strict weak ordering defined by {@link less}. The resulting order of equivalent
-         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
-         * existing elements precede those equivalent inserted from <i>obj</i>). </p>
-         *
-         * The function does nothing if <code>this == obj</code>.
-         *
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
-         *			  passed.
-         */
-        merge<U extends T>(obj: List<U>): void;
-        /**
-         * <p> Merge sorted {@link List Lists}. </p>
-         *
-         * <p> Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
-         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
-         * </p>
-         *
-         * <p> This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
-         * them into their ordered position within container (which expands in {@link size} by the number of elements
-         * transferred). The operation is performed without constructing nor destroying any element: they are
-         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
-         * move-construction or not. </p>
-         *
-         * <p> The argument <i>compare</i> is a specific predicate to perform the comparison operation between
-         * elements. This comparison shall produce a strict weak ordering of the elements (i.e., a consistent
-         * transitive comparison, without considering its reflexiveness).
-         *
-         * <p> This function requires that the {@link List} containers have their elements already ordered by
-         * <i>compare</i> before the call. For an alternative on unordered {@link List Lists}, see
-         * {@link List.splice}. </p>
-         *
-         * <p> Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
-         * value according to the strict weak ordering defined by <i>compare</i>. The resulting order of equivalent
-         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
-         * existing elements precede those equivalent inserted from <i>obj</i>). </p>
-         *
-         * The function does nothing if <code>this == obj</code>.
-         *
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
-         *			  passed.
-         * @param compare Binary predicate that, taking two values of the same type than those contained in the
-         *				  {@link list}, returns <code>true</code> if the first argument is considered to go before
-         *				  the second in the strict weak ordering it defines, and <code>false</code> otherwise.
-         *				  This shall be a function pointer or a function object.
-         */
-        merge<U extends T>(obj: List<U>, compare: (left: T, right: T) => boolean): void;
-        /**
-         * <p> Transfer elements from {@link List} to {@link List}. </p>
-         *
-         * <p> Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>. </p>
-         *
-         * <p> This effectively inserts all elements into the container and removes them from <i>obj</i>, altering
-         * the sizes of both containers. The operation does not involve the construction or destruction of any
-         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
-         * value_type supports move-construction or not. </p>
-         *
-         * <p> This first version (1) transfers all the elements of <i>obj</i> into the  </p>
-         *
-         * @param position Position within the container where the elements of <i>obj</i> are inserted.
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         */
-        splice<U extends T>(position: ListIterator<T>, obj: List<U>): void;
-        /**
-         * <p> Transfer an element from {@link List} to {@link List}. </p>
-         *
-         * <p> Transfers an element from <i>obj</i>, which is pointed by an {@link ListIterator iterator} <i>it</i>,
-         * into the container, inserting the element at specified <i>position</i>. </p>
-         *
-         * <p> This effectively inserts an element into the container and removes it from <i>obj</i>, altering the
-         * sizes of both containers. The operation does not involve the construction or destruction of any element.
-         * They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type
-         * supports move-construction or not. </p>
-         *
-         * <p> This second version (2) transfers only the element pointed by <i>it</i> from <i>obj</i> into the
-         *  </p>
-         *
-         * @param position Position within the container where the element of <i>obj</i> is inserted.
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
-         *			  being spliced.
-         * @param it {@link ListIterator Iterator} to an element in <i>obj</i>. Only this single element is
-         *			 transferred.
-         */
-        splice<U extends T>(position: ListIterator<T>, obj: List<U>, it: ListIterator<U>): void;
-        /**
-         * <p> Transfer elements from {@link List} to {@link List}. </p>
-         *
-         * <p> Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>. </p>
-         *
-         * <p> This effectively inserts those elements into the container and removes them from <i>obj</i>, altering
-         * the sizes of both containers. The operation does not involve the construction or destruction of any
-         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
-         * value_type supports move-construction or not. </p>
-         *
-         * <p> This third version (3) transfers the range [<i>begin</i>, <i>end</i>) from <i>obj</i> into the
-         *  </p>
-         *
-         * @param position Position within the container where the elements of <i>obj</i> are inserted.
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
-         *			  being spliced.
-         * @param begin {@link ListIterator An Iterator} specifying initial position of a range of elements in
-         *				<i>obj</i>. Transfers the elements in the range [<b><i>begin</i></b>, <i>end</i>) to
-         *				<i>position</i>.
-         * @param end {@link ListIterator An Iterator} specifying final position of a range of elements in
-         *			  <i>obj</i>. Transfers the elements in the range [<i>begin</i>, <b><i>end</i></b>) to
-         *			  <i>position</i>. Notice that the range includes all the elements between <i>begin<i/> and
-         *			  <i>end</i>, including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        splice<U extends T>(position: ListIterator<T>, obj: List<U>, begin: ListIterator<U>, end: ListIterator<U>): void;
-        /**
-         * <p> Sort elements in  </p>
-         *
-         * <p> Sorts the elements in the {@link List}, altering their position within the  </p>
-         *
-         * <p> The sorting is performed by applying an algorithm that uses {@link less}. This comparison shall
-         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
-         * considering its reflexiveness). </p>
-         *
-         * <p> The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
-         * order they had before the call. </p>
-         *
-         * <p> The entire operation does not involve the construction, destruction or copy of any element object.
-         * Elements are moved within the  </p>
-         */
-        sort(): void;
-        /**
-         * <p> Sort elements in  </p>
-         *
-         * <p> Sorts the elements in the {@link List}, altering their position within the  </p>
-         *
-         * <p> The sorting is performed by applying an algorithm that uses <i>compare</i>. This comparison shall
-         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
-         * considering its reflexiveness). </p>
-         *
-         * <p> The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
-         * order they had before the call. </p>
-         *
-         * <p> The entire operation does not involve the construction, destruction or copy of any element object.
-         * Elements are moved within the  </p>
-         *
-         * @param compare Binary predicate that, taking two values of the same type of those contained in the
-         *				  {@link List}, returns <code>true</code> if the first argument goes before the second
-         *				  argument in the strict weak ordering it defines, and <code>false</code> otherwise. This
-         *				  shall be a function pointer or a function object.
-         */
-        sort(compare: (left: T, right: T) => boolean): void;
-        /**
-         * @hidden
-         */
-        private qsort(first, last, compare);
-        /**
-         * @hidden
-         */
-        private partition(first, last, compare);
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link List container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link List container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container List}.
-         */
-        swap(obj: List<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator, node of a List. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ListIterator<T> extends base.ListIteratorBase<T> {
-        /**
-         * Initializer Constructor.
-         *
-         * #### Note
-         * Do not create the iterator directly, by yourself.
-         *
-         * Use {@link List.begin begin()}, {@link List.end end()} in {@link List container} instead.
-         *
-         * @param source The source {@link List container} to reference.
-         * @param prev A refenrece of previous node ({@link ListIterator iterator}).
-         * @param next A refenrece of next node ({@link ListIterator iterator}).
-         * @param value Value to be stored in the node (iterator).
-         */
-        constructor(source: List<T>, prev: ListIterator<T>, next: ListIterator<T>, value: T);
-        /**
-         * @inheritdoc
-         */
-        prev(): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(step: number): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * @inheritdoc
-         */
-        equals(obj: ListIterator<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: ListIterator<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> A reverse-iterator of List. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ListReverseIterator<T> extends ReverseIterator<T, ListIterator<T>, ListReverseIterator<T>> implements base.ILinearIterator<T> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: ListIterator<T>);
-        /**
-         * @hidden
-         */
-        protected _Create_neighbor(base: ListIterator<T>): ListReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-    }
-}
-declare namespace std.Vector {
-    type iterator<T> = std.VectorIterator<T>;
-    type reverse_iterator<T> = std.VectorReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Vector, the dynamic array. </p>
-     *
-     * <p> {@link Vector}s are sequence containers representing arrays that can change in size. </p>
-     *
-     * <p> Just like arrays, {@link Vector}s use contiguous storage locations for their elements, which means that
-     * their elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently
-     * as in arrays. But unlike arrays, their size can change dynamically, with their storage being handled
-     * automatically by the container. </p>
-     *
-     * <p> Internally, {@link Vector}s use a dynamically allocated array to store their elements. This array may need
-     * to be reallocated in order to grow in size when new elements are inserted, which implies allocating a new
-     * array and moving all elements to it. This is a relatively expensive task in terms of processing time, and
-     * thus, {@link Vector}s do not reallocate each time an element is added to the container. </p>
-     *
-     * <p> Instead, {@link Vector} containers may allocate some extra storage to accommodate for possible growth, and
-     * thus the container may have an actual {@link capacity} greater than the storage strictly needed to contain its
-     * elements (i.e., its {@link size}). Libraries can implement different strategies for growth to balance between
-     * memory usage and reallocations, but in any case, reallocations should only happen at logarithmically growing
-     * intervals of {@link size} so that the insertion of individual elements at the end of the {@link Vector} can be
-     * provided with amortized constant time complexity (see {@link push_back push_back()}). </p>
-     *
-     * <p> Therefore, compared to arrays, {@link Vector}s consume more memory in exchange for the ability to manage
-     * storage and grow dynamically in an efficient way. </p>
-     *
-     * <p> Compared to the other dynamic sequence containers ({@link Deque}s, {@link List}s), {@link Vector Vectors}
-     * are very efficient accessing its elements (just like arrays) and relatively efficient adding or removing
-     * elements from its end. For operations that involve inserting or removing elements at positions other than the
-     * end, they perform worse than the others, and have less consistent iterators and references than {@link List}s.
-     * </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Sequence </dt>
-     *	<dd>
-     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
-     *		accessed by their position in this sequence.
-     *	</dd>
-     *
-     *	<dt> Dynamic array </dt>
-     *	<dd>
-     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
-     *		relatively fast addition/removal of elements at the end of the sequence.
-     *	</dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/vector/vector
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Vector<T> extends Array<T> implements base.IContainer<T>, base.IArrayContainer<T> {
-        /**
-         * @hidden
-         */
-        private end_;
-        /**
-         * @hidden
-         */
-        private rend_;
-        /**
-         * <p> Default Constructor. </p>
-         *
-         * <p> Constructs an empty container, with no elements. </p>
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        constructor(array: Array<T>);
-        /**
-         * <p> Initializer list Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
-         *
-         * @param array An array containing elements to be copied and contained.
-         */
-        constructor(n: number);
-        /**
-         * <p> Fill Constructor. </p>
-         *
-         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
-         *
-         * @param n Initial container size (i.e., the number of elements in the container at construction).
-         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
-         *			  initialized to a copy of this value.
-         */
-        constructor(n: number, val: T);
-        /**
-         * <p> Copy Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
-         *
-         * @param container Another container object of the same type (with the same class template
-         *					arguments <i>T</i>), whose contents are either copied or acquired.
-         */
-        constructor(container: Vector<T>);
-        /**
-         * <p> Range Constructor. </p>
-         *
-         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
-         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        assign(n: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        reserve(size: number): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        begin(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): VectorReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): VectorReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        capacity(): number;
-        /**
-         * @inheritdoc
-         */
-        empty(): boolean;
-        /**
-         * @inheritdoc
-         */
-        at(index: number): T;
-        /**
-         * @inheritdoc
-         */
-        set(index: number, val: T): T;
-        /**
-         * @inheritdoc
-         */
-        front(): T;
-        /**
-         * @inheritdoc
-         */
-        back(): T;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new element before the element at the specified
-         * <i>position</i>, effectively increasing the container size by one. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Position in the {@link Vector} where the new element is inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param val Value to be copied to the inserted element.
-         *
-         * @return An iterator that points to the newly inserted element.
-         */
-        insert(position: VectorIterator<T>, val: T): VectorIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
-         * @param val Value to be copied (or moved) to the inserted elements.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: VectorIterator<T>, n: number, val: T): VectorIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
-         * iterators. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorIterator<T>, begin: InputIterator, end: InputIterator): VectorIterator<T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new element before the element at the specified
-         * <i>position</i>, effectively increasing the container size by one. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Position in the {@link Vector} where the new element is inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param val Value to be copied to the inserted element.
-         *
-         * @return An iterator that points to the newly inserted element.
-         */
-        insert(position: VectorReverseIterator<T>, val: T): VectorReverseIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
-         * @param val Value to be copied (or moved) to the inserted elements.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: VectorReverseIterator<T>, n: number, val: T): VectorReverseIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
-         * iterators. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorReverseIterator<T>, begin: InputIterator, end: InputIterator): VectorReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private insert_by_val(position, val);
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: VectorIterator<T>, n: number, val: T): VectorIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<InputIterator extends Iterator<T>>(position: VectorIterator<T>, first: InputIterator, last: InputIterator): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the {@link Vector} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(position: VectorIterator<T>): VectorIterator<T>;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the <ode>Vector</code> either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the {@link Vector} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(position: VectorReverseIterator<T>): VectorReverseIterator<T>;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the <ode>Vector</code> either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(first: VectorReverseIterator<T>, last: VectorReverseIterator<T>): VectorReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link Vector container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link Vector container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container Vector}.
-         */
-        swap(obj: Vector<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of Vector. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class VectorIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
-        /**
-         * Sequence number of iterator in the source {@link Vector}.
-         */
-        private index_;
-        /**
-         * <p> Construct from the source {@link Vector container}. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Do not create the iterator directly, by yourself. </p>
-         * <p> Use {@link Vector.begin begin()}, {@link Vector.end end()} in {@link Vector container} instead. </p>
-         *
-         * @param source The source {@link Vector container} to reference.
-         * @param index Sequence number of the element in the source {@link Vector}.
-         */
-        constructor(source: Vector<T>, index: number);
-        /**
-         * @hidden
-         */
-        private readonly vector;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * Get index.
-         */
-        readonly index: number;
-        /**
-         * @inheritdoc
-         */
-        prev(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(n: number): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        equals(obj: VectorIterator<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: VectorIterator<T>): void;
-        toString(): number;
-    }
-}
-declare namespace std {
-    /**
-     * <p> A reverse-iterator of Vector. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class VectorReverseIterator<T> extends ReverseIterator<T, VectorIterator<T>, VectorReverseIterator<T>> implements base.IArrayIterator<T> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: VectorIterator<T>);
-        /**
-         * @hidden
-         */
-        protected _Create_neighbor(base: VectorIterator<T>): VectorReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * Get index.
-         */
-        readonly index: number;
-    }
-}
-declare namespace std {
-    /**
-     * <p> FIFO queue. </p>
-     *
-     * <p> {@link Queue}s are a type of container adaptor, specifically designed to operate in a FIFO context
-     * (first-in first-out), where elements are inserted into one end of the container and extracted from the other.
-     * </p>
-     *
-     * <p> {@link Queue}s are implemented as containers adaptors, which are classes that use an encapsulated object of
-     * a specific container class as its underlying container, providing a specific set of member functions to access
-     * its elements. Elements are pushed into the {@link IDeque.back back()} of the specific container and popped from
-     * its {@link IDeque.front front()}. </p>
-     *
-     * <p> {@link container_ The underlying container} may be one of the standard container class template or some
-     * other specifically designed container class. This underlying container shall support at least the following
-     * operations: </p>
-     *
-     * <ul>
-     *	<li> empty </li>
-     *	<li> size </li>
-     *	<li> front </li>
-     *	<li> back </li>
-     *	<li> push_back </li>
-     *	<li> pop_front </li>
-     * </ul>
-     *
-     * <p> The standard container classes {@link Deque} and {@link List} fulfill these requirements.
-     * By default, if no container class is specified for a particular {@link Queue} class instantiation, the standard
-     * container {@link List} is used. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @param <T> Type of elements.
-     *
-     * @reference http://www.cplusplus.com/reference/queue/queue
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Queue<T> {
-        /**
-         * The <i>underlying object</i> for implementing the <i>FIFO</i>
-         */
-        private container_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: Queue<T>);
-        /**
-         * <p> Return size. </p>
-         * <p> Returns the number of elements in the {@link Queue}. </p>
-         *
-         * <p> This member function effectively calls member {@link IDeque.size size()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return The number of elements in the {@link container_ underlying container}.
-         */
-        size(): number;
-        /**
-         * <p> Test whether container is empty. </p>
-         * <p> returns whether the {@link Queue} is empty: i.e. whether its <i>size</i> is zero. </p>
-         *
-         * <p> This member function efeectively calls member {@link IDeque.empty empty()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return <code>true</code> if the {@link container_ underlying container}'s size is 0,
-         *		   <code>false</code> otherwise. </p>
-         */
-        empty(): boolean;
-        /**
-         * <p> Access next element. </p>
-         * <p> Returns a value of the next element in the {@link Queue}. </p>
-         *
-         * <p> The next element is the "oldest" element in the {@link Queue} and the same element that is popped out
-         * from the queue when {@link pop Queue.pop()} is called. </p>
-         *
-         * <p> This member function effectively calls member {@link IDeque.front front()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A value of the next element in the {@link Queue}.
-         */
-        front(): T;
-        /**
-         * <p> Access last element. </p>
-         *
-         * <p> Returns a vaue of the last element in the queue. This is the "newest" element in the queue (i.e. the
-         * last element pushed into the queue). </p>
-         *
-         * <p> This member function effectively calls the member function {@link IDeque.back back()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A value of the last element in the {@link Queue}.
-         */
-        back(): T;
-        /**
-         * <p> Insert element. </p>
-         *
-         * <p> Inserts a new element at the end of the {@link Queue}, after its current last element.
-         * The content of this new element is initialized to <i>val</i>. </p>
-         *
-         * <p> This member function effectively calls the member function {@link IDeque.push_back push_back()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @param val Value to which the inserted element is initialized.
-         */
-        push(val: T): void;
-        /**
-         * <p> Remove next element. </p>
-         *
-         * <p> Removes the next element in the {@link Queue}, effectively reducing its size by one. </p>
-         *
-         * <p> The element removed is the "oldest" element in the {@link Queue} whose value can be retrieved by calling
-         * member {@link front Queue.front()} </p>.
-         *
-         * <p> This member function effectively calls the member function {@link IDeque.pop_front pop_front()} of the
-         * {@link container_ underlying container} object. </p>
-         */
-        pop(): void;
-        /**
-         * <p> Swap contents. </p>
-         *
-         * <p> Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>. </p>
-         *
-         * <p> This member function calls the non-member function {@link IContainer.swap swap} (unqualified) to swap
-         * the {@link container_ underlying containers}. </p>
-         *
-         * @param obj Another {@link Queue} container adaptor of the same type (i.e., instantiated with the same
-         *			  template parameter, <b>T</b>). Sizes may differ. </p>
-         */
-        swap(obj: Queue<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Priority queue. </p>
-     *
-     * <p> {@link PriorityQueue Priority queues} are a type of container adaptors, specifically designed such that its
-     * first element is always the greatest of the elements it contains, according to some <i>strict weak ordering</i>
-     * criterion. </p>
-     *
-     * <p> This context is similar to a <i>heap</i>, where elements can be inserted at any moment, and only the
-     * <i>max heap</i> element can be retrieved (the one at the top in the {@link PriorityQueue priority queue}). </p>
-     *
-     * <p> {@link PriorityQueue Priority queues} are implemented as <i>container adaptors</i>, which are classes that
-     * use an encapsulated object of a specific container class as its {@link container_ underlying container},
-     * providing a specific set of member functions to access its elements. Elements are popped from the <i>"back"</i>
-     * of the specific container, which is known as the <i>top</i> of the {@link PriorityQueue Priority queue}. </p>
-     *
-     * <p> The {@link container_ underlying container} may be any of the standard container class templates or some
-     * other specifically designed container class. The container shall be accessible through
-     * {@link IArrayIterator random access iterators} and support the following operations: </p>
-     *
-     * <ul>
-     *	<li> empty() </li>
-     *	<li> size() </li>
-     *	<li> front() </li>
-     *	<li> push_back() </li>
-     *	<li> pop_back() </li>
-     * </ul>
-     *
-     * <p> The standard container classes {@link Vector} and {@link Deque} fulfill these requirements. By default, if
-     * no container class is specified for a particular {@link PriorityQueue} class instantiation, the standard
-     * container {@link Vector} is used. </p>
-     *
-     * <p> Support of {@link IArrayIterator random access iterators} is required to keep a heap structure internally
-     * at all times. This is done automatically by the container adaptor by automatically calling the algorithm
-     * functions <i>make_heap</i>, <i>push_heap</i> and <i>pop_heap</i> when needed. </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/queue/priority_queue/
-     * @author Jeongho Nam
-     */
-    class PriorityQueue<T> {
-        /**
-         * <p> The <i>underlying container</i> for implementing the <i>priority queue</i>. </p>
-         *
-         * <p> Following standard definition from the C++ committee, the <i>underlying container</i> should be one of
-         * {@link Vector} or {@link Deque}, however, I've adopted {@link TreeMultiSet} instead of them. Of course,
-         * there are proper reasons for adapting the {@link TreeMultiSet} even violating standard advice. </p>
-         *
-         * <p> <i>Underlying container</i> of {@link PriorityQueue} must keep a condition; the highest (or lowest)
-         * element must be placed on the terminal node for fast retrieval and deletion. To keep the condition with
-         * {@link Vector} or {@link Deque}, lots of times will only be spent for re-arranging elements. It calls
-         * rearrangement functions like <i>make_heap</i>, <i>push_heap</i> and <i>pop_head</i> for rearrangement. </p>
-         *
-         * <p> However, the {@link TreeMultiSet} container always keeps arrangment automatically without additional
-         * operations and it even meets full criteria of {@link PriorityQueue}. Those are the reason why I've adopted
-         * {@link TreeMultiSet} as the <i>underlying container</i> of {@link PriorityQueue}. </p>
-         */
-        private container_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (left: T, right: T) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<T>);
-        /**
-         * Contruct from elements with compare.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<T>, compare: (left: T, right: T) => boolean);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: base.IContainer<T>);
-        /**
-         * Copy Constructor with compare.
-         *
-         * @param container A container to be copied.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: base.IContainer<T>, compare: (left: T, right: T) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * Range Constructor with compare.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (left: T, right: T) => boolean);
-        /**
-         * <p> Return size. </p>
-         *
-         * <p> Returns the number of elements in the {@link PriorityQueue}. </p>
-         *
-         * <p> This member function effectively calls member {@link IArray.size size} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return The number of elements in the underlying
-         */
-        size(): number;
-        /**
-         * <p> Test whether container is empty. </p>
-         *
-         * <p> Returns whether the {@link PriorityQueue} is empty: i.e. whether its {@link size} is zero. </p>
-         *
-         * <p> This member function effectively calls member {@link IARray.empty empty} of the
-         * {@link container_ underlying container} object. </p>
-         */
-        empty(): boolean;
-        /**
-         * <p> Access top element. </p>
-         *
-         * <p> Returns a constant reference to the top element in the {@link PriorityQueue}. </p>
-         *
-         * <p> The top element is the element that compares higher in the {@link PriorityQueue}, and the next that is
-         * removed from the container when {@link PriorityQueue.pop} is called. </p>
-         *
-         * <p> This member function effectively calls member {@link IArray.front front} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A reference to the top element in the {@link PriorityQueue}.
-         */
-        top(): T;
-        /**
-         * <p> Insert element. </p>
-         *
-         * <p> Inserts a new element in the {@link PriorityQueue}. The content of this new element is initialized to
-         * <i>val</i>.
-         *
-         * <p> This member function effectively calls the member function {@link IArray.push_back push_back} of the
-         * {@link container_ underlying container} object, and then reorders it to its location in the heap by calling
-         * the <i>push_heap</i> algorithm on the range that includes all the elements of the  </p>
-         *
-         * @param val Value to which the inserted element is initialized.
-         */
-        push(val: T): void;
-        /**
-         * <p> Remove top element. </p>
-         *
-         * <p> Removes the element on top of the {@link PriorityQueue}, effectively reducing its {@link size} by one.
-         * The element removed is the one with the highest (or lowest) value. </p>
-         *
-         * <p> The value of this element can be retrieved before being popped by calling member
-         * {@link PriorityQueue.top}. </p>
-         *
-         * <p> This member function effectively calls the <i>pop_heap</i> algorithm to keep the heap property of
-         * {@link PriorityQueue PriorityQueues} and then calls the member function {@link IArray.pop_back pop_back} of
-         * the {@link container_ underlying container} object to remove the element. </p>
-         */
-        pop(): void;
-        /**
-         * <p> Swap contents. </p>
-         *
-         * <p> Exchanges the contents of the container adaptor by those of <i>obj</i>, swapping both the
-         * {@link container_ underlying container} value and their comparison function using the corresponding
-         * {@link std.swap swap} non-member functions (unqualified). </p>
-         *
-         * <p> This member function has a <i>noexcept</i> specifier that matches the combined <i>noexcept</i> of the
-         * {@link IArray.swap swap} operations on the {@link container_ underlying container} and the comparison
-         * functions. </p>
-         *
-         * @param obj {@link PriorityQueue} container adaptor of the same type (i.e., instantiated with the same
-         *			  template parameters, <b>T</b>). Sizes may differ.
-         */
-        swap(obj: PriorityQueue<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> LIFO stack. </p>
-     *
-     * <p> {@link Stack}s are a type of container adaptor, specifically designed to operate in a LIFO context
-     * (last-in first-out), where elements are inserted and extracted only from one end of the  </p>
-     *
-     * <p> {@link Stack}s are implemented as containers adaptors, which are classes that use an encapsulated object of
-     * a specific container class as its <i>underlying container</i>, providing a specific set of member functions to
-     * access its elements. Elements are pushed/popped from the {@link ILinearContainer.back back()} of the
-     * {@link ILinearContainer specific container}, which is known as the top of the {@link Stack}. </p>
-     *
-     * <p> {@link container_ The underlying container} may be any of the standard container class templates or some
-     * other specifically designed container class. The container shall support the following operations: </p>
-     *
-     * <ul>
-     *	<li> empty </li>
-     *	<li> size </li>
-     *	<li> front </li>
-     *	<li> back </li>
-     *	<li> push_back </li>
-     *	<li> pop_back </li>
-     * </ul>
-     *
-     * <p> The standard container classes {@link Vector}, {@link Deque} and {@link List} fulfill these requirements.
-     * By default, if no container class is specified for a particular {@link Stack} class instantiation, the standard
-     * container {@link List} is used. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @param <T> Type of elements.
-     *
-     * @reference http://www.cplusplus.com/reference/stack/stack
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Stack<T> {
-        /**
-         * The <i>underlying object</i> for implementing the <i>LIFO</i>
-         */
-        private container_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Copy Constructor.
-         */
-        constructor(stack: Stack<T>);
-        /**
-         * <p> Return size. </p>
-         *
-         * <p> Returns the number of elements in the {@link Stack}. </p>
-         *
-         * <p> This member function effectively calls member {@link ILinearContainer.size size()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return The number of elements in the {@link container_ underlying container}.
-         */
-        size(): number;
-        /**
-         * <p> Test whether container is empty. </p>
-         *
-         * <p> returns whether the {@link Stack} is empty: i.e. whether its <i>size</i> is zero. </p>
-         *
-         * <p> This member function effectively calls member {@link ILinearContainer.empty empty()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return <code>true</code> if the <i>underlying container</i>'s size is 0,
-         *		   <code>false</code> otherwise. </p>
-         */
-        empty(): boolean;
-        /**
-         * <p> Access next element. </p>
-         *
-         * <p> Returns a value of the top element in the {@link Stack} </p>.
-         *
-         * <p> Since {@link Stack}s are last-in first-out containers, the top element is the last element inserted into
-         * the {@link Stack}. </p>
-         *
-         * <p> This member function effectively calls member {@link ILinearContainer.back back()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A value of the top element in the {@link Stack}.
-         */
-        top(): T;
-        /**
-         * <p> Insert element. </p>
-         *
-         * <p> Inserts a new element at the top of the {@link Stack}, above its current top element. </p>
-         *
-         * <p> This member function effectively calls the member function
-         * {@link ILinearContainer.push_back push_back()} of the {@link container_ underlying container} object. </p>
-         *
-         * @param val Value to which the inserted element is initialized.
-         */
-        push(val: T): void;
-        /**
-         * <p> Remove top element. </p>
-         *
-         * <p> Removes the element on top of the {@link Stack}, effectively reducing its size by one. </p>
-         *
-         * <p> The element removed is the latest element inserted into the {@link Stack}, whose value can be retrieved
-         * by calling member {@link top Stack.top()} </p>.
-         *
-         * <p> This member function effectively calls the member function {@link ILinearContainer.pop_back pop_back()}
-         * of the {@link container_ underlying container} object. </p>
-         */
-        pop(): void;
-        /**
-         * <p> Swap contents. </p>
-         *
-         * <p> Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>. </p>
-         *
-         * <p> This member function calls the non-member function {@link IContainer.swap swap} (unqualified) to swap
-         * the {@link container_ underlying containers}. </p>
-         *
-         * @param obj Another {@link Stack} container adaptor of the same type (i.e., instantiated with the same
-         *			  template parameter, <b>T</b>). Sizes may differ. </p>
-         */
-        swap(obj: Stack<T>): void;
-    }
-}
-declare namespace std.TreeSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured set, <code>std::set</code> of STL. </p>
-     *
-     * <p> {@link TreeSet}s are containers that store unique elements following a specific order. </p>
-     *
-     * <p> In a {@link TreeSet}, the value of an element also identifies it (the value is itself the
-     * <i>key</i>, of type <i>T</i>), and each value must be unique. The value of the elements in a
-     * {@link TreeSet} cannot be modified once in the container (the elements are always const), but they
-     * can be inserted or removed from the container. </p>
-     *
-     * <p> Internally, the elements in a {@link TreeSet} are always sorted following a specific strict weak
-     * ordering criterion indicated by its internal comparison method (of {@link less}). </p>
-     *
-     * <p> {@link TreeSet} containers are generally slower than {@link HashSet} containers to access
-     * individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on their
-     * order. </p>
-     *
-     * <p> {@link TreeSet}s are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *			  Each element in an {@link TreeSet} is also uniquely identified by this value.
-     *
-     * @reference http://www.cplusplus.com/reference/set/set
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeSet<T> extends base.UniqueSet<T> implements base.ITreeSet<T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: T, y: T) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<T>);
-        /**
-         * Contruct from elements with compare.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: TreeMultiSet<T>);
-        /**
-         * Copy Constructor with compare.
-         *
-         * @param container A container to be copied.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * Construct from range and compare.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeSet container}.
-         */
-        swap(obj: TreeSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std.TreeMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured map, <code>std::map</code> of STL. </p>
-     *
-     * <p> {@link TreeMap TreeMaps} are associative containers that store elements formed by a combination of a
-     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), following order. </p>
-     *
-     * <p> In a {@link TreeMap}, the <i>key values</i> are generally used to sort and uniquely identify the elements,
-     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a {@link Pair}
-     * type combining both: </p>
-     *
-     * <p> <code>typedef Pair<Key, T> value_type;</code> </p>
-     *
-     * <p> Internally, the elements in a {@link TreeMap} are always sorted by its <i>key</i> following a
-     * <i>strict weak ordering</i> criterion indicated by its internal comparison method {@link less}.
-     *
-     * <p> {@link TreeMap} containers are generally slower than {@link HashMap HashMap} containers to access individual
-     * elements by their <i>key</i>, but they allow the direct iteration on subsets based on their order. </p>
-     *
-     * <p> {@link TreeMap}s are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
-     *		 given a position in this order. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/map/map
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMap<Key, T> extends base.UniqueMap<Key, T> implements base.ITreeMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<Pair<Key, T>>);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: Array<[Key, T]>);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         */
-        constructor(container: TreeMap<Key, T>);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMap<Key, T>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: Key, y: Key) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeMap map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeMap map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeMap container}.
-         */
-        swap(obj: TreeMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std.TreeMultiSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured multiple-key set. </p>
-     *
-     * <p> {@link TreeMultiSet TreeMultiSets} are containers that store elements following a specific order, and
-     * where multiple elements can have equivalent values. </p>
-     *
-     * <p> In a {@link TreeMultiSet}, the value of an element also identifies it (the value is itself
-     * the <i>key</i>, of type <i>T</i>). The value of the elements in a {@link TreeMultiSet} cannot
-     * be modified once in the container (the elements are always const), but they can be inserted or removed
-     * from the container. </p>
-     *
-     * <p> Internally, the elements in a {@link TreeMultiSet TreeMultiSets} are always sorted following a strict
-     * weak ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}). </p>
-     *
-     * <p> {@link TreeMultiSet} containers are generally slower than {@link HashMultiSet} containers
-     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on
-     * their order. </p>
-     *
-     * <p> {@link TreeMultiSet TreeMultiSets} are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link TreeMultiSet} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @reference http://www.cplusplus.com/reference/set/multiset
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMultiSet<T> extends base.MultiSet<T> implements base.ITreeSet<T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: T, y: T) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<T>);
-        /**
-         * Contruct from elements with compare.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: TreeMultiSet<T>);
-        /**
-         * Copy Constructor with compare.
-         *
-         * @param container A container to be copied.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * Construct from range and compare.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        count(val: T): number;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeMultiSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeMultiSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeMultiSet container}.
-         */
-        swap(obj: TreeMultiSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std.TreeMultiMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured multiple-key map. </p>
-     *
-     * <p> {@link TreeMultiMap TreeMultiMaps} are associative containers that store elements formed by a combination of
-     * a <i>key value</i> and a <i>mapped value</i>, following a specific order, and where multiple elements can
-     * have equivalent keys. </p>
-     *
-     * <p> In a {@link TreeMultiMap}, the <i>key values</i> are generally used to sort and uniquely identify
-     * the elements, while the <i>mapped values</i> store the content associated to this <i>key</i>. The types of
-     * <i>key</i> and <i>mapped value</i> may differ, and are grouped together in member type
-     * <code>value_type</code>, which is a {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef Pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> Internally, the elements in a {@link TreeMultiMap}are always sorted by its key following a
-     * strict weak ordering criterion indicated by its internal comparison method (of {@link less}). </p>
-     *
-     * <p> {@link TreeMultiMap}containers are generally slower than {@link HashMap} containers
-     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based
-     * on their order. </p>
-     *
-     * <p> {@link TreeMultiMap TreeMultiMaps} are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank"> <
-     * img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/map/multimap
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMultiMap<Key, T> extends base.MultiMap<Key, T> implements base.ITreeMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<Pair<Key, T>>);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: Array<[Key, T]>);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         */
-        constructor(container: TreeMultiMap<Key, T>);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMultiMap<Key, T>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        count(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: Key, y: Key) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeMapMulti map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeMapMulti map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeMapMulti container}.
-         */
-        swap(obj: TreeMultiMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> System error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report conditions originating during
-     * runtime from the operating system or other low-level application program interfaces which have an
-     * associated {@link ErrorCode}. </p>
-     *
-     * <p> The class inherits from {@link RuntimeError}, to which it adds an {@link ErrorCode} as
-     * member code (and defines a specialized what member). </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/system_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SystemError extends RuntimeError {
-        /**
-         * @hidden
-         */
-        protected code_: ErrorCode;
-        /**
-         * Construct from an error code.
-         *
-         * @param code An {@link ErrorCode} object.
-         */
-        constructor(code: ErrorCode);
-        /**
-         * Construct from an error code and message.
-         *
-         * @param code An {@link ErrorCode} object.
-         * @param message A message incorporated in the string returned by member {@link what what()}.
-         */
-        constructor(code: ErrorCode, message: string);
-        /**
-         * Construct from a numeric value and error category.
-         *
-         * @param val A numerical value identifying an error code.
-         * @param category A reference to an {@link ErrorCode} object.
-         */
-        constructor(val: number, category: ErrorCategory);
-        /**
-         * Construct from a numeric value, error category and message.
-         *
-         * @param val A numerical value identifying an error code.
-         * @param category A reference to an {@link ErrorCode} object.
-         * @param message A message incorporated in the string returned by member {@link what what()}.
-         */
-        constructor(val: number, category: ErrorCategory, message: string);
-        /**
-         * <p> Get error code. </p>
-         *
-         * <p> Returns the {@link ErrorCode} object associated with the exception. </p>
-         *
-         * <p> This value is either the {@link ErrorCode} passed to the construction or its equivalent
-         * (if constructed with a value and a {@link category}. </p>
-         *
-         * @return The {@link ErrorCode} associated with the object.
-         */
-        code(): ErrorCode;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Error category. </p>
-     *
-     * <p> This type serves as a base class for specific category types. </p>
-     *
-     * <p> Category types are used to identify the source of an error. They also define the relation between
-     * {@link ErrorCode} and {@link ErrorCondition}objects of its category, as well as the message set for {@link ErrorCode}
-     * objects.
-     *
-     * <p> Objects of these types have no distinct values and are not-copyable and not-assignable, and thus can only be
-     * passed by reference. As such, only one object of each of these types shall exist, each uniquely identifying its own
-     * category: all error codes and conditions of a same category shall return a reference to same object. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/error_category
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ErrorCategory {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * <p> Return category name. </p>
-         *
-         * <p> In derived classes, the function returns a string naming the category. </p>
-         *
-         * <p> In {@link ErrorCategory}, it is a pure virtual member function. </p>
-         *
-         * <ul>
-         *	<li> In the {@link GenericCategory} object, it returns <i>"generic"</i>. </li>
-         *	<li> In the {@link SystemCategory} object, it returns <i>"system"</i>. </li>
-         *	<li> In the {@link IOStreamCategory} object, it returns <i>"iostream"</i>. </li>
-         * </ul>
-         *
-         * @return The category name.
-         */
-        abstract name(): string;
-        /**
-         * <p> Error message. </p>
-         *
-         * <p> In derived classes, the function returns a string object with a message describing the error condition
-         * denoted by <i>val</i>. </p>
-         *
-         * <p> In {@link ErrorCategory}, it is a pure virtual member function. </p>
-         *
-         * <p> This function is called both by {@link ErrorCode.message ErrorCode.message()} and
-         * {@link ErrorCondition.message ErrorCondition.message()} to obtain the corresponding message in the
-         * {@link category}. Therefore, numerical values used by custom <i>error codes</i> and
-         * {@link ErrorCondition error conditions} should only match for a category if they describe the same error. </p>
-         *
-         * @param val A numerical value identifying an error condition.
-         *			  If the {@link ErrorCategory} object is the {@link GenericCategory}, this argument is equivalent to an
-         *			  {@link errno} value.
-         *
-         * @return A string object with the message.
-         */
-        abstract message(val: number): string;
-        /**
-         * <p> Default error condition. </p>
-         *
-         * <p> Returns the default {@link ErrorCondition}object of this category that is associated with the
-         * {@link ErrorCode} identified by a value of <i>val</i>. </p>
-         *
-         * <p> Its definition in the base class {@link ErrorCategory} returns the same as constructing an
-         * {@link ErrorCondition} object with:
-         *
-         * <p> <code>new ErrorCondition(val, *this);</code> </p>
-         *
-         * <p> As a virtual member function, this behavior can be overriden in derived classes. </p>
-         *
-         * <p> This function is called by the default definition of member {@link equivalent equivalent()}, which is used to
-         * compare {@link ErrorCondition error conditions} with error codes. </p>
-         *
-         * @param val A numerical value identifying an error condition.
-         *
-         * @return The default {@link ErrorCondition}object associated with condition value <i>val</i> for this category.
-         */
-        default_error_condition(val: number): ErrorCondition;
-        /**
-         * <p> Check error code equivalence. </p>
-         *
-         * <p> Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
-         * {@link ErrorCondition error condition. </p>
-         *
-         * <p> This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
-         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
-         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
-         * equivalent by the operator. </p>
-         *
-         * <p> As a virtual member function, this behavior can be overridden in derived classes to define a different
-         * correspondence mechanism for each {@link ErrorCategory} type. </p>
-         *
-         * @param val_code A numerical value identifying an error code.
-         * @param cond An object of an {@link ErrorCondition} type.
-         *
-         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
-         */
-        equivalent(val_code: number, cond: ErrorCondition): boolean;
-        /**
-         * <p> Check error code equivalence. </p>
-         *
-         * <p> Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
-         * {@link ErrorCondition error condition. </p>
-         *
-         * <p> This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
-         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
-         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
-         * equivalent by the operator. </p>
-         *
-         * <p> As a virtual member function, this behavior can be overridden in derived classes to define a different
-         * correspondence mechanism for each {@link ErrorCategory} type. </p>
-         *
-         * @param code An object of an {@link ErrorCode} type.
-         * @param val_cond A numerical value identifying an error code.
-         *
-         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
-         */
-        equivalent(code: ErrorCode, val_cond: number): boolean;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Error condition. </p>
-     *
-     * <p> Objects of this type hold a condition {@link value} associated with a {@link category}. </p>
-     *
-     * <p> Objects of this type describe errors in a generic way so that they may be portable across different
-     * systems. This is in contrast with {@link ErrorCode} objects, that may contain system-specific
-     * information. </p>
-     *
-     * <p> Because {@link ErrorCondition}objects can be compared with error_code objects directly by using
-     * <code>relational operators</code>, {@link ErrorCondition}objects are generally used to check whether
-     * a particular {@link ErrorCode} obtained from the system matches a specific error condition no matter
-     * the system. </p>
-     *
-     * <p> The {@link ErrorCategory categories} associated with the {@link ErrorCondition} and the
-     * {@link ErrorCode} define the equivalences between them. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/error_condition
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ErrorCondition extends base.ErrorInstance {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from a numeric value and error category.
-         *
-         * @param val A numerical value identifying an error condition.
-         * @param category A reference to an {@link ErrorCategory} object.
-         */
-        constructor(val: number, category: ErrorCategory);
-    }
-}
-declare namespace std {
-    /**
-     * <p> Error code. </p>
-     *
-     * <p> Objects of this type hold an error code {@link value} associated with a {@link category}. </p>
-     *
-     * <p> The operating system and other low-level applications and libraries generate numerical error codes to
-     * represent possible results. These numerical values may carry essential information for a specific platform,
-     * but be non-portable from one platform to another. </p>
-     *
-     * <p> Objects of this class associate such numerical codes to {@link ErrorCategory error categories}, so that they
-     * can be interpreted when needed as more abstract (and portable) {@link ErrorCondition error conditions}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/error_code
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ErrorCode extends base.ErrorInstance {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from a numeric value and error category.
-         *
-         * @param val A numerical value identifying an error code.
-         * @param category A reference to an {@link ErrorCategory} object.
-         */
-        constructor(val: number, category: ErrorCategory);
-    }
-}
-declare namespace std {
-    /**
-     * <p> Running on Node. </p>
-     *
-     * <p> Test whether the JavaScript is running on Node. </p>
-     *
-     * @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
-     */
-    function is_node(): boolean;
-    /**
-     * <p> Pair of values. </p>
-     *
-     * <p> This class couples together a pair of values, which may be of different types (<i>T1</i> and
-     * <i>T2</i>). The individual values can be accessed through its public members {@link first} and
-     * {@link second}. </p>
-     *
-     * @param <T1> Type of member {@link first}.
-     * @param <T2> Type of member {@link second}.
-     *
-     * @reference http://www.cplusplus.com/reference/utility/pair
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Pair<T1, T2> implements IComparable<Pair<T1, T2>> {
-        /**
-         * <p> A first value in the Pair. </p>
-         */
-        first: T1;
-        /**
-         * <p> A second value in the Pair. </p>
-         */
-        second: T2;
-        /**
-         * <p> Construct from pair values. </p>
-         *
-         * @param first The first value of the Pair
-         * @param second The second value of the Pair
-         */
-        constructor(first: T1, second: T2);
-        /**
-         * <p> Whether a Pair is equal with the Pair. <p>
-         * <p> Compare each first and second value of two Pair(s) and returns whether they are equal or not. </p>
-         *
-         * <p> If stored key and value in a Pair are not number or string but an object like a class or struct,
-         * the comparison will be executed by a member method (SomeObject)::equal_to(). If the object does not have
-         * the member method equal_to(), only address of pointer will be compared. </p>
-         *
-         * @param obj A Map to compare
-         * @return Indicates whether equal or not.
-         */
-        equals<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
-        /**
-         * @inheritdoc
-         */
-        less<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
-    }
-    /**
-     * <p> Construct {@link Pair} object. </p>
-     *
-     * <p> Constructs a {@link Pair} object with its {@link Pair.first first} element set to <i>x</i> and its
-     * {@link Pair.second second} element set to <i>y</i>. </p>
-     *
-     * <p> The template types can be implicitly deduced from the arguments passed to {@link make_pair}. </p>
-     *
-     * <p> {@link Pair} objects can be constructed from other {@link Pair} objects containing different types, if the
-     * respective types are implicitly convertible. </p>
-     *
-     * @param x Value for member {@link Pair.first first}.
-     * @param y Value for member {@link Pair.second second}.
-     *
-     * @return A {@link Pair} object whose elements {@link Pair.first first} and {@link Pair.second second} are set to
-     *		   <i>x</i> and <i>y</i> respectivelly.
-     */
-    function make_pair<T1, T2>(x: T1, y: T2): Pair<T1, T2>;
-}
-declare namespace std {
-    /**
-     * Type definition of {@link Vector} and it's the original name used in C++.
-     */
-    export import vector = Vector;
-    /**
-     * Type definition of {@link List} and it's the original name used in C++.
-     */
-    export import list = List;
-    /**
-     * Type definition of {@link Deque} and it's the original name used in C++.
-     */
-    export import deque = Deque;
-    /**
-     * Type definition of {@link Stack} and it's the original name used in C++.
-     */
-    type stack<T> = Stack<T>;
-    /**
-     * Type definition of {@link Queue} and it's the original name used in C++.
-     */
-    type queue<T> = Queue<T>;
-    /**
-     * Type definition of {@link PriorityQueue} and it's the original name used in C++.
-     */
-    type priority_queue<T> = PriorityQueue<T>;
-    var stack: typeof Stack;
-    var queue: typeof Queue;
-    var priority_queue: typeof PriorityQueue;
-    /**
-     * Type definition of {@link TreeSet} and it's the original name used in C++.
-     */
-    export import set = TreeSet;
-    /**
-     * Type definition of {@link TreeMultiSet} and it's the original name used in C++.
-     */
-    export import multiset = TreeMultiSet;
-    /**
-     * Type definition of {@link HashSet} and it's the original name used in C++.
-     */
-    export import unordered_set = HashSet;
-    /**
-     * Type definition of {@link HashMultiSet} and it's the original name used in C++.
-     */
-    export import unordered_multiset = HashMultiSet;
-    /**
-     * Type definition of {@link TreeMap} and it's the original name used in C++.
-     */
-    export import map = TreeMap;
-    /**
-     * Type definition of {@link TreeMultiMap} and it's the original name used in C++.
-     */
-    export import multimap = TreeMultiMap;
-    /**
-     * Type definition of {@link HashMap} and it's the original name used in C++.
-     */
-    export import unordered_map = HashMap;
-    /**
-     * Type definition of {@link HashMultiMap} and it's the original name used in C++.
-     */
-    export import unordered_multimap = HashMultiMap;
-    type exception = Exception;
-    type logic_error = LogicError;
-    type domain_error = DomainError;
-    type invalid_argument = InvalidArgument;
-    type length_error = LengthError;
-    type out_of_range = OutOfRange;
-    type runtime_error = RuntimeError;
-    type overflow_error = OverflowError;
-    type underflow_error = UnderflowError;
-    type range_error = RangeError;
-    type system_error = SystemError;
-    type error_category = ErrorCategory;
-    type error_condition = ErrorCondition;
-    type error_code = ErrorCode;
-    var exception: typeof Exception;
-    var logic_error: typeof LogicError;
-    var domain_error: typeof DomainError;
-    var invalid_argument: typeof InvalidArgument;
-    var length_error: typeof LengthError;
-    var out_of_range: typeof OutOfRange;
-    var runtime_error: typeof RuntimeError;
-    var overflow_error: typeof OverflowError;
-    var underflow_error: typeof UnderflowError;
-    var range_error: typeof RangeError;
-    var system_error: typeof SystemError;
-    var error_category: typeof ErrorCategory;
-    var error_condition: typeof ErrorCondition;
-    var error_code: typeof ErrorCode;
-}
+}
\ No newline at end of file