From abd2c058b12b2d83a9e17e60759d6ff6115798b1 Mon Sep 17 00:00:00 2001
From: JdeH <info@qquick.org>
Date: Sat, 30 Dec 2017 21:59:41 +0100
Subject: [PATCH] Docs adapted to Python 3.6

---
 numscrypt/__base__.py                         |    2 +-
 .../ndarray/__javascript__/autotest.js        | 5341 +++++++++++++++++
 .../ndarray/__javascript__/autotest.min.js    |  175 +
 .../ndarray/__javascript__/autotest.mod.js    |   26 +
 .../automated_tests/ndarray/autotest.html     |   62 +
 .../automated_tests/ndarray/autotest.min.html |   62 +
 .../basics/__javascript__/__init__.mod.js     |  177 +
 .../module_fft/__javascript__/__init__.mod.js |  113 +
 .../__javascript__/__init__.mod.js            |   58 +
 .../__javascript__/test.js                    | 4324 +++++++++++++
 .../__javascript__/test.min.js                |  132 +
 .../__javascript__/test.mod.js                |   78 +
 .../sphinx/_build/doctrees/environment.pickle |  Bin 10298 -> 10108 bytes
 .../docs/sphinx/_build/doctrees/index.doctree |  Bin 2927 -> 2927 bytes
 .../_build/doctrees/installation_use.doctree  |  Bin 13966 -> 13834 bytes
 .../doctrees/supported_constructs.doctree     |  Bin 50478 -> 50487 bytes
 .../sphinx/_build/doctrees/what_why.doctree   |  Bin 10726 -> 10690 bytes
 numscrypt/docs/sphinx/_build/html/.buildinfo  |    2 +-
 .../_build/html/_sources/installation_use.txt |   10 +-
 .../docs/sphinx/_build/html/genindex.html     |   10 +-
 numscrypt/docs/sphinx/_build/html/index.html  |   10 +-
 .../sphinx/_build/html/installation_use.html  |   20 +-
 numscrypt/docs/sphinx/_build/html/objects.inv |    2 +-
 numscrypt/docs/sphinx/_build/html/search.html |   10 +-
 .../docs/sphinx/_build/html/searchindex.js    |    2 +-
 .../_build/html/supported_constructs.html     |   10 +-
 .../docs/sphinx/_build/html/what_why.html     |   10 +-
 numscrypt/docs/sphinx/installation_use.rst    |   10 +-
 28 files changed, 10597 insertions(+), 49 deletions(-)
 create mode 100644 numscrypt/development/automated_tests/ndarray/__javascript__/autotest.js
 create mode 100644 numscrypt/development/automated_tests/ndarray/__javascript__/autotest.min.js
 create mode 100644 numscrypt/development/automated_tests/ndarray/__javascript__/autotest.mod.js
 create mode 100644 numscrypt/development/automated_tests/ndarray/autotest.html
 create mode 100644 numscrypt/development/automated_tests/ndarray/autotest.min.html
 create mode 100644 numscrypt/development/automated_tests/ndarray/basics/__javascript__/__init__.mod.js
 create mode 100644 numscrypt/development/automated_tests/ndarray/module_fft/__javascript__/__init__.mod.js
 create mode 100644 numscrypt/development/automated_tests/ndarray/module_linalg/__javascript__/__init__.mod.js
 create mode 100644 numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.js
 create mode 100644 numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.min.js
 create mode 100644 numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.mod.js

diff --git a/numscrypt/__base__.py b/numscrypt/__base__.py
index 437e8cd..2daf1a0 100644
--- a/numscrypt/__base__.py
+++ b/numscrypt/__base__.py
@@ -1 +1 @@
-ns_version = '0.0.36'
+ns_version = '0.0.37'
diff --git a/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.js b/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.js
new file mode 100644
index 0000000..ab32b0a
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.js
@@ -0,0 +1,5341 @@
+"use strict";
+// Transcrypt'ed from Python, 2017-12-30 21:58:01
+function autotest () {
+   var __symbols__ = ['__complex__', '__py3.6__', '__esv6__'];
+    var __all__ = {};
+    var __world__ = __all__;
+    
+    /* Nested module-object creator, part of the nesting may already exist and have attributes
+    
+    A Transcrypt applicaton consists of a main module and additional modules.
+    Transcrypt modules constitute a unique, unambigous tree by their dotted names, no matter which of the alternative module root paths they come from.
+    The main module is represented by a main function by the name of the application.
+    The locals of this function constitute the outer namespace of the Transcrypt application.
+    References to all local variables of this function are also assigned to attributes of local variable __all__, using the variable names as an attribute names.
+    The main function returns this local variable __all__ (that inside the function is also known by the name __world__)
+    Normally this function result is assigned to window.<application name>.
+    The function may than be exited (unless its main line starts an ongoing activity), but the application namespace stays alive tby the reference that window has to it.
+    In case of the ongoing activity including the script is enough to start it, in other cases it has to be started explicitly by calling window.<application name>.<a function>.
+    There may be multiple such entrypoint functions.
+    
+    Additional modules are represented by objects rather than functions, nested into __world__ (so into __all__ of the main function).
+    This nesting can be directly or indirectly, according to the dotted paths of the additional modules.
+    One of the methods of the module object is the __init__ function, that's executed once at module initialisation time.
+    
+    The additional modues also have an __all__ variable, an attribute rather than a local variable.
+    However this __all__ object is passed to the __init__ function, so becomes a local variable there.
+    Variables in additional modules first become locals to the __init__ function but references to all of them are assigend to __all__ under their same names.
+    This resembles the cause of affairs in the main function.
+    However __world__ only referes to the __all__ of the main module, not of any additional modules.
+    Importing a module boils down to adding all members of its __all__ to the local namespace, directly or via dotted access, depending on the way of import.
+    
+    In each local namespace of the module function (main function for main module, __init__ for additional modules) there's a variable __name__ holding the name of the module.
+    Classes are created inside the static scope of a particular module, and at that (class creation) time their variable __module__ gets assigned a reference to __name__.
+    This assignement is generated explicitly by the compiler, as the class creation function __new__ of the metaclass isn't in the static scope containing __name__.
+    
+    In case of
+        import a
+        import a.b
+    a will have been created at the moment that a.b is imported,
+    so all a.b. is allowed to do is an extra attribute in a, namely a reference to b,
+    not recreate a, since that would destroy attributes previously present in a
+    
+    In case of
+        import a.b
+        import a
+    a will have to be created at the moment that a.b is imported
+    
+    In general in a chain
+        import a.b.c.d.e
+    a, a.b, a.b.c and a.b.c.d have to exist before e is created, since a.b.c.d should hold a reference to e.
+    Since this applies recursively, if e.g. c is already created, we can be sure a and a.b. will also be already created.
+    
+    So to be able to create e, we'll have to walk the chain a.b.c.d, starting with a.
+    As soon as we encounter a module in the chain that isn't already there, we'll have to create the remainder (tail) of the chain.
+    
+    e.g.
+        import a.b.c.d.e
+        import a.b.c
+    
+    will generate
+        var modules = {};
+        __nest__ (a, 'b.c.d.e', __init__ (__world__.a.b.c.d.e));
+        __nest__ (a, 'b.c', __init__ (__world__.a.b.c));
+        
+    The task of the __nest__ function is to start at the head object and then walk to the chain of objects behind it (tail),
+    creating the ones that do not exist already, and insert the necessary module reference attributes into them.   
+    */
+    
+    var __nest__ = function (headObject, tailNames, value) {    
+        var current = headObject;
+        // In some cases this will be <main function>.__all__,
+        // which is the main module and is also known under the synonym <main function.__world__.
+        // N.B. <main function> is the entry point of a Transcrypt application,
+        // Carrying the same name as the application except the file name extension.
+        
+        if (tailNames != '') {  // Split on empty string doesn't give empty list
+            // Find the last already created object in tailNames
+            var tailChain = tailNames.split ('.');
+            var firstNewIndex = tailChain.length;
+            for (var index = 0; index < tailChain.length; index++) {
+                if (!current.hasOwnProperty (tailChain [index])) {
+                    firstNewIndex = index;
+                    break;
+                }
+                current = current [tailChain [index]];
+            }
+            
+            // Create the rest of the objects, if any
+            for (var index = firstNewIndex; index < tailChain.length; index++) {
+                current [tailChain [index]] = {};
+                current = current [tailChain [index]];
+            }
+        }
+        
+        // Insert it new attributes, it may have been created earlier and have other attributes
+        for (var attrib in value) {
+            current [attrib] = value [attrib];          
+        }       
+    };
+    __all__.__nest__ = __nest__;
+    
+    // Initialize module if not yet done and return its globals
+    var __init__ = function (module) {
+        if (!module.__inited__) {
+            module.__all__.__init__ (module.__all__);
+            module.__inited__ = true;
+        }
+        return module.__all__;
+    };
+    __all__.__init__ = __init__;
+    
+    
+    // Proxy switch, controlled by __pragma__ ('proxy') and __pragma ('noproxy')
+    var __proxy__ = false;  // No use assigning it to __all__, only its transient state is important
+    
+    
+    // Since we want to assign functions, a = b.f should make b.f produce a bound function
+    // So __get__ should be called by a property rather then a function
+    // Factory __get__ creates one of three curried functions for func
+    // Which one is produced depends on what's to the left of the dot of the corresponding JavaScript property
+    var __get__ = function (self, func, quotedFuncName) {
+        if (self) {
+            if (self.hasOwnProperty ('__class__') || typeof self == 'string' || self instanceof String) {           // Object before the dot
+                if (quotedFuncName) {                                   // Memoize call since fcall is on, by installing bound function in instance
+                    Object.defineProperty (self, quotedFuncName, {      // Will override the non-own property, next time it will be called directly
+                        value: function () {                            // So next time just call curry function that calls function
+                            var args = [] .slice.apply (arguments);
+                            return func.apply (null, [self] .concat (args));
+                        },              
+                        writable: true,
+                        enumerable: true,
+                        configurable: true
+                    });
+                }
+                return function () {                                    // Return bound function, code dupplication for efficiency if no memoizing
+                    var args = [] .slice.apply (arguments);             // So multilayer search prototype, apply __get__, call curry func that calls func
+                    return func.apply (null, [self] .concat (args));
+                };
+            }
+            else {                                                      // Class before the dot
+                return func;                                            // Return static method
+            }
+        }
+        else {                                                          // Nothing before the dot
+            return func;                                                // Return free function
+        }
+    }
+    __all__.__get__ = __get__;
+
+    var __getcm__ = function (self, func, quotedFuncName) {
+        if (self.hasOwnProperty ('__class__')) {
+            return function () {
+                var args = [] .slice.apply (arguments);
+                return func.apply (null, [self.__class__] .concat (args));
+            };
+        }
+        else {
+            return function () {
+                var args = [] .slice.apply (arguments);
+                return func.apply (null, [self] .concat (args));
+            };
+        }
+    }
+    __all__.__getcm__ = __getcm__;
+    
+    var __getsm__ = function (self, func, quotedFuncName) {
+        return func;
+    }
+    __all__.__getsm__ = __getsm__;
+        
+    // Mother of all metaclasses        
+    var py_metatype = {
+        __name__: 'type',
+        __bases__: [],
+        
+        // Overridable class creation worker
+        __new__: function (meta, name, bases, attribs) {
+            // Create the class cls, a functor, which the class creator function will return
+            var cls = function () {                     // If cls is called with arg0, arg1, etc, it calls its __new__ method with [arg0, arg1, etc]
+                var args = [] .slice.apply (arguments); // It has a __new__ method, not yet but at call time, since it is copied from the parent in the loop below
+                return cls.__new__ (args);              // Each Python class directly or indirectly derives from object, which has the __new__ method
+            };                                          // If there are no bases in the Python source, the compiler generates [object] for this parameter
+            
+            // Copy all methods, including __new__, properties and static attributes from base classes to new cls object
+            // The new class object will simply be the prototype of its instances
+            // JavaScript prototypical single inheritance will do here, since any object has only one class
+            // This has nothing to do with Python multiple inheritance, that is implemented explictly in the copy loop below
+            for (var index = bases.length - 1; index >= 0; index--) {   // Reversed order, since class vars of first base should win
+                var base = bases [index];
+                for (var attrib in base) {
+                    var descrip = Object.getOwnPropertyDescriptor (base, attrib);
+                    Object.defineProperty (cls, attrib, descrip);
+                }           
+
+                for (var symbol of Object.getOwnPropertySymbols (base)) {
+                    var descrip = Object.getOwnPropertyDescriptor (base, symbol);
+                    Object.defineProperty (cls, symbol, descrip);
+                }
+                
+            }
+            
+            // Add class specific attributes to the created cls object
+            cls.__metaclass__ = meta;
+            cls.__name__ = name.startsWith ('py_') ? name.slice (3) : name;
+            cls.__bases__ = bases;
+            
+            // Add own methods, properties and own static attributes to the created cls object
+            for (var attrib in attribs) {
+                var descrip = Object.getOwnPropertyDescriptor (attribs, attrib);
+                Object.defineProperty (cls, attrib, descrip);
+            }
+
+            for (var symbol of Object.getOwnPropertySymbols (attribs)) {
+                var descrip = Object.getOwnPropertyDescriptor (attribs, symbol);
+                Object.defineProperty (cls, symbol, descrip);
+            }
+            
+            // Return created cls object
+            return cls;
+        }
+    };
+    py_metatype.__metaclass__ = py_metatype;
+    __all__.py_metatype = py_metatype;
+    
+    // Mother of all classes
+    var object = {
+        __init__: function (self) {},
+        
+        __metaclass__: py_metatype, // By default, all classes have metaclass type, since they derive from object
+        __name__: 'object',
+        __bases__: [],
+            
+        // Object creator function, is inherited by all classes (so could be global)
+        __new__: function (args) {  // Args are just the constructor args       
+            // In JavaScript the Python class is the prototype of the Python object
+            // In this way methods and static attributes will be available both with a class and an object before the dot
+            // The descriptor produced by __get__ will return the right method flavor
+            var instance = Object.create (this, {__class__: {value: this, enumerable: true}});
+            
+            if ('__getattr__' in this || '__setattr__' in this) {
+                instance = new Proxy (instance, {
+                    get: function (target, name) {
+                        var result = target [name];
+                        if (result == undefined) {  // Target doesn't have attribute named name
+                            return target.__getattr__ (name);
+                        }
+                        else {
+                            return result;
+                        }
+                    },
+                    set: function (target, name, value) {
+                        try {
+                            target.__setattr__ (name, value);
+                        }
+                        catch (exception) {         // Target doesn't have a __setattr__ method
+                            target [name] = value;
+                        }
+                        return true;
+                    }
+                })
+            }
+
+            // Call constructor
+            this.__init__.apply (null, [instance] .concat (args));
+
+            // Return constructed instance
+            return instance;
+        }   
+    };
+    __all__.object = object;
+    
+    // Class creator facade function, calls class creation worker
+    var __class__ = function (name, bases, attribs, meta) {         // Parameter meta is optional
+        if (meta == undefined) {
+            meta = bases [0] .__metaclass__;
+        }
+                
+        return meta.__new__ (meta, name, bases, attribs);
+    }
+    __all__.__class__ = __class__;
+    
+    // Define __pragma__ to preserve '<all>' and '</all>', since it's never generated as a function, must be done early, so here
+    var __pragma__ = function () {};
+    __all__.__pragma__ = __pragma__;
+    
+    	__nest__ (
+		__all__,
+		'org.transcrypt.__base__', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'org.transcrypt.__base__';
+					var __Envir__ = __class__ ('__Envir__', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							self.interpreter_name = 'python';
+							self.transpiler_name = 'transcrypt';
+							self.transpiler_version = '3.6.66';
+							self.target_subdir = '__javascript__';
+						}, '__init__');}
+					});
+					var __envir__ = __Envir__ ();
+					__pragma__ ('<all>')
+						__all__.__Envir__ = __Envir__;
+						__all__.__envir__ = __envir__;
+						__all__.__name__ = __name__;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'org.transcrypt.__standard__', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'org.transcrypt.__standard__';
+					var Exception = __class__ ('Exception', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							var kwargs = dict ();
+							if (arguments.length) {
+								var __ilastarg0__ = arguments.length - 1;
+								if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+									var __allkwargs0__ = arguments [__ilastarg0__--];
+									for (var __attrib0__ in __allkwargs0__) {
+										switch (__attrib0__) {
+											case 'self': var self = __allkwargs0__ [__attrib0__]; break;
+											default: kwargs [__attrib0__] = __allkwargs0__ [__attrib0__];
+										}
+									}
+									delete kwargs.__kwargtrans__;
+								}
+								var args = tuple ([].slice.apply (arguments).slice (1, __ilastarg0__ + 1));
+							}
+							else {
+								var args = tuple ();
+							}
+							self.__args__ = args;
+							try {
+								self.stack = kwargs.error.stack;
+							}
+							catch (__except0__) {
+								self.stack = 'No stack trace available';
+							}
+						}, '__init__');},
+						get __repr__ () {return __get__ (this, function (self) {
+							if (len (self.__args__)) {
+								return '{}{}'.format (self.__class__.__name__, repr (tuple (self.__args__)));
+							}
+							else {
+								return '{}()'.format (self.__class__.__name__);
+							}
+						}, '__repr__');},
+						get __str__ () {return __get__ (this, function (self) {
+							if (len (self.__args__) > 1) {
+								return str (tuple (self.__args__));
+							}
+							else if (len (self.__args__)) {
+								return str (self.__args__ [0]);
+							}
+							else {
+								return '';
+							}
+						}, '__str__');}
+					});
+					var IterableError = __class__ ('IterableError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, error) {
+							Exception.__init__ (self, "Can't iterate over non-iterable", __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var StopIteration = __class__ ('StopIteration', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, error) {
+							Exception.__init__ (self, 'Iterator exhausted', __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var ValueError = __class__ ('ValueError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var KeyError = __class__ ('KeyError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var AssertionError = __class__ ('AssertionError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							if (message) {
+								Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+							}
+							else {
+								Exception.__init__ (self, __kwargtrans__ ({error: error}));
+							}
+						}, '__init__');}
+					});
+					var NotImplementedError = __class__ ('NotImplementedError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var IndexError = __class__ ('IndexError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var AttributeError = __class__ ('AttributeError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var py_TypeError = __class__ ('py_TypeError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var Warning = __class__ ('Warning', [Exception], {
+						__module__: __name__,
+					});
+					var UserWarning = __class__ ('UserWarning', [Warning], {
+						__module__: __name__,
+					});
+					var DeprecationWarning = __class__ ('DeprecationWarning', [Warning], {
+						__module__: __name__,
+					});
+					var RuntimeWarning = __class__ ('RuntimeWarning', [Warning], {
+						__module__: __name__,
+					});
+					var __sort__ = function (iterable, key, reverse) {
+						if (typeof key == 'undefined' || (key != null && key .hasOwnProperty ("__kwargtrans__"))) {;
+							var key = null;
+						};
+						if (typeof reverse == 'undefined' || (reverse != null && reverse .hasOwnProperty ("__kwargtrans__"))) {;
+							var reverse = false;
+						};
+						if (arguments.length) {
+							var __ilastarg0__ = arguments.length - 1;
+							if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+								var __allkwargs0__ = arguments [__ilastarg0__--];
+								for (var __attrib0__ in __allkwargs0__) {
+									switch (__attrib0__) {
+										case 'iterable': var iterable = __allkwargs0__ [__attrib0__]; break;
+										case 'key': var key = __allkwargs0__ [__attrib0__]; break;
+										case 'reverse': var reverse = __allkwargs0__ [__attrib0__]; break;
+									}
+								}
+							}
+						}
+						else {
+						}
+						if (key) {
+							iterable.sort ((function __lambda__ (a, b) {
+								if (arguments.length) {
+									var __ilastarg0__ = arguments.length - 1;
+									if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+										var __allkwargs0__ = arguments [__ilastarg0__--];
+										for (var __attrib0__ in __allkwargs0__) {
+											switch (__attrib0__) {
+												case 'a': var a = __allkwargs0__ [__attrib0__]; break;
+												case 'b': var b = __allkwargs0__ [__attrib0__]; break;
+											}
+										}
+									}
+								}
+								else {
+								}
+								return (key (a) > key (b) ? 1 : -(1));
+							}));
+						}
+						else {
+							iterable.sort ();
+						}
+						if (reverse) {
+							iterable.reverse ();
+						}
+					};
+					var sorted = function (iterable, key, reverse) {
+						if (typeof key == 'undefined' || (key != null && key .hasOwnProperty ("__kwargtrans__"))) {;
+							var key = null;
+						};
+						if (typeof reverse == 'undefined' || (reverse != null && reverse .hasOwnProperty ("__kwargtrans__"))) {;
+							var reverse = false;
+						};
+						if (arguments.length) {
+							var __ilastarg0__ = arguments.length - 1;
+							if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+								var __allkwargs0__ = arguments [__ilastarg0__--];
+								for (var __attrib0__ in __allkwargs0__) {
+									switch (__attrib0__) {
+										case 'iterable': var iterable = __allkwargs0__ [__attrib0__]; break;
+										case 'key': var key = __allkwargs0__ [__attrib0__]; break;
+										case 'reverse': var reverse = __allkwargs0__ [__attrib0__]; break;
+									}
+								}
+							}
+						}
+						else {
+						}
+						if (py_typeof (iterable) == dict) {
+							var result = copy (iterable.py_keys ());
+						}
+						else {
+							var result = copy (iterable);
+						}
+						__sort__ (result, key, reverse);
+						return result;
+					};
+					var map = function (func, iterable) {
+						return (function () {
+							var __accu0__ = [];
+							for (var item of iterable) {
+								__accu0__.append (func (item));
+							}
+							return __accu0__;
+						}) ();
+					};
+					var filter = function (func, iterable) {
+						if (func == null) {
+							var func = bool;
+						}
+						return (function () {
+							var __accu0__ = [];
+							for (var item of iterable) {
+								if (func (item)) {
+									__accu0__.append (item);
+								}
+							}
+							return __accu0__;
+						}) ();
+					};
+					var complex = __class__ ('complex', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, real, imag) {
+							if (typeof imag == 'undefined' || (imag != null && imag .hasOwnProperty ("__kwargtrans__"))) {;
+								var imag = null;
+							};
+							if (imag == null) {
+								if (py_typeof (real) == complex) {
+									self.real = real.real;
+									self.imag = real.imag;
+								}
+								else {
+									self.real = real;
+									self.imag = 0;
+								}
+							}
+							else {
+								self.real = real;
+								self.imag = imag;
+							}
+						}, '__init__');},
+						get __neg__ () {return __get__ (this, function (self) {
+							return complex (-(self.real), -(self.imag));
+						}, '__neg__');},
+						get __exp__ () {return __get__ (this, function (self) {
+							var modulus = Math.exp (self.real);
+							return complex (modulus * Math.cos (self.imag), modulus * Math.sin (self.imag));
+						}, '__exp__');},
+						get __log__ () {return __get__ (this, function (self) {
+							return complex (Math.log (Math.sqrt (self.real * self.real + self.imag * self.imag)), Math.atan2 (self.imag, self.real));
+						}, '__log__');},
+						get __pow__ () {return __get__ (this, function (self, other) {
+							return self.__log__ ().__mul__ (other).__exp__ ();
+						}, '__pow__');},
+						get __rpow__ () {return __get__ (this, function (self, real) {
+							return self.__mul__ (Math.log (real)).__exp__ ();
+						}, '__rpow__');},
+						get __mul__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real * other, self.imag * other);
+							}
+							else {
+								return complex (self.real * other.real - self.imag * other.imag, self.real * other.imag + self.imag * other.real);
+							}
+						}, '__mul__');},
+						get __rmul__ () {return __get__ (this, function (self, real) {
+							return complex (self.real * real, self.imag * real);
+						}, '__rmul__');},
+						get __div__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real / other, self.imag / other);
+							}
+							else {
+								var denom = other.real * other.real + other.imag * other.imag;
+								return complex ((self.real * other.real + self.imag * other.imag) / denom, (self.imag * other.real - self.real * other.imag) / denom);
+							}
+						}, '__div__');},
+						get __rdiv__ () {return __get__ (this, function (self, real) {
+							var denom = self.real * self.real;
+							return complex ((real * self.real) / denom, (real * self.imag) / denom);
+						}, '__rdiv__');},
+						get __add__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real + other, self.imag);
+							}
+							else {
+								return complex (self.real + other.real, self.imag + other.imag);
+							}
+						}, '__add__');},
+						get __radd__ () {return __get__ (this, function (self, real) {
+							return complex (self.real + real, self.imag);
+						}, '__radd__');},
+						get __sub__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real - other, self.imag);
+							}
+							else {
+								return complex (self.real - other.real, self.imag - other.imag);
+							}
+						}, '__sub__');},
+						get __rsub__ () {return __get__ (this, function (self, real) {
+							return complex (real - self.real, -(self.imag));
+						}, '__rsub__');},
+						get __repr__ () {return __get__ (this, function (self) {
+							return '({}{}{}j)'.format (self.real, (self.imag >= 0 ? '+' : ''), self.imag);
+						}, '__repr__');},
+						get __str__ () {return __get__ (this, function (self) {
+							return __repr__ (self).__getslice__ (1, -(1), 1);
+						}, '__str__');}
+					});
+					var __Terminal__ = __class__ ('__Terminal__', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							self.buffer = '';
+							try {
+								self.element = document.getElementById ('__terminal__');
+							}
+							catch (__except0__) {
+								self.element = null;
+							}
+							if (self.element) {
+								self.element.style.overflowX = 'auto';
+								self.element.style.boxSizing = 'border-box';
+								self.element.style.padding = '5px';
+								self.element.innerHTML = '_';
+							}
+						}, '__init__');},
+						get print () {return __get__ (this, function (self) {
+							var sep = ' ';
+							var end = '\n';
+							if (arguments.length) {
+								var __ilastarg0__ = arguments.length - 1;
+								if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+									var __allkwargs0__ = arguments [__ilastarg0__--];
+									for (var __attrib0__ in __allkwargs0__) {
+										switch (__attrib0__) {
+											case 'self': var self = __allkwargs0__ [__attrib0__]; break;
+											case 'sep': var sep = __allkwargs0__ [__attrib0__]; break;
+											case 'end': var end = __allkwargs0__ [__attrib0__]; break;
+										}
+									}
+								}
+								var args = tuple ([].slice.apply (arguments).slice (1, __ilastarg0__ + 1));
+							}
+							else {
+								var args = tuple ();
+							}
+							self.buffer = '{}{}{}'.format (self.buffer, sep.join ((function () {
+								var __accu0__ = [];
+								for (var arg of args) {
+									__accu0__.append (str (arg));
+								}
+								return __accu0__;
+							}) ()), end).__getslice__ (-(4096), null, 1);
+							if (self.element) {
+								self.element.innerHTML = self.buffer.py_replace ('\n', '<br>').py_replace (' ', '&nbsp');
+								self.element.scrollTop = self.element.scrollHeight;
+							}
+							else {
+								console.log (sep.join ((function () {
+									var __accu0__ = [];
+									for (var arg of args) {
+										__accu0__.append (str (arg));
+									}
+									return __accu0__;
+								}) ()));
+							}
+						}, 'print');},
+						get input () {return __get__ (this, function (self, question) {
+							if (arguments.length) {
+								var __ilastarg0__ = arguments.length - 1;
+								if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+									var __allkwargs0__ = arguments [__ilastarg0__--];
+									for (var __attrib0__ in __allkwargs0__) {
+										switch (__attrib0__) {
+											case 'self': var self = __allkwargs0__ [__attrib0__]; break;
+											case 'question': var question = __allkwargs0__ [__attrib0__]; break;
+										}
+									}
+								}
+							}
+							else {
+							}
+							self.print ('{}'.format (question), __kwargtrans__ ({end: ''}));
+							var answer = window.prompt ('\n'.join (self.buffer.py_split ('\n').__getslice__ (-(16), null, 1)));
+							self.print (answer);
+							return answer;
+						}, 'input');}
+					});
+					var __terminal__ = __Terminal__ ();
+					__pragma__ ('<all>')
+						__all__.AssertionError = AssertionError;
+						__all__.AttributeError = AttributeError;
+						__all__.DeprecationWarning = DeprecationWarning;
+						__all__.Exception = Exception;
+						__all__.IndexError = IndexError;
+						__all__.IterableError = IterableError;
+						__all__.KeyError = KeyError;
+						__all__.NotImplementedError = NotImplementedError;
+						__all__.RuntimeWarning = RuntimeWarning;
+						__all__.StopIteration = StopIteration;
+						__all__.py_TypeError = py_TypeError;
+						__all__.UserWarning = UserWarning;
+						__all__.ValueError = ValueError;
+						__all__.Warning = Warning;
+						__all__.__Terminal__ = __Terminal__;
+						__all__.__name__ = __name__;
+						__all__.__sort__ = __sort__;
+						__all__.__terminal__ = __terminal__;
+						__all__.complex = complex;
+						__all__.filter = filter;
+						__all__.map = map;
+						__all__.sorted = sorted;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+    var __call__ = function (/* <callee>, <this>, <params>* */) {   // Needed for __base__ and __standard__ if global 'opov' switch is on
+        var args = [] .slice.apply (arguments);
+        if (typeof args [0] == 'object' && '__call__' in args [0]) {        // Overloaded
+            return args [0] .__call__ .apply (args [1], args.slice (2));
+        }
+        else {                                                              // Native
+            return args [0] .apply (args [1], args.slice (2));
+        }
+    };
+    __all__.__call__ = __call__;
+
+    // Initialize non-nested modules __base__ and __standard__ and make its names available directly and via __all__
+    // They can't do that itself, because they're regular Python modules
+    // The compiler recognizes their names and generates them inline rather than nesting them
+    // In this way it isn't needed to import them everywhere
+
+    // __base__
+
+    __nest__ (__all__, '', __init__ (__all__.org.transcrypt.__base__));
+    var __envir__ = __all__.__envir__;
+
+    // __standard__
+
+    __nest__ (__all__, '', __init__ (__all__.org.transcrypt.__standard__));
+
+    var Exception = __all__.Exception;
+    var IterableError = __all__.IterableError;
+    var StopIteration = __all__.StopIteration;
+    var ValueError = __all__.ValueError;
+    var KeyError = __all__.KeyError;
+    var AssertionError = __all__.AssertionError;
+    var NotImplementedError = __all__.NotImplementedError;
+    var IndexError = __all__.IndexError;
+    var AttributeError = __all__.AttributeError;
+    var py_TypeError = __all__.py_TypeError;
+
+    // Warnings Exceptions
+    var Warning = __all__.Warning;
+    var UserWarning = __all__.UserWarning;
+    var DeprecationWarning = __all__.DeprecationWarning;
+    var RuntimeWarning = __all__.RuntimeWarning;
+
+    var __sort__ = __all__.__sort__;
+    var sorted = __all__.sorted;
+
+    var map = __all__.map;
+    var filter = __all__.filter;
+
+    var complex = __all__.complex;
+    __all__.print = __all__.__terminal__.print;
+    __all__.input = __all__.__terminal__.input;
+
+    var __terminal__ = __all__.__terminal__;
+    var print = __all__.print;
+    var input = __all__.input;
+
+    // Complete __envir__, that was created in __base__, for non-stub mode
+    __envir__.executor_name = __envir__.transpiler_name;
+
+    // Make make __main__ available in browser
+    var __main__ = {__file__: ''};
+    __all__.main = __main__;
+
+    // Define current exception, there's at most one exception in the air at any time
+    var __except__ = null;
+    __all__.__except__ = __except__;
+    
+     // Creator of a marked dictionary, used to pass **kwargs parameter
+    var __kwargtrans__ = function (anObject) {
+        anObject.__kwargtrans__ = null; // Removable marker
+        anObject.constructor = Object;
+        return anObject;
+    }
+    __all__.__kwargtrans__ = __kwargtrans__;
+
+    // 'Oneshot' dict promotor, used to enrich __all__ and help globals () return a true dict
+    var __globals__ = function (anObject) {
+        if (isinstance (anObject, dict)) {  // Don't attempt to promote (enrich) again, since it will make a copy
+            return anObject;
+        }
+        else {
+            return dict (anObject)
+        }
+    }
+    __all__.__globals__ = __globals__
+    
+    // Partial implementation of super () .<methodName> (<params>)
+    var __super__ = function (aClass, methodName) {
+        // Lean and fast, no C3 linearization, only call first implementation encountered
+        // Will allow __super__ ('<methodName>') (self, <params>) rather than only <className>.<methodName> (self, <params>)
+        
+        for (let base of aClass.__bases__) {
+            if (methodName in base) {
+               return base [methodName];
+            }
+        }
+
+        throw new Exception ('Superclass method not found');    // !!! Improve!
+    }
+    __all__.__super__ = __super__
+        
+    // Python property installer function, no member since that would bloat classes
+    var property = function (getter, setter) {  // Returns a property descriptor rather than a property
+        if (!setter) {  // ??? Make setter optional instead of dummy?
+            setter = function () {};
+        }
+        return {get: function () {return getter (this)}, set: function (value) {setter (this, value)}, enumerable: true};
+    }
+    __all__.property = property;
+    
+    // Conditional JavaScript property installer function, prevents redefinition of properties if multiple Transcrypt apps are on one page
+    var __setProperty__ = function (anObject, name, descriptor) {
+        if (!anObject.hasOwnProperty (name)) {
+            Object.defineProperty (anObject, name, descriptor);
+        }
+    }
+    __all__.__setProperty__ = __setProperty__
+    
+    // Assert function, call to it only generated when compiling with --dassert option
+    function assert (condition, message) {  // Message may be undefined
+        if (!condition) {
+            throw AssertionError (message, new Error ());
+        }
+    }
+
+    __all__.assert = assert;
+
+    var __merge__ = function (object0, object1) {
+        var result = {};
+        for (var attrib in object0) {
+            result [attrib] = object0 [attrib];
+        }
+        for (var attrib in object1) {
+            result [attrib] = object1 [attrib];
+        }
+        return result;
+    };
+    __all__.__merge__ = __merge__;
+
+    // Manipulating attributes by name
+    
+    var dir = function (obj) {
+        var aList = [];
+        for (var aKey in obj) {
+            aList.push (aKey);
+        }
+        aList.sort ();
+        return aList;
+    };
+    __all__.dir = dir;
+
+    var setattr = function (obj, name, value) {
+        obj [name] = value;
+    };
+    __all__.setattr = setattr;
+
+    var getattr = function (obj, name) {
+        return obj [name];
+    };
+    __all__.getattr= getattr;
+
+    var hasattr = function (obj, name) {
+        try {
+            return name in obj;
+        }
+        catch (exception) {
+            return false;
+        }
+    };
+    __all__.hasattr = hasattr;
+
+    var delattr = function (obj, name) {
+        delete obj [name];
+    };
+    __all__.delattr = (delattr);
+
+    // The __in__ function, used to mimic Python's 'in' operator
+    // In addition to CPython's semantics, the 'in' operator is also allowed to work on objects, avoiding a counterintuitive separation between Python dicts and JavaScript objects
+    // In general many Transcrypt compound types feature a deliberate blend of Python and JavaScript facilities, facilitating efficient integration with JavaScript libraries
+    // If only Python objects and Python dicts are dealt with in a certain context, the more pythonic 'hasattr' is preferred for the objects as opposed to 'in' for the dicts
+    var __in__ = function (element, container) {
+        if (py_typeof (container) == dict) {        // Currently only implemented as an augmented JavaScript object
+            return container.hasOwnProperty (element);
+        }
+        else {                                      // Parameter 'element' itself is an array, string or a plain, non-dict JavaScript object
+            return (
+                container.indexOf ?                 // If it has an indexOf
+                container.indexOf (element) > -1 :  // it's an array or a string,
+                container.hasOwnProperty (element)  // else it's a plain, non-dict JavaScript object
+            );
+        }
+    };
+    __all__.__in__ = __in__;
+
+    // Find out if an attribute is special
+    var __specialattrib__ = function (attrib) {
+        return (attrib.startswith ('__') && attrib.endswith ('__')) || attrib == 'constructor' || attrib.startswith ('py_');
+    };
+    __all__.__specialattrib__ = __specialattrib__;
+
+    // Compute length of any object
+    var len = function (anObject) {
+        if (anObject === undefined || anObject === null) {
+            return 0;
+        }
+
+        if (anObject.__len__ instanceof Function) {
+            return anObject.__len__ ();
+        }
+
+        if (anObject.length !== undefined) {
+            return anObject.length;
+        }
+
+        var length = 0;
+        for (var attr in anObject) {
+            if (!__specialattrib__ (attr)) {
+                length++;
+            }
+        }
+
+        return length;
+    };
+    __all__.len = len;
+
+    // General conversions and checks
+
+    function __i__ (any) {  //  Convert to iterable
+        return py_typeof (any) == dict ? any.py_keys () : any;
+    }
+
+    function __k__ (keyed, key) {  //  Check existence of dict key via retrieved element
+        var result = keyed [key];
+        if (typeof result == 'undefined') {
+             throw KeyError (key, new Error());
+        }
+        return result;
+    }
+
+    // If the target object is somewhat true, return it. Otherwise return false.
+    // Try to follow Python conventions of truthyness
+    function __t__ (target) { 
+        return (
+            // Avoid invalid checks
+            target === undefined || target === null ? false :
+            
+            // Take a quick shortcut if target is a simple type
+            ['boolean', 'number'] .indexOf (typeof target) >= 0 ? target :
+            
+            // Use __bool__ (if present) to decide if target is true
+            target.__bool__ instanceof Function ? (target.__bool__ () ? target : false) :
+            
+            // There is no __bool__, use __len__ (if present) instead
+            target.__len__ instanceof Function ?  (target.__len__ () !== 0 ? target : false) :
+            
+            // There is no __bool__ and no __len__, declare Functions true.
+            // Python objects are transpiled into instances of Function and if
+            // there is no __bool__ or __len__, the object in Python is true.
+            target instanceof Function ? target :
+            
+            // Target is something else, compute its len to decide
+            len (target) !== 0 ? target :
+            
+            // When all else fails, declare target as false
+            false
+        );
+    }
+    __all__.__t__ = __t__;
+
+    var bool = function (any) {     // Always truly returns a bool, rather than something truthy or falsy
+        return !!__t__ (any);
+    };
+    bool.__name__ = 'bool';         // So it can be used as a type with a name
+    __all__.bool = bool;
+
+    var float = function (any) {
+        if (any == 'inf') {
+            return Infinity;
+        }
+        else if (any == '-inf') {
+            return -Infinity;
+        }
+        else if (isNaN (parseFloat (any))) {    // Call to parseFloat needed to exclude '', ' ' etc.
+            if (any === false) {
+                return 0;
+            }
+            else if (any === true) {
+                return 1;
+            }
+            else {  // Needed e.g. in autoTester.check, so "return any ? true : false" won't do
+                throw ValueError ("could not convert string to float: '" + str(any) + "'", new Error ());
+            }
+        }
+        else {
+            return +any;
+        }
+    };
+    float.__name__ = 'float';
+    __all__.float = float;
+
+    var int = function (any) {
+        return float (any) | 0
+    };
+    int.__name__ = 'int';
+    __all__.int = int;
+
+    var py_typeof = function (anObject) {
+        var aType = typeof anObject;
+        if (aType == 'object') {    // Directly trying '__class__ in anObject' turns out to wreck anObject in Chrome if its a primitive
+            try {
+                return anObject.__class__;
+            }
+            catch (exception) {
+                return aType;
+            }
+        }
+        else {
+            return (    // Odly, the braces are required here
+                aType == 'boolean' ? bool :
+                aType == 'string' ? str :
+                aType == 'number' ? (anObject % 1 == 0 ? int : float) :
+                null
+            );
+        }
+    };
+    __all__.py_typeof = py_typeof;
+
+    var isinstance = function (anObject, classinfo) {
+        function isA (queryClass) {
+            if (queryClass == classinfo) {
+                return true;
+            }
+            for (var index = 0; index < queryClass.__bases__.length; index++) {
+                if (isA (queryClass.__bases__ [index], classinfo)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        if (classinfo instanceof Array) {   // Assume in most cases it isn't, then making it recursive rather than two functions saves a call
+            for (let aClass of classinfo) {
+                if (isinstance (anObject, aClass)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        try {                   // Most frequent use case first
+            return '__class__' in anObject ? isA (anObject.__class__) : anObject instanceof classinfo;
+        }
+        catch (exception) {     // Using isinstance on primitives assumed rare
+            var aType = py_typeof (anObject);
+            return aType == classinfo || (aType == bool && classinfo == int);
+        }
+    };
+    __all__.isinstance = isinstance;
+
+    var callable = function (anObject) {
+        if ( typeof anObject == 'object' && '__call__' in anObject ) {
+            return true;
+        }
+        else {
+            return typeof anObject === 'function';
+        }
+    };
+    __all__.callable = callable;
+
+    // Repr function uses __repr__ method, then __str__, then toString
+    var repr = function (anObject) {
+        try {
+            return anObject.__repr__ ();
+        }
+        catch (exception) {
+            try {
+                return anObject.__str__ ();
+            }
+            catch (exception) { // anObject has no __repr__ and no __str__
+                try {
+                    if (anObject == null) {
+                        return 'None';
+                    }
+                    else if (anObject.constructor == Object) {
+                        var result = '{';
+                        var comma = false;
+                        for (var attrib in anObject) {
+                            if (!__specialattrib__ (attrib)) {
+                                if (attrib.isnumeric ()) {
+                                    var attribRepr = attrib;                // If key can be interpreted as numerical, we make it numerical
+                                }                                           // So we accept that '1' is misrepresented as 1
+                                else {
+                                    var attribRepr = '\'' + attrib + '\'';  // Alpha key in dict
+                                }
+
+                                if (comma) {
+                                    result += ', ';
+                                }
+                                else {
+                                    comma = true;
+                                }
+                                result += attribRepr + ': ' + repr (anObject [attrib]);
+                            }
+                        }
+                        result += '}';
+                        return result;
+                    }
+                    else {
+                        return typeof anObject == 'boolean' ? anObject.toString () .capitalize () : anObject.toString ();
+                    }
+                }
+                catch (exception) {
+                    return '<object of type: ' + typeof anObject + '>';
+                }
+            }
+        }
+    };
+    __all__.repr = repr;
+
+    // Char from Unicode or ASCII
+    var chr = function (charCode) {
+        return String.fromCharCode (charCode);
+    };
+    __all__.chr = chr;
+
+    // Unicode or ASCII from char
+    var ord = function (aChar) {
+        return aChar.charCodeAt (0);
+    };
+    __all__.ord = ord;
+
+    // Maximum of n numbers
+    var max = Math.max;
+    __all__.max = max;
+
+    // Minimum of n numbers
+    var min = Math.min;
+    __all__.min = min;
+
+    // Absolute value
+    var abs = function (x) {
+        try {
+            return Math.abs (x);
+        }
+        catch (exception) {
+            return Math.sqrt (x.real * x.real + x.imag * x.imag);
+        }
+    };
+
+    // Bankers rounding
+    var round = function (number, ndigits) {
+        if (ndigits) {
+            var scale = Math.pow (10, ndigits);
+            number *= scale;
+        }
+
+        var rounded = Math.round (number);
+        if (rounded - number == 0.5 && rounded % 2) {   // Has rounded up to odd, should have rounded down to even
+            rounded -= 1;
+        }
+
+        if (ndigits) {
+            rounded /= scale;
+        }
+
+        return rounded;
+    };
+    __all__.round = round;
+
+    // BEGIN unified iterator model
+
+    function __jsUsePyNext__ () {       // Add as 'next' method to make Python iterator JavaScript compatible
+        try {
+            var result = this.__next__ ();
+            return {value: result, done: false};
+        }
+        catch (exception) {
+            return {value: undefined, done: true};
+        }
+    }
+
+    function __pyUseJsNext__ () {       // Add as '__next__' method to make JavaScript iterator Python compatible
+        var result = this.next ();
+        if (result.done) {
+            throw StopIteration (new Error ());
+        }
+        else {
+            return result.value;
+        }
+    }
+
+    function py_iter (iterable) {                   // Alias for Python's iter function, produces a universal iterator / iterable, usable in Python and JavaScript
+        if (typeof iterable == 'string' || '__iter__' in iterable) {    // JavaScript Array or string or Python iterable (string has no 'in')
+            var result = iterable.__iter__ ();                          // Iterator has a __next__
+            result.next = __jsUsePyNext__;                              // Give it a next
+        }
+        else if ('selector' in iterable) {                              // Assume it's a JQuery iterator
+            var result = list (iterable) .__iter__ ();                  // Has a __next__
+            result.next = __jsUsePyNext__;                              // Give it a next
+        }
+        else if ('next' in iterable) {                                  // It's a JavaScript iterator already,  maybe a generator, has a next and may have a __next__
+            var result = iterable
+            if (! ('__next__' in result)) {                             // If there's no danger of recursion
+                result.__next__ = __pyUseJsNext__;                      // Give it a __next__
+            }
+        }
+        else if (Symbol.iterator in iterable) {                         // It's a JavaScript iterable such as a typed array, but not an iterator
+            var result = iterable [Symbol.iterator] ();                 // Has a next
+            result.__next__ = __pyUseJsNext__;                          // Give it a __next__
+        }
+        else {
+            throw IterableError (new Error ()); // No iterator at all
+        }
+        result [Symbol.iterator] = function () {return result;};
+        return result;
+    }
+
+    function py_next (iterator) {               // Called only in a Python context, could receive Python or JavaScript iterator
+        try {                                   // Primarily assume Python iterator, for max speed
+            var result = iterator.__next__ ();
+        }
+        catch (exception) {                     // JavaScript iterators are the exception here
+            var result = iterator.next ();
+            if (result.done) {
+                throw StopIteration (new Error ());
+            }
+            else {
+                return result.value;
+            }
+        }
+        if (result == undefined) {
+            throw StopIteration (new Error ());
+        }
+        else {
+            return result;
+        }
+    }
+
+    function __PyIterator__ (iterable) {
+        this.iterable = iterable;
+        this.index = 0;
+    }
+
+    __PyIterator__.prototype.__next__ = function () {
+        if (this.index < this.iterable.length) {
+            return this.iterable [this.index++];
+        }
+        else {
+            throw StopIteration (new Error ());
+        }
+    };
+
+    function __JsIterator__ (iterable) {
+        this.iterable = iterable;
+        this.index = 0;
+    }
+
+    __JsIterator__.prototype.next = function () {
+        if (this.index < this.iterable.py_keys.length) {
+            return {value: this.index++, done: false};
+        }
+        else {
+            return {value: undefined, done: true};
+        }
+    };
+
+    // END unified iterator model
+
+    // Reversed function for arrays
+    var py_reversed = function (iterable) {
+        iterable = iterable.slice ();
+        iterable.reverse ();
+        return iterable;
+    };
+    __all__.py_reversed = py_reversed;
+
+    // Zip method for arrays and strings
+    var zip = function () {
+        var args = [] .slice.call (arguments);
+        for (var i = 0; i < args.length; i++) {
+            if (typeof args [i] == 'string') {
+                args [i] = args [i] .split ('');
+            }
+            else if (!Array.isArray (args [i])) {
+                args [i] = Array.from (args [i]);
+            }
+        }
+        var shortest = args.length == 0 ? [] : args.reduce (    // Find shortest array in arguments
+            function (array0, array1) {
+                return array0.length < array1.length ? array0 : array1;
+            }
+        );
+        return shortest.map (                   // Map each element of shortest array
+            function (current, index) {         // To the result of this function
+                return args.map (               // Map each array in arguments
+                    function (current) {        // To the result of this function
+                        return current [index]; // Namely it's index't entry
+                    }
+                );
+            }
+        );
+    };
+    __all__.zip = zip;
+
+    // Range method, returning an array
+    function range (start, stop, step) {
+        if (stop == undefined) {
+            // one param defined
+            stop = start;
+            start = 0;
+        }
+        if (step == undefined) {
+            step = 1;
+        }
+        if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
+            return [];
+        }
+        var result = [];
+        for (var i = start; step > 0 ? i < stop : i > stop; i += step) {
+            result.push(i);
+        }
+        return result;
+    };
+    __all__.range = range;
+
+    // Any, all and sum
+
+    function any (iterable) {
+        for (let item of iterable) {
+            if (bool (item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function all (iterable) {
+        for (let item of iterable) {
+            if (! bool (item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function sum (iterable) {
+        let result = 0;
+        for (let item of iterable) {
+            result += item;
+        }
+        return result;
+    }
+
+    __all__.any = any;
+    __all__.all = all;
+    __all__.sum = sum;
+
+    // Enumerate method, returning a zipped list
+    function enumerate (iterable) {
+        return zip (range (len (iterable)), iterable);
+    }
+    __all__.enumerate = enumerate;
+
+    // Shallow and deepcopy
+
+    function copy (anObject) {
+        if (anObject == null || typeof anObject == "object") {
+            return anObject;
+        }
+        else {
+            var result = {};
+            for (var attrib in obj) {
+                if (anObject.hasOwnProperty (attrib)) {
+                    result [attrib] = anObject [attrib];
+                }
+            }
+            return result;
+        }
+    }
+    __all__.copy = copy;
+
+    function deepcopy (anObject) {
+        if (anObject == null || typeof anObject == "object") {
+            return anObject;
+        }
+        else {
+            var result = {};
+            for (var attrib in obj) {
+                if (anObject.hasOwnProperty (attrib)) {
+                    result [attrib] = deepcopy (anObject [attrib]);
+                }
+            }
+            return result;
+        }
+    }
+    __all__.deepcopy = deepcopy;
+
+    // List extensions to Array
+
+    function list (iterable) {                                      // All such creators should be callable without new
+        var instance = iterable ? Array.from (iterable) : [];
+        // Sort is the normal JavaScript sort, Python sort is a non-member function
+        return instance;
+    }
+    __all__.list = list;
+    Array.prototype.__class__ = list;   // All arrays are lists (not only if constructed by the list ctor), unless constructed otherwise
+    list.__name__ = 'list';
+
+    /*
+    Array.from = function (iterator) { // !!! remove
+        result = [];
+        for (item of iterator) {
+            result.push (item);
+        }
+        return result;
+    }
+    */
+
+    Array.prototype.__iter__ = function () {return new __PyIterator__ (this);};
+
+    Array.prototype.__getslice__ = function (start, stop, step) {
+        if (start < 0) {
+            start = this.length + start;
+        }
+
+        if (stop == null) {
+            stop = this.length;
+        }
+        else if (stop < 0) {
+            stop = this.length + stop;
+        }
+        else if (stop > this.length) {
+            stop = this.length;
+        }
+
+        var result = list ([]);
+        for (var index = start; index < stop; index += step) {
+            result.push (this [index]);
+        }
+
+        return result;
+    };
+
+    Array.prototype.__setslice__ = function (start, stop, step, source) {
+        if (start < 0) {
+            start = this.length + start;
+        }
+
+        if (stop == null) {
+            stop = this.length;
+        }
+        else if (stop < 0) {
+            stop = this.length + stop;
+        }
+
+        if (step == null) { // Assign to 'ordinary' slice, replace subsequence
+            Array.prototype.splice.apply (this, [start, stop - start] .concat (source));
+        }
+        else {              // Assign to extended slice, replace designated items one by one
+            var sourceIndex = 0;
+            for (var targetIndex = start; targetIndex < stop; targetIndex += step) {
+                this [targetIndex] = source [sourceIndex++];
+            }
+        }
+    };
+
+    Array.prototype.__repr__ = function () {
+        if (this.__class__ == set && !this.length) {
+            return 'set()';
+        }
+
+        var result = !this.__class__ || this.__class__ == list ? '[' : this.__class__ == tuple ? '(' : '{';
+
+        for (var index = 0; index < this.length; index++) {
+            if (index) {
+                result += ', ';
+            }
+            result += repr (this [index]);
+        }
+
+        if (this.__class__ == tuple && this.length == 1) {
+            result += ',';
+        }
+
+        result += !this.__class__ || this.__class__ == list ? ']' : this.__class__ == tuple ? ')' : '}';;
+        return result;
+    };
+
+    Array.prototype.__str__ = Array.prototype.__repr__;
+
+    Array.prototype.append = function (element) {
+        this.push (element);
+    };
+
+    Array.prototype.py_clear = function () {
+        this.length = 0;
+    };
+
+    Array.prototype.extend = function (aList) {
+        this.push.apply (this, aList);
+    };
+
+    Array.prototype.insert = function (index, element) {
+        this.splice (index, 0, element);
+    };
+
+    Array.prototype.remove = function (element) {
+        var index = this.indexOf (element);
+        if (index == -1) {
+            throw ValueError ("list.remove(x): x not in list", new Error ());
+        }
+        this.splice (index, 1);
+    };
+
+    Array.prototype.index = function (element) {
+        return this.indexOf (element);
+    };
+
+    Array.prototype.py_pop = function (index) {
+        if (index == undefined) {
+            return this.pop ();  // Remove last element
+        }
+        else {
+            return this.splice (index, 1) [0];
+        }
+    };
+
+    Array.prototype.py_sort = function () {
+        __sort__.apply  (null, [this].concat ([] .slice.apply (arguments)));    // Can't work directly with arguments
+        // Python params: (iterable, key = None, reverse = False)
+        // py_sort is called with the Transcrypt kwargs mechanism, and just passes the params on to __sort__
+        // __sort__ is def'ed with the Transcrypt kwargs mechanism
+    };
+
+    Array.prototype.__add__ = function (aList) {
+        return list (this.concat (aList));
+    };
+
+    Array.prototype.__mul__ = function (scalar) {
+        var result = this;
+        for (var i = 1; i < scalar; i++) {
+            result = result.concat (this);
+        }
+        return result;
+    };
+
+    Array.prototype.__rmul__ = Array.prototype.__mul__;
+
+    // Tuple extensions to Array
+
+    function tuple (iterable) {
+        var instance = iterable ? [] .slice.apply (iterable) : [];
+        instance.__class__ = tuple; // Not all arrays are tuples
+        return instance;
+    }
+    __all__.tuple = tuple;
+    tuple.__name__ = 'tuple';
+
+    // Set extensions to Array
+    // N.B. Since sets are unordered, set operations will occasionally alter the 'this' array by sorting it
+
+    function set (iterable) {
+        var instance = [];
+        if (iterable) {
+            for (var index = 0; index < iterable.length; index++) {
+                instance.add (iterable [index]);
+            }
+        }
+        instance.__class__ = set;   // Not all arrays are sets
+        return instance;
+    }
+    __all__.set = set;
+    set.__name__ = 'set';
+
+    Array.prototype.__bindexOf__ = function (element) { // Used to turn O (n^2) into O (n log n)
+    // Since sorting is lex, compare has to be lex. This also allows for mixed lists
+
+        element += '';
+
+        var mindex = 0;
+        var maxdex = this.length - 1;
+
+        while (mindex <= maxdex) {
+            var index = (mindex + maxdex) / 2 | 0;
+            var middle = this [index] + '';
+
+            if (middle < element) {
+                mindex = index + 1;
+            }
+            else if (middle > element) {
+                maxdex = index - 1;
+            }
+            else {
+                return index;
+            }
+        }
+
+        return -1;
+    };
+
+    Array.prototype.add = function (element) {
+        if (this.indexOf (element) == -1) { // Avoid duplicates in set
+            this.push (element);
+        }
+    };
+
+    Array.prototype.discard = function (element) {
+        var index = this.indexOf (element);
+        if (index != -1) {
+            this.splice (index, 1);
+        }
+    };
+
+    Array.prototype.isdisjoint = function (other) {
+        this.sort ();
+        for (var i = 0; i < other.length; i++) {
+            if (this.__bindexOf__ (other [i]) != -1) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    Array.prototype.issuperset = function (other) {
+        this.sort ();
+        for (var i = 0; i < other.length; i++) {
+            if (this.__bindexOf__ (other [i]) == -1) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    Array.prototype.issubset = function (other) {
+        return set (other.slice ()) .issuperset (this); // Sort copy of 'other', not 'other' itself, since it may be an ordered sequence
+    };
+
+    Array.prototype.union = function (other) {
+        var result = set (this.slice () .sort ());
+        for (var i = 0; i < other.length; i++) {
+            if (result.__bindexOf__ (other [i]) == -1) {
+                result.push (other [i]);
+            }
+        }
+        return result;
+    };
+
+    Array.prototype.intersection = function (other) {
+        this.sort ();
+        var result = set ();
+        for (var i = 0; i < other.length; i++) {
+            if (this.__bindexOf__ (other [i]) != -1) {
+                result.push (other [i]);
+            }
+        }
+        return result;
+    };
+
+    Array.prototype.difference = function (other) {
+        var sother = set (other.slice () .sort ());
+        var result = set ();
+        for (var i = 0; i < this.length; i++) {
+            if (sother.__bindexOf__ (this [i]) == -1) {
+                result.push (this [i]);
+            }
+        }
+        return result;
+    };
+
+    Array.prototype.symmetric_difference = function (other) {
+        return this.union (other) .difference (this.intersection (other));
+    };
+
+    Array.prototype.py_update = function () {   // O (n)
+        var updated = [] .concat.apply (this.slice (), arguments) .sort ();
+        this.py_clear ();
+        for (var i = 0; i < updated.length; i++) {
+            if (updated [i] != updated [i - 1]) {
+                this.push (updated [i]);
+            }
+        }
+    };
+
+    Array.prototype.__eq__ = function (other) { // Also used for list
+        if (this.length != other.length) {
+            return false;
+        }
+        if (this.__class__ == set) {
+            this.sort ();
+            other.sort ();
+        }
+        for (var i = 0; i < this.length; i++) {
+            if (this [i] != other [i]) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    Array.prototype.__ne__ = function (other) { // Also used for list
+        return !this.__eq__ (other);
+    };
+
+    Array.prototype.__le__ = function (other) {
+        return this.issubset (other);
+    };
+
+    Array.prototype.__ge__ = function (other) {
+        return this.issuperset (other);
+    };
+
+    Array.prototype.__lt__ = function (other) {
+        return this.issubset (other) && !this.issuperset (other);
+    };
+
+    Array.prototype.__gt__ = function (other) {
+        return this.issuperset (other) && !this.issubset (other);
+    };
+
+    // Byte array extensions
+    
+    function bytearray (bytable, encoding) {
+        if (bytable == undefined) {
+            return new Uint8Array (0);
+        }
+        else {
+            var aType = py_typeof (bytable);
+            if (aType == int) {
+                return new Uint8Array (bytable);
+            }
+            else if (aType == str) {
+                var aBytes = new Uint8Array (len (bytable));
+                for (var i = 0; i < len (bytable); i++) {
+                    aBytes [i] = bytable.charCodeAt (i);
+                }
+                return aBytes;
+            }
+            else if (aType == list || aType == tuple) {
+                return new Uint8Array (bytable);
+            }
+            else {
+                throw py_TypeError;
+            }
+        }
+    }
+
+    var bytes = bytearray;
+    
+    __all__.bytearray = bytearray;
+    __all__.bytes = bytearray;
+   
+    Uint8Array.prototype.__add__ = function (aBytes) {
+        var result = new Uint8Array (this.length + aBytes.length);
+        result.set (this);
+        result.set (aBytes, this.length);
+        return result;
+    };
+
+    Uint8Array.prototype.__mul__ = function (scalar) {
+        var result = new Uint8Array (scalar * this.length);
+        for (var i = 0; i < scalar; i++) {
+            result.set (this, i * this.length);
+        }
+        return result;
+    };
+
+    Uint8Array.prototype.__rmul__ = Uint8Array.prototype.__mul__;
+    
+    // String extensions
+
+    function str (stringable) {
+        try {
+            return stringable.__str__ ();
+        }
+        catch (exception) {
+            try {
+                return repr (stringable);
+            }
+            catch (exception) {
+                return String (stringable); // No new, so no permanent String object but a primitive in a temporary 'just in time' wrapper
+            }
+        }
+    };
+    __all__.str = str;
+
+    String.prototype.__class__ = str;   // All strings are str
+    str.__name__ = 'str';
+
+    String.prototype.__iter__ = function () {new __PyIterator__ (this);};
+
+    String.prototype.__repr__ = function () {
+        return (this.indexOf ('\'') == -1 ? '\'' + this + '\'' : '"' + this + '"') .py_replace ('\t', '\\t') .py_replace ('\n', '\\n');
+    };
+
+    String.prototype.__str__ = function () {
+        return this;
+    };
+
+    String.prototype.capitalize = function () {
+        return this.charAt (0).toUpperCase () + this.slice (1);
+    };
+
+    String.prototype.endswith = function (suffix) {
+        return suffix == '' || this.slice (-suffix.length) == suffix;
+    };
+
+    String.prototype.find  = function (sub, start) {
+        return this.indexOf (sub, start);
+    };
+
+    String.prototype.__getslice__ = function (start, stop, step) {
+        if (start < 0) {
+            start = this.length + start;
+        }
+
+        if (stop == null) {
+            stop = this.length;
+        }
+        else if (stop < 0) {
+            stop = this.length + stop;
+        }
+
+        var result = '';
+        if (step == 1) {
+            result = this.substring (start, stop);
+        }
+        else {
+            for (var index = start; index < stop; index += step) {
+                result = result.concat (this.charAt(index));
+            }
+        }
+        return result;
+    }
+
+    // Since it's worthwhile for the 'format' function to be able to deal with *args, it is defined as a property
+    // __get__ will produce a bound function if there's something before the dot
+    // Since a call using *args is compiled to e.g. <object>.<function>.apply (null, args), the function has to be bound already
+    // Otherwise it will never be, because of the null argument
+    // Using 'this' rather than 'null' contradicts the requirement to be able to pass bound functions around
+    // The object 'before the dot' won't be available at call time in that case, unless implicitly via the function bound to it
+    // While for Python methods this mechanism is generated by the compiler, for JavaScript methods it has to be provided manually
+    // Call memoizing is unattractive here, since every string would then have to hold a reference to a bound format method
+    __setProperty__ (String.prototype, 'format', {
+        get: function () {return __get__ (this, function (self) {
+            var args = tuple ([] .slice.apply (arguments).slice (1));
+            var autoIndex = 0;
+            return self.replace (/\{(\w*)\}/g, function (match, key) {
+                if (key == '') {
+                    key = autoIndex++;
+                }
+                if (key == +key) {  // So key is numerical
+                    return args [key] == undefined ? match : str (args [key]);
+                }
+                else {              // Key is a string
+                    for (var index = 0; index < args.length; index++) {
+                        // Find first 'dict' that has that key and the right field
+                        if (typeof args [index] == 'object' && args [index][key] != undefined) {
+                            return str (args [index][key]); // Return that field field
+                        }
+                    }
+                    return match;
+                }
+            });
+        });},
+        enumerable: true
+    });
+
+    String.prototype.isalnum = function () {
+        return /^[0-9a-zA-Z]{1,}$/.test(this)
+    }
+
+    String.prototype.isalpha = function () {
+        return /^[a-zA-Z]{1,}$/.test(this)
+    }
+
+    String.prototype.isdecimal = function () {
+        return /^[0-9]{1,}$/.test(this)
+    }
+
+    String.prototype.isdigit = function () {
+        return this.isdecimal()
+    }
+
+    String.prototype.islower = function () {
+        return /^[a-z]{1,}$/.test(this)
+    }
+
+    String.prototype.isupper = function () {
+        return /^[A-Z]{1,}$/.test(this)
+    }
+
+    String.prototype.isspace = function () {
+        return /^[\s]{1,}$/.test(this)
+    }
+
+    String.prototype.isnumeric = function () {
+        return !isNaN (parseFloat (this)) && isFinite (this);
+    };
+
+    String.prototype.join = function (strings) {
+        strings = Array.from (strings); // Much faster than iterating through strings char by char
+        return strings.join (this);
+    };
+
+    String.prototype.lower = function () {
+        return this.toLowerCase ();
+    };
+
+    String.prototype.py_replace = function (old, aNew, maxreplace) {
+        return this.split (old, maxreplace) .join (aNew);
+    };
+
+    String.prototype.lstrip = function () {
+        return this.replace (/^\s*/g, '');
+    };
+
+    String.prototype.rfind = function (sub, start) {
+        return this.lastIndexOf (sub, start);
+    };
+
+    String.prototype.rsplit = function (sep, maxsplit) {    // Combination of general whitespace sep and positive maxsplit neither supported nor checked, expensive and rare
+        if (sep == undefined || sep == null) {
+            sep = /\s+/;
+            var stripped = this.strip ();
+        }
+        else {
+            var stripped = this;
+        }
+
+        if (maxsplit == undefined || maxsplit == -1) {
+            return stripped.split (sep);
+        }
+        else {
+            var result = stripped.split (sep);
+            if (maxsplit < result.length) {
+                var maxrsplit = result.length - maxsplit;
+                return [result.slice (0, maxrsplit) .join (sep)] .concat (result.slice (maxrsplit));
+            }
+            else {
+                return result;
+            }
+        }
+    };
+
+    String.prototype.rstrip = function () {
+        return this.replace (/\s*$/g, '');
+    };
+
+    String.prototype.py_split = function (sep, maxsplit) {  // Combination of general whitespace sep and positive maxsplit neither supported nor checked, expensive and rare
+        if (sep == undefined || sep == null) {
+            sep = /\s+/;
+            var stripped = this.strip ();
+        }
+        else {
+            var stripped = this;
+        }
+
+        if (maxsplit == undefined || maxsplit == -1) {
+            return stripped.split (sep);
+        }
+        else {
+            var result = stripped.split (sep);
+            if (maxsplit < result.length) {
+                return result.slice (0, maxsplit).concat ([result.slice (maxsplit).join (sep)]);
+            }
+            else {
+                return result;
+            }
+        }
+    };
+
+    String.prototype.startswith = function (prefix) {
+        return this.indexOf (prefix) == 0;
+    };
+
+    String.prototype.strip = function () {
+        return this.trim ();
+    };
+
+    String.prototype.upper = function () {
+        return this.toUpperCase ();
+    };
+
+    String.prototype.__mul__ = function (scalar) {
+        var result = this;
+        for (var i = 1; i < scalar; i++) {
+            result = result + this;
+        }
+        return result;
+    };
+
+    String.prototype.__rmul__ = String.prototype.__mul__;
+
+    // Dict extensions to object
+
+    function __keys__ () {
+        var keys = [];
+        for (var attrib in this) {
+            if (!__specialattrib__ (attrib)) {
+                keys.push (attrib);
+            }
+        }
+        return keys;
+    }
+
+    function __items__ () {
+        var items = [];
+        for (var attrib in this) {
+            if (!__specialattrib__ (attrib)) {
+                items.push ([attrib, this [attrib]]);
+            }
+        }
+        return items;
+    }
+
+    function __del__ (key) {
+        delete this [key];
+    }
+
+    function __clear__ () {
+        for (var attrib in this) {
+            delete this [attrib];
+        }
+    }
+
+    function __getdefault__ (aKey, aDefault) {  // Each Python object already has a function called __get__, so we call this one __getdefault__
+        var result = this [aKey];
+        return result == undefined ? (aDefault == undefined ? null : aDefault) : result;
+    }
+
+    function __setdefault__ (aKey, aDefault) {
+        var result = this [aKey];
+        if (result != undefined) {
+            return result;
+        }
+        var val = aDefault == undefined ? null : aDefault;
+        this [aKey] = val;
+        return val;
+    }
+
+    function __pop__ (aKey, aDefault) {
+        var result = this [aKey];
+        if (result != undefined) {
+            delete this [aKey];
+            return result;
+        } else {
+            // Identify check because user could pass None
+            if ( aDefault === undefined ) {
+                throw KeyError (aKey, new Error());
+            }
+        }
+        return aDefault;
+    }
+    
+    function __popitem__ () {
+        var aKey = Object.keys (this) [0];
+        if (aKey == null) {
+            throw KeyError ("popitem(): dictionary is empty", new Error ());
+        }
+        var result = tuple ([aKey, this [aKey]]);
+        delete this [aKey];
+        return result;
+    }
+    
+    function __update__ (aDict) {
+        for (var aKey in aDict) {
+            this [aKey] = aDict [aKey];
+        }
+    }
+    
+    function __values__ () {
+        var values = [];
+        for (var attrib in this) {
+            if (!__specialattrib__ (attrib)) {
+                values.push (this [attrib]);
+            }
+        }
+        return values;
+
+    }
+    
+    function __dgetitem__ (aKey) {
+        return this [aKey];
+    }
+    
+    function __dsetitem__ (aKey, aValue) {
+        this [aKey] = aValue;
+    }
+
+    function dict (objectOrPairs) {
+        var instance = {};
+        if (!objectOrPairs || objectOrPairs instanceof Array) { // It's undefined or an array of pairs
+            if (objectOrPairs) {
+                for (var index = 0; index < objectOrPairs.length; index++) {
+                    var pair = objectOrPairs [index];
+                    if ( !(pair instanceof Array) || pair.length != 2) {
+                        throw ValueError(
+                            "dict update sequence element #" + index +
+                            " has length " + pair.length +
+                            "; 2 is required", new Error());
+                    }
+                    var key = pair [0];
+                    var val = pair [1];
+                    if (!(objectOrPairs instanceof Array) && objectOrPairs instanceof Object) {
+                         // User can potentially pass in an object
+                         // that has a hierarchy of objects. This
+                         // checks to make sure that these objects
+                         // get converted to dict objects instead of
+                         // leaving them as js objects.
+                         
+                         if (!isinstance (objectOrPairs, dict)) {
+                             val = dict (val);
+                         }
+                    }
+                    instance [key] = val;
+                }
+            }
+        }
+        else {
+            if (isinstance (objectOrPairs, dict)) {
+                // Passed object is a dict already so we need to be a little careful
+                // N.B. - this is a shallow copy per python std - so
+                // it is assumed that children have already become
+                // python objects at some point.
+                
+                var aKeys = objectOrPairs.py_keys ();
+                for (var index = 0; index < aKeys.length; index++ ) {
+                    var key = aKeys [index];
+                    instance [key] = objectOrPairs [key];
+                }
+            } else if (objectOrPairs instanceof Object) {
+                // Passed object is a JavaScript object but not yet a dict, don't copy it
+                instance = objectOrPairs;
+            } else {
+                // We have already covered Array so this indicates
+                // that the passed object is not a js object - i.e.
+                // it is an int or a string, which is invalid.
+                
+                throw ValueError ("Invalid type of object for dict creation", new Error ());
+            }
+        }
+
+        // Trancrypt interprets e.g. {aKey: 'aValue'} as a Python dict literal rather than a JavaScript object literal
+        // So dict literals rather than bare Object literals will be passed to JavaScript libraries
+        // Some JavaScript libraries call all enumerable callable properties of an object that's passed to them
+        // So the properties of a dict should be non-enumerable
+        __setProperty__ (instance, '__class__', {value: dict, enumerable: false, writable: true});
+        __setProperty__ (instance, 'py_keys', {value: __keys__, enumerable: false});
+        __setProperty__ (instance, '__iter__', {value: function () {new __PyIterator__ (this.py_keys ());}, enumerable: false});
+        __setProperty__ (instance, Symbol.iterator, {value: function () {new __JsIterator__ (this.py_keys ());}, enumerable: false});
+        __setProperty__ (instance, 'py_items', {value: __items__, enumerable: false});
+        __setProperty__ (instance, 'py_del', {value: __del__, enumerable: false});
+        __setProperty__ (instance, 'py_clear', {value: __clear__, enumerable: false});
+        __setProperty__ (instance, 'py_get', {value: __getdefault__, enumerable: false});
+        __setProperty__ (instance, 'py_setdefault', {value: __setdefault__, enumerable: false});
+        __setProperty__ (instance, 'py_pop', {value: __pop__, enumerable: false});
+        __setProperty__ (instance, 'py_popitem', {value: __popitem__, enumerable: false});
+        __setProperty__ (instance, 'py_update', {value: __update__, enumerable: false});
+        __setProperty__ (instance, 'py_values', {value: __values__, enumerable: false});
+        __setProperty__ (instance, '__getitem__', {value: __dgetitem__, enumerable: false});    // Needed since compound keys necessarily
+        __setProperty__ (instance, '__setitem__', {value: __dsetitem__, enumerable: false});    // trigger overloading to deal with slices
+        return instance;
+    }
+
+    __all__.dict = dict;
+    dict.__name__ = 'dict';
+    
+    // Docstring setter
+
+    function __setdoc__ (docString) {
+        this.__doc__ = docString;
+        return this;
+    }
+
+    // Python classes, methods and functions are all translated to JavaScript functions
+    __setProperty__ (Function.prototype, '__setdoc__', {value: __setdoc__, enumerable: false});
+
+    // General operator overloading, only the ones that make most sense in matrix and complex operations
+
+    var __neg__ = function (a) {
+        if (typeof a == 'object' && '__neg__' in a) {
+            return a.__neg__ ();
+        }
+        else {
+            return -a;
+        }
+    };
+    __all__.__neg__ = __neg__;
+
+    var __matmul__ = function (a, b) {
+        return a.__matmul__ (b);
+    };
+    __all__.__matmul__ = __matmul__;
+
+    var __pow__ = function (a, b) {
+        if (typeof a == 'object' && '__pow__' in a) {
+            return a.__pow__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rpow__ (a);
+        }
+        else {
+            return Math.pow (a, b);
+        }
+    };
+    __all__.pow = __pow__;
+
+    var __jsmod__ = function (a, b) {
+        if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return a % b;
+        }
+    };
+    __all__.__jsmod__ = __jsmod__;
+    
+    var __mod__ = function (a, b) {
+        if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return ((a % b) + b) % b;
+        }
+    };
+    __all__.mod = __mod__;
+
+    // Overloaded binary arithmetic
+    
+    var __mul__ = function (a, b) {
+        if (typeof a == 'object' && '__mul__' in a) {
+            return a.__mul__ (b);
+        }
+        else if (typeof b == 'object' && '__rmul__' in b) {
+            return b.__rmul__ (a);
+        }
+        else if (typeof a == 'string') {
+            return a.__mul__ (b);
+        }
+        else if (typeof b == 'string') {
+            return b.__rmul__ (a);
+        }
+        else {
+            return a * b;
+        }
+    };
+    __all__.__mul__ = __mul__;
+
+    var __truediv__ = function (a, b) {
+        if (typeof a == 'object' && '__truediv__' in a) {
+            return a.__truediv__ (b);
+        }
+        else if (typeof b == 'object' && '__rtruediv__' in b) {
+            return b.__rtruediv__ (a);
+        }
+        else if (typeof a == 'object' && '__div__' in a) {
+            return a.__div__ (b);
+        }
+        else if (typeof b == 'object' && '__rdiv__' in b) {
+            return b.__rdiv__ (a);
+        }
+        else {
+            return a / b;
+        }
+    };
+    __all__.__truediv__ = __truediv__;
+
+    var __floordiv__ = function (a, b) {
+        if (typeof a == 'object' && '__floordiv__' in a) {
+            return a.__floordiv__ (b);
+        }
+        else if (typeof b == 'object' && '__rfloordiv__' in b) {
+            return b.__rfloordiv__ (a);
+        }
+        else if (typeof a == 'object' && '__div__' in a) {
+            return a.__div__ (b);
+        }
+        else if (typeof b == 'object' && '__rdiv__' in b) {
+            return b.__rdiv__ (a);
+        }
+        else {
+            return Math.floor (a / b);
+        }
+    };
+    __all__.__floordiv__ = __floordiv__;
+
+    var __add__ = function (a, b) {
+        if (typeof a == 'object' && '__add__' in a) {
+            return a.__add__ (b);
+        }
+        else if (typeof b == 'object' && '__radd__' in b) {
+            return b.__radd__ (a);
+        }
+        else {
+            return a + b;
+        }
+    };
+    __all__.__add__ = __add__;
+
+    var __sub__ = function (a, b) {
+        if (typeof a == 'object' && '__sub__' in a) {
+            return a.__sub__ (b);
+        }
+        else if (typeof b == 'object' && '__rsub__' in b) {
+            return b.__rsub__ (a);
+        }
+        else {
+            return a - b;
+        }
+    };
+    __all__.__sub__ = __sub__;
+
+    // Overloaded binary bitwise
+    
+    var __lshift__ = function (a, b) {
+        if (typeof a == 'object' && '__lshift__' in a) {
+            return a.__lshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rlshift__' in b) {
+            return b.__rlshift__ (a);
+        }
+        else {
+            return a << b;
+        }
+    };
+    __all__.__lshift__ = __lshift__;
+
+    var __rshift__ = function (a, b) {
+        if (typeof a == 'object' && '__rshift__' in a) {
+            return a.__rshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rrshift__' in b) {
+            return b.__rrshift__ (a);
+        }
+        else {
+            return a >> b;
+        }
+    };
+    __all__.__rshift__ = __rshift__;
+
+    var __or__ = function (a, b) {
+        if (typeof a == 'object' && '__or__' in a) {
+            return a.__or__ (b);
+        }
+        else if (typeof b == 'object' && '__ror__' in b) {
+            return b.__ror__ (a);
+        }
+        else {
+            return a | b;
+        }
+    };
+    __all__.__or__ = __or__;
+
+    var __xor__ = function (a, b) {
+        if (typeof a == 'object' && '__xor__' in a) {
+            return a.__xor__ (b);
+        }
+        else if (typeof b == 'object' && '__rxor__' in b) {
+            return b.__rxor__ (a);
+        }
+        else {
+            return a ^ b;
+        }
+    };
+    __all__.__xor__ = __xor__;
+
+    var __and__ = function (a, b) {
+        if (typeof a == 'object' && '__and__' in a) {
+            return a.__and__ (b);
+        }
+        else if (typeof b == 'object' && '__rand__' in b) {
+            return b.__rand__ (a);
+        }
+        else {
+            return a & b;
+        }
+    };
+    __all__.__and__ = __and__;
+
+    // Overloaded binary compare
+    
+    var __eq__ = function (a, b) {
+        if (typeof a == 'object' && '__eq__' in a) {
+            return a.__eq__ (b);
+        }
+        else {
+            return a == b;
+        }
+    };
+    __all__.__eq__ = __eq__;
+
+    var __ne__ = function (a, b) {
+        if (typeof a == 'object' && '__ne__' in a) {
+            return a.__ne__ (b);
+        }
+        else {
+            return a != b
+        }
+    };
+    __all__.__ne__ = __ne__;
+
+    var __lt__ = function (a, b) {
+        if (typeof a == 'object' && '__lt__' in a) {
+            return a.__lt__ (b);
+        }
+        else {
+            return a < b;
+        }
+    };
+    __all__.__lt__ = __lt__;
+
+    var __le__ = function (a, b) {
+        if (typeof a == 'object' && '__le__' in a) {
+            return a.__le__ (b);
+        }
+        else {
+            return a <= b;
+        }
+    };
+    __all__.__le__ = __le__;
+
+    var __gt__ = function (a, b) {
+        if (typeof a == 'object' && '__gt__' in a) {
+            return a.__gt__ (b);
+        }
+        else {
+            return a > b;
+        }
+    };
+    __all__.__gt__ = __gt__;
+
+    var __ge__ = function (a, b) {
+        if (typeof a == 'object' && '__ge__' in a) {
+            return a.__ge__ (b);
+        }
+        else {
+            return a >= b;
+        }
+    };
+    __all__.__ge__ = __ge__;
+    
+    // Overloaded augmented general
+    
+    var __imatmul__ = function (a, b) {
+        if ('__imatmul__' in a) {
+            return a.__imatmul__ (b);
+        }
+        else {
+            return a.__matmul__ (b);
+        }
+    };
+    __all__.__imatmul__ = __imatmul__;
+
+    var __ipow__ = function (a, b) {
+        if (typeof a == 'object' && '__pow__' in a) {
+            return a.__ipow__ (b);
+        }
+        else if (typeof a == 'object' && '__ipow__' in a) {
+            return a.__pow__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rpow__ (a);
+        }
+        else {
+            return Math.pow (a, b);
+        }
+    };
+    __all__.ipow = __ipow__;
+
+    var __ijsmod__ = function (a, b) {
+        if (typeof a == 'object' && '__imod__' in a) {
+            return a.__ismod__ (b);
+        }
+        else if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return a % b;
+        }
+    };
+    __all__.ijsmod__ = __ijsmod__;
+    
+    var __imod__ = function (a, b) {
+        if (typeof a == 'object' && '__imod__' in a) {
+            return a.__imod__ (b);
+        }
+        else if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return ((a % b) + b) % b;
+        }
+    };
+    __all__.imod = __imod__;
+    
+    // Overloaded augmented arithmetic
+    
+    var __imul__ = function (a, b) {
+        if (typeof a == 'object' && '__imul__' in a) {
+            return a.__imul__ (b);
+        }
+        else if (typeof a == 'object' && '__mul__' in a) {
+            return a = a.__mul__ (b);
+        }
+        else if (typeof b == 'object' && '__rmul__' in b) {
+            return a = b.__rmul__ (a);
+        }
+        else if (typeof a == 'string') {
+            return a = a.__mul__ (b);
+        }
+        else if (typeof b == 'string') {
+            return a = b.__rmul__ (a);
+        }
+        else {
+            return a *= b;
+        }
+    };
+    __all__.__imul__ = __imul__;
+
+    var __idiv__ = function (a, b) {
+        if (typeof a == 'object' && '__idiv__' in a) {
+            return a.__idiv__ (b);
+        }
+        else if (typeof a == 'object' && '__div__' in a) {
+            return a = a.__div__ (b);
+        }
+        else if (typeof b == 'object' && '__rdiv__' in b) {
+            return a = b.__rdiv__ (a);
+        }
+        else {
+            return a /= b;
+        }
+    };
+    __all__.__idiv__ = __idiv__;
+
+    var __iadd__ = function (a, b) {
+        if (typeof a == 'object' && '__iadd__' in a) {
+            return a.__iadd__ (b);
+        }
+        else if (typeof a == 'object' && '__add__' in a) {
+            return a = a.__add__ (b);
+        }
+        else if (typeof b == 'object' && '__radd__' in b) {
+            return a = b.__radd__ (a);
+        }
+        else {
+            return a += b;
+        }
+    };
+    __all__.__iadd__ = __iadd__;
+
+    var __isub__ = function (a, b) {
+        if (typeof a == 'object' && '__isub__' in a) {
+            return a.__isub__ (b);
+        }
+        else if (typeof a == 'object' && '__sub__' in a) {
+            return a = a.__sub__ (b);
+        }
+        else if (typeof b == 'object' && '__rsub__' in b) {
+            return a = b.__rsub__ (a);
+        }
+        else {
+            return a -= b;
+        }
+    };
+    __all__.__isub__ = __isub__;
+
+    // Overloaded augmented bitwise
+    
+    var __ilshift__ = function (a, b) {
+        if (typeof a == 'object' && '__ilshift__' in a) {
+            return a.__ilshift__ (b);
+        }
+        else if (typeof a == 'object' && '__lshift__' in a) {
+            return a = a.__lshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rlshift__' in b) {
+            return a = b.__rlshift__ (a);
+        }
+        else {
+            return a <<= b;
+        }
+    };
+    __all__.__ilshift__ = __ilshift__;
+
+    var __irshift__ = function (a, b) {
+        if (typeof a == 'object' && '__irshift__' in a) {
+            return a.__irshift__ (b);
+        }
+        else if (typeof a == 'object' && '__rshift__' in a) {
+            return a = a.__rshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rrshift__' in b) {
+            return a = b.__rrshift__ (a);
+        }
+        else {
+            return a >>= b;
+        }
+    };
+    __all__.__irshift__ = __irshift__;
+
+    var __ior__ = function (a, b) {
+        if (typeof a == 'object' && '__ior__' in a) {
+            return a.__ior__ (b);
+        }
+        else if (typeof a == 'object' && '__or__' in a) {
+            return a = a.__or__ (b);
+        }
+        else if (typeof b == 'object' && '__ror__' in b) {
+            return a = b.__ror__ (a);
+        }
+        else {
+            return a |= b;
+        }
+    };
+    __all__.__ior__ = __ior__;
+
+    var __ixor__ = function (a, b) {
+        if (typeof a == 'object' && '__ixor__' in a) {
+            return a.__ixor__ (b);
+        }
+        else if (typeof a == 'object' && '__xor__' in a) {
+            return a = a.__xor__ (b);
+        }
+        else if (typeof b == 'object' && '__rxor__' in b) {
+            return a = b.__rxor__ (a);
+        }
+        else {
+            return a ^= b;
+        }
+    };
+    __all__.__ixor__ = __ixor__;
+
+    var __iand__ = function (a, b) {
+        if (typeof a == 'object' && '__iand__' in a) {
+            return a.__iand__ (b);
+        }
+        else if (typeof a == 'object' && '__and__' in a) {
+            return a = a.__and__ (b);
+        }
+        else if (typeof b == 'object' && '__rand__' in b) {
+            return a = b.__rand__ (a);
+        }
+        else {
+            return a &= b;
+        }
+    };
+    __all__.__iand__ = __iand__;
+    
+    // Indices and slices
+
+    var __getitem__ = function (container, key) {                           // Slice c.q. index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__getitem__' in container) {
+            return container.__getitem__ (key);                             // Overloaded on container
+        }
+        else {
+            return container [key];                                         // Container must support bare JavaScript brackets
+        }
+    };
+    __all__.__getitem__ = __getitem__;
+
+    var __setitem__ = function (container, key, value) {                    // Slice c.q. index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__setitem__' in container) {
+            container.__setitem__ (key, value);                             // Overloaded on container
+        }
+        else {
+            container [key] = value;                                        // Container must support bare JavaScript brackets
+        }
+    };
+    __all__.__setitem__ = __setitem__;
+
+    var __getslice__ = function (container, lower, upper, step) {           // Slice only, no index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__getitem__' in container) {
+            return container.__getitem__ ([lower, upper, step]);            // Container supports overloaded slicing c.q. indexing
+        }
+        else {
+            return container.__getslice__ (lower, upper, step);             // Container only supports slicing injected natively in prototype
+        }
+    };
+    __all__.__getslice__ = __getslice__;
+
+    var __setslice__ = function (container, lower, upper, step, value) {    // Slice, no index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__setitem__' in container) {
+            container.__setitem__ ([lower, upper, step], value);            // Container supports overloaded slicing c.q. indexing
+        }
+        else {
+            container.__setslice__ (lower, upper, step, value);             // Container only supports slicing injected natively in prototype
+        }
+    };
+    __all__.__setslice__ = __setslice__;
+	__nest__ (
+		__all__,
+		'basics', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'basics';
+					if (__envir__.executor_name == __envir__.transpiler_name) {
+						var num =  __init__ (__world__.numscrypt);
+					}
+					var run = function (autoTester) {
+						var z = num.zeros (tuple ([4, 3]), 'int32');
+						autoTester.check ('Zeros', z.tolist (), '<br>');
+						var o = num.ones (tuple ([4, 5]));
+						autoTester.check ('Ones', o.astype ('int32').tolist ());
+						var i = num.identity (3, 'int32');
+						autoTester.check ('Identity', i.tolist (), '<br>');
+						var a = num.array (list ([list ([1, 1, 2, 3]), list ([4, 5, 6, 7]), list ([8, 9, 10, 12])]));
+						autoTester.check ('Matrix a', a.tolist (), '<br>');
+						autoTester.check ('Transpose of a', a.transpose ().tolist (), '<br>');
+						var b = num.array (list ([list ([2, 2, 4, 6]), list ([8, 10, 12, 14]), list ([16, 18, 20, 24])]));
+						var bp = b.transpose ();
+						autoTester.check ('Matrix b', b.tolist (), '<br>');
+						autoTester.check ('Permutation of b', bp.tolist (), '<br>');
+						var c = num.array (list ([list ([1, 2, 3, 4]), list ([5, 6, 7, 8]), list ([9, 10, 11, 12])]), 'int32');
+						autoTester.check ('Shape c', tuple (c.shape), '<br>');
+						autoTester.check ('Matrix c', c.tolist (), '<br>');
+						var ct = c.transpose ();
+						autoTester.check ('Shape ct', tuple (ct.shape), '<br>');
+						autoTester.check ('Transpose of c', ct.tolist (), '<br>');
+						var __left0__ = num.hsplit (c, 2);
+						var cs0 = __left0__ [0];
+						var cs1 = __left0__ [1];
+						autoTester.check ('Matrix cs0', cs0.tolist (), '<br>');
+						autoTester.check ('Matrix cs1', cs1.tolist (), '<br>');
+						var ci = num.hstack (tuple ([cs1, cs0]));
+						autoTester.check ('Matrix ci', ci.tolist (), '<br>');
+						var __left0__ = num.hsplit (ct, 3);
+						var cts0 = __left0__ [0];
+						var cts1 = __left0__ [1];
+						var cts2 = __left0__ [2];
+						autoTester.check ('Matrix cts0', cts0.tolist (), '<br>');
+						autoTester.check ('Matrix cts1', cts1.tolist (), '<br>');
+						autoTester.check ('Matrix cts2', cts2.tolist (), '<br>');
+						var cti = num.hstack (tuple ([cts2, cts1, cts0]));
+						autoTester.check ('Matrix ci', cti.tolist (), '<br>');
+						var d = num.array (list ([list ([13, 14]), list ([15, 16]), list ([17, 18]), list ([19, 20])]), 'int32');
+						autoTester.check ('Matrix d', d.tolist (), '<br>');
+						var dt = d.transpose ();
+						autoTester.check ('Permutation of d', dt.tolist (), '<br>');
+						var __left0__ = num.vsplit (d, 4);
+						var ds0 = __left0__ [0];
+						var ds1 = __left0__ [1];
+						var ds2 = __left0__ [2];
+						var ds3 = __left0__ [3];
+						autoTester.check ('Matrix ds0', ds0.tolist (), '<br>');
+						autoTester.check ('Matrix ds1', ds1.tolist (), '<br>');
+						autoTester.check ('Matrix ds2', ds2.tolist (), '<br>');
+						autoTester.check ('Matrix ds3', ds3.tolist (), '<br>');
+						var di = num.vstack (tuple ([ds3, ds2, ds1, ds0]));
+						autoTester.check ('Matrix di', di.tolist (), '<br>');
+						var __left0__ = num.vsplit (dt, 2);
+						var dts0 = __left0__ [0];
+						var dts1 = __left0__ [1];
+						autoTester.check ('Matrix dts0', dts0.tolist (), '<br>');
+						autoTester.check ('Matrix dts1', dts1.tolist (), '<br>');
+						var dti = num.vstack (tuple ([dts1, dts0]));
+						autoTester.check ('Matrix dti', dti.tolist (), '<br>');
+						var v0 = num.array (range (10));
+						var v1 = num.array (tuple ([1, 2, 3, 1, 2, 3, 1, 2, 3, 1]));
+						a.__setitem__ ([1, 0], 177);
+						var el = b.__getitem__ ([1, 2]);
+						var bsl0 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl1 = b.__getitem__ ([tuple ([1, 2, 1]), tuple ([1, 3, 1])]);
+						var bsl2 = b.__getitem__ ([tuple ([1, 2, 1]), 1]);
+						var bsl3 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl4 = b.__getitem__ ([tuple ([0, null, 1]), 1]);
+						var bsl5 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl6 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl7 = b.__getitem__ ([1, tuple ([2, 3, 1])]);
+						var bpsl0 = bp.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bpsl1 = bp.__getitem__ ([tuple ([1, 2, 1]), tuple ([1, 3, 1])]);
+						var bpsl2 = bp.__getitem__ ([1, tuple ([0, null, 1])]);
+						var bpsl3 = bp.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bpsl4 = bp.__getitem__ ([tuple ([0, null, 1]), 1]);
+						var bpsl5 = bp.__getitem__ ([3, tuple ([1, 3, 1])]);
+						var bpsl6 = bp.__getitem__ ([tuple ([2, 4, 1]), tuple ([1, 3, 1])]);
+						var bpsl7 = bp.__getitem__ ([tuple ([2, 4, 1]), tuple ([2, 3, 1])]);
+						var sum = __add__ (a, b);
+						var dif = __sub__ (a, b);
+						var prod = __mul__ (a, b);
+						var quot = __truediv__ (a, b);
+						var dot = __matmul__ (c, d);
+						var vsum = __add__ (v0, v1);
+						var vel = __getitem__ (vsum, 6);
+						__setitem__ (vsum, 6, 70);
+						var mul_a3 = __mul__ (a, 3);
+						var mul_3a = __mul__ (3, a);
+						var div_a3 = __truediv__ (a, 3.1234567);
+						var div_3a = __truediv__ (3.1234567, a);
+						var add_a3 = __add__ (a, 3);
+						var add_3a = __add__ (3, a);
+						var sub_a3 = __sub__ (a, 3);
+						var sub_3a = __sub__ (3, a);
+						var neg_a = __neg__ (a);
+						autoTester.check ('El a [1, 2, 3] alt', a.tolist (), '<br>');
+						autoTester.check ('El b [1, 2, 3]', el, '<br>');
+						autoTester.check ('Sl b0', bsl0.tolist (), '<br>');
+						autoTester.check ('Sl b1', bsl1.tolist (), '<br>');
+						autoTester.check ('Sl b2', bsl2.tolist (), '<br>');
+						autoTester.check ('Sl b3', bsl3.tolist (), '<br>');
+						autoTester.check ('Sl b4', bsl4.tolist (), '<br>');
+						autoTester.check ('Sl b5', bsl5.tolist (), '<br>');
+						autoTester.check ('Sl b6', bsl6.tolist (), '<br>');
+						autoTester.check ('Sl b7', bsl7.tolist (), '<br>');
+						autoTester.check ('Sl bp0', bpsl0.tolist (), '<br>');
+						autoTester.check ('Sl bp1', bpsl1.tolist (), '<br>');
+						autoTester.check ('Sl bp2', bpsl2.tolist (), '<br>');
+						autoTester.check ('Sl bp3', bpsl3.tolist (), '<br>');
+						autoTester.check ('Sl bp4', bpsl4.tolist (), '<br>');
+						autoTester.check ('Sl bp5', bpsl5.tolist (), '<br>');
+						autoTester.check ('Sl bp6', bpsl6.tolist (), '<br>');
+						autoTester.check ('Sl bp7', bpsl7.tolist (), '<br>');
+						autoTester.check ('Matrix sum', sum.tolist (), '<br>');
+						autoTester.check ('Matrix difference', dif.tolist (), '<br>');
+						autoTester.check ('Matrix product', prod.tolist (), '<br>');
+						autoTester.check ('Matrix quotient', quot.tolist (), '<br>');
+						autoTester.check ('Matrix dotproduct', dot.tolist (), '<br>');
+						autoTester.check ('Vector', v0.tolist (), '<br>');
+						autoTester.check ('Vector', v1.tolist (), '<br>');
+						autoTester.check ('El sum old', vel, '<br>');
+						autoTester.check ('Vector sum new', vsum.tolist (), '<br>');
+						autoTester.check ('mul_a3', mul_a3.tolist (), '<br>');
+						autoTester.check ('mul_3a', mul_3a.tolist (), '<br>');
+						autoTester.check ('div_a3', num.round (div_a3, 2).tolist (), '<br>');
+						autoTester.check ('div_3a', num.round (div_3a, 2).tolist (), '<br>');
+						autoTester.check ('add_a3', add_a3.tolist (), '<br>');
+						autoTester.check ('add_3a', add_3a.tolist (), '<br>');
+						autoTester.check ('sub_a3', sub_a3.tolist (), '<br>');
+						autoTester.check ('sub_3a', sub_3a.tolist (), '<br>');
+						autoTester.check ('neg_a', neg_a.tolist (), '<br>');
+						var comp_a = __call__ (num.array, num, list ([list ([__add__ (1, complex (0, 2.0)), __sub__ (2, complex (0, 1.0)), 3]), list ([4, __add__ (5, complex (0, 3.0)), 7])]), 'complex128');
+						var comp_b = __call__ (num.array, num, list ([list ([6, __sub__ (8, complex (0, 1.0))]), list ([__add__ (9, complex (0, 3.0)), 10]), list ([11, __sub__ (12, complex (0, 6.0))])]), 'complex128');
+						var comp_c = __matmul__ (comp_a, comp_b);
+						autoTester.check ('comp_a', comp_a.tolist (), '<br>');
+						autoTester.check ('comp_b', comp_b.tolist (), '<br>');
+						autoTester.check ('comp_c', comp_c.tolist (), '<br>');
+						var comp_a_square = comp_a.__getitem__ ([tuple ([0, null, 1]), tuple ([0, 2, 1])]);
+						var comp_b_square = comp_b.__getitem__ ([tuple ([1, null, 1]), tuple ([0, null, 1])]);
+						var comp_c_square = __mul__ (comp_a_square, comp_b_square);
+						var comp_d_square = __truediv__ (comp_a_square, comp_b_square);
+						var comp_e_square = __add__ (comp_a_square, comp_b_square);
+						var comp_f_square = __sub__ (comp_a_square, comp_b_square);
+						autoTester.check ('comp_a_square', comp_a_square.tolist (), '<br>');
+						autoTester.check ('comp_b_square', comp_b_square.tolist (), '<br>');
+						autoTester.check ('comp_c_square', comp_c_square.tolist (), '<br>');
+						autoTester.check ('comp_d_square', num.round (comp_d_square, 2).tolist (), '<br>');
+						autoTester.check ('comp_e_square', comp_e_square.tolist (), '<br>');
+						autoTester.check ('comp_f_square', comp_f_square.tolist (), '<br>');
+						var sliceable_a = __call__ (num.array, num, list ([list ([1, 2, 3, 4]), list ([5, 6, 7, 8]), list ([9, 10, 11, 12]), list ([13, 14, 15, 16])]));
+						__call__ (autoTester.check, autoTester, 'sliceable_a', __call__ (sliceable_a.tolist, sliceable_a));
+						var slice_a = sliceable_a.__getitem__ ([tuple ([1, null, 1]), tuple ([1, null, 1])]);
+						__call__ (autoTester.check, autoTester, 'slice_a');
+						var sliceable_at = __call__ (sliceable_a.transpose, sliceable_a);
+						var slice_at = __getslice__ (sliceable_at, 1, null, 1);
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.run = run;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+    __nest__ (
+        __all__,
+        'itertools', {
+            __all__: {
+                __inited__: false,
+                __init__: function (__all__) {
+                    var count = function* (start, step) {
+                        if (start == undefined) {
+                            start = 0;
+                        }
+                        if (step == undefined) {
+                            step = 1;
+                        }
+                        while (true) {
+                            yield start;
+                            start += step;
+                        }
+                    }
+                    var cycle = function* (iterable) {                      
+                        let buffer = Array.from (iterable); // Can't reset, Chrome can't obtain iter from gener
+                        while (true) {
+                            for (let item of buffer) {
+                                yield item;
+                            }
+                        }
+                    }
+                    var repeat = function* (item, n) {
+                        if (typeof n == 'undefined') {
+                            while (true) {
+                                yield item;
+                            }
+                        }
+                        else {
+                            for (let index = 0; index < n; index++) {
+                                yield item;
+                            }
+                        }
+                    }
+                    var accumulate = function* (iterable, func) {
+                        let sum;
+                        let first = true;
+                        if (func) {
+                            for (let item of iterable) {
+                                if (first) {
+                                    sum = item;
+                                    first = false;
+                                }
+                                else {
+                                    sum = func (sum, item);
+                                }
+                                yield sum;
+                            }
+                        }
+                        else {
+                            for (let item of iterable) {
+                                if (first) {
+                                    sum = item;
+                                    first = false;
+                                }
+                                else {
+                                    sum = sum + item;
+                                }
+                                yield sum;
+                            }
+                        }
+                    }
+                    var chain = function* () {
+                        let args = [] .slice.apply (arguments);                         
+                        for (let arg of args) {
+                            for (let item of arg) {
+                                yield item;
+                            }
+                        }
+                    }
+                    chain.from_iterable = function* (iterable) {                        
+                        for (let item of iterable) {
+                            for (let subItem of item) {
+                                yield subItem;
+                            }
+                        }
+                    }
+                    var compress = function* (data, selectors) {
+                        let dataIterator = data [Symbol.iterator] .call (data);
+                        let selectorsIterator = selectors [Symbol.iterator] ();
+                        while (true) {
+                            let dataItem = dataIterator.next ();
+                            let selectorsItem = selectorsIterator.next ();
+                            if (dataItem.done || selectorsItem.done) {
+                                break;
+                            }
+                            else {
+                                if (selectorsItem.value) {
+                                    yield dataItem.value;
+                                }
+                            }
+                        }
+                    }
+                    var dropwhile = function* (pred, seq) {
+                        let started = false;
+                        for (let item of seq) {
+                            if (started) {
+                                yield item;
+                            }
+                            else if (!pred (item)) {
+                                started = true;
+                                yield item;
+                            }
+                        }
+                    }
+                    var filterfalse = function* (pred, seq) {
+                        for (let item of seq) {
+                            if (!pred (item)) {
+                                yield item;
+                            }
+                        }
+                    }
+                    var groupby = function* (iterable, keyfunc) {
+                        let anIterator = iterable [Symbol.iterator] ();
+                        let item = anIterator.next ();
+                        
+                        if (item.done) {
+                            return;
+                        }
+                        
+                        let groupKey = keyfunc (item.value);
+                        let more = true;
+                        
+                        function* group () {
+                            while (true) {
+                                yield (item.value);
+                                item = anIterator.next ();
+                                
+                                if (item.done) {
+                                    more = false;
+                                    return;
+                                }
+                                
+                                let key = keyfunc (item.value);
+                                
+                                if (key != groupKey) {
+                                    groupKey = key;
+                                    return;
+                                }
+                            }
+                        }
+                        
+                        while (more) {
+                            yield tuple ([groupKey, group ()]);
+                        }
+                    }
+                    
+                    var islice = function* () {
+                        let start;  // Have to be defined at function level, or Closure compiler will loose them after a yield 
+                        let stop;   //
+                        let step;   //
+                        
+                        let args = [] .slice.apply (arguments);
+                        let anIterator = args [0][Symbol.iterator] ();
+                        if (args.length == 2) {
+                            stop = args [1];
+                            start = 0;
+                            step = 1;
+                        }
+                        else {
+                            start = args [1];
+                            stop = args [2];
+                            if (args.length == 4) {
+                                step = args [3];
+                            }
+                            else {
+                                step = 1;
+                            }
+                        }
+                        for (let index = 0; index < start; index++) {
+                            if (anIterator.next (). done) {
+                                return;
+                            }
+                        }
+                        for (let index = 0; index < stop - start; index++) {
+                            let next = anIterator.next ();
+                            if (next.done) {
+                                return;
+                            }
+                            if (index % step == 0) {
+                                yield next.value;
+                            }
+                        }
+                    }
+                    var starmap = function* (func, seq) {
+                        let anIterator = seq [Symbol.iterator] ();
+                        while (true) {
+                            let next = anIterator.next ()
+                            if (next.done) {
+                                return;
+                            }
+                            else {
+                                yield func (...next.value); 
+                            }
+                        }
+                    }
+                    var takewhile = function* (pred, seq) {
+                        for (let item of seq) {
+                            if (pred (item)) {
+                                yield item;
+                            }
+                            else {
+                                return;
+                            }
+                        }
+                    }
+                    var tee = function (iterable, n) {
+                        if (n == undefined) {
+                            n = 2;
+                        }
+                        let all = [];                               // Don't return iterator since destructuring assignment cannot yet deal with that
+                        let one = list (iterable);
+                        for (let i = 0; i < n; i++) {
+                            all.append (one [Symbol.iterator] ());  // Iterator rather than list, exhaustable for semantic equivalence
+                        }
+                        return list (all);
+                    }
+                    
+                    var product = function () {
+                        let args = [] .slice.apply (arguments);
+                        if (args.length && args [args.length - 1] .hasOwnProperty ('__kwargtrans__')) {
+                            var repeat = args.pop () ['repeat']; 
+                        }
+                        else {
+                            var repeat = 1;
+                        }
+                        
+                        let oldMolecules = [tuple ([])];
+                        for (let i = 0; i < repeat; i++) {
+                            for (let arg of args) {
+                                let newMolecules = [];
+                                for (let oldMolecule of oldMolecules) {
+                                    for (let atom of arg) {
+                                        newMolecules.append (tuple (oldMolecule.concat (atom)));
+                                    }
+                                }
+                                oldMolecules = newMolecules;
+                            }
+                        }
+                        return list (oldMolecules); // Also works if args is emptpy
+                    }
+                    var permutations = function (iterable, r) {
+                        if (r == undefined) {
+                            try {
+                                r = len (iterable);
+                            }
+                            catch (exception) {
+                                r = len (list (iterable));
+                            }
+                        }
+                        let aProduct = product (iterable, __kwargtrans__ ({repeat: r}));
+                        let result = [];
+                        for (let molecule of aProduct) {
+                            if (len (set (molecule)) == r) {    // Weed out doubles
+                                result.append (molecule);
+                            }
+                        }
+                        return list (result);
+                    }
+                    var combinations = function (iterable, r) {
+                        let tail = list (iterable);
+                        function recurse (tail, molecule, rNext) {
+                            for (let index = 0; index < len (tail) - rNext; index++) {
+                                let newMolecule = molecule.concat (tail.slice (index, index + 1));
+
+                                if (rNext) {
+                                    recurse (tail.slice (index + 1), newMolecule, rNext - 1);
+                                }
+                                else {
+                                    result.append (tuple (newMolecule));
+                                }
+                            }
+                        }
+                        let result = [];
+                        recurse (tail, tail.slice (0, 0), r - 1);
+                        return list (result);
+                    }
+                    var combinations_with_replacement = function (iterable, r) {
+                        let tail = list (iterable);
+                        function recurse (tail, molecule, rNext) {
+                            for (let index = 0; index < len (tail); index++) {
+                                let newMolecule = molecule.concat (tail.slice (index, index + 1));
+
+                                if (rNext) {
+                                    recurse (tail.slice (index), newMolecule, rNext - 1);
+                                }
+                                else {
+                                    result.append (tuple (newMolecule));
+                                }
+                            }
+                        }
+                        let result = [];
+                        recurse (tail, tail.slice (0, 0), r - 1);
+                        return list (result);
+                    }
+                    //<all>
+                    __all__.count = count;
+                    __all__.cycle = cycle;
+                    __all__.repeat = repeat;
+                    __all__.accumulate = accumulate;
+                    __all__.chain = chain;
+                    __all__.compress = compress;
+                    __all__.dropwhile = dropwhile;
+                    __all__.filterfalse = filterfalse;
+                    __all__.groupby = groupby;
+                    __all__.islice = islice;
+                    __all__.starmap = starmap;
+                    __all__.takewhile = takewhile;
+                    __all__.tee = tee;
+                    __all__.product = product;
+                    __all__.permutations = permutations;
+                    __all__.combinations = combinations;
+                    __all__.combinations_with_replacement = combinations_with_replacement;
+                    //</all>
+                }
+            }
+        }
+    );
+	__nest__ (
+		__all__,
+		'math', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'math';
+					var pi = Math.PI;
+					var e = Math.E;
+					var exp = Math.exp;
+					var expm1 = function (x) {
+						return Math.exp (x) - 1;
+					};
+					var log = function (x, base) {
+						return (base === undefined ? Math.log (x) : Math.log (x) / Math.log (base));
+					};
+					var log1p = function (x) {
+						return Math.log (x + 1);
+					};
+					var log2 = function (x) {
+						return Math.log (x) / Math.LN2;
+					};
+					var log10 = function (x) {
+						return Math.log (x) / Math.LN10;
+					};
+					var pow = Math.pow;
+					var sqrt = Math.sqrt;
+					var sin = Math.sin;
+					var cos = Math.cos;
+					var tan = Math.tan;
+					var asin = Math.asin;
+					var acos = Math.acos;
+					var atan = Math.atan;
+					var atan2 = Math.atan2;
+					var hypot = Math.hypot;
+					var degrees = function (x) {
+						return (x * 180) / Math.PI;
+					};
+					var radians = function (x) {
+						return (x * Math.PI) / 180;
+					};
+					var sinh = Math.sinh;
+					var cosh = Math.cosh;
+					var tanh = Math.tanh;
+					var asinh = Math.asinh;
+					var acosh = Math.acosh;
+					var atanh = Math.atanh;
+					var floor = Math.floor;
+					var ceil = Math.ceil;
+					var trunc = Math.trunc;
+					var isnan = isNaN;
+					var inf = Infinity;
+					var nan = NaN;
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.acos = acos;
+						__all__.acosh = acosh;
+						__all__.asin = asin;
+						__all__.asinh = asinh;
+						__all__.atan = atan;
+						__all__.atan2 = atan2;
+						__all__.atanh = atanh;
+						__all__.ceil = ceil;
+						__all__.cos = cos;
+						__all__.cosh = cosh;
+						__all__.degrees = degrees;
+						__all__.e = e;
+						__all__.exp = exp;
+						__all__.expm1 = expm1;
+						__all__.floor = floor;
+						__all__.hypot = hypot;
+						__all__.inf = inf;
+						__all__.isnan = isnan;
+						__all__.log = log;
+						__all__.log10 = log10;
+						__all__.log1p = log1p;
+						__all__.log2 = log2;
+						__all__.nan = nan;
+						__all__.pi = pi;
+						__all__.pow = pow;
+						__all__.radians = radians;
+						__all__.sin = sin;
+						__all__.sinh = sinh;
+						__all__.sqrt = sqrt;
+						__all__.tan = tan;
+						__all__.tanh = tanh;
+						__all__.trunc = trunc;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'module_fft', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'module_fft';
+					var sin = __init__ (__world__.math).sin;
+					var cos = __init__ (__world__.math).cos;
+					var pi = __init__ (__world__.math).pi;
+					var transpiled = __envir__.executor_name == __envir__.transpiler_name;
+					if (__envir__.executor_name == __envir__.transpiler_name) {
+						var num =  __init__ (__world__.numscrypt);
+						var fft =  __init__ (__world__.numscrypt.fft);
+					}
+					var fSample = 4096;
+					var tTotal = 2;
+					var fSin = 30;
+					var fCos = 50;
+					var getNow = function () {
+						return new Date ();
+					};
+					var tCurrent = function (iCurrent) {
+						return iCurrent / fSample;
+					};
+					var run = function (autoTester) {
+						var delta = __add__ (0.001, complex (0, 0.001));
+						autoTester.check ('<br>------ 1D ------<br>');
+						var cut = 102;
+						autoTester.check ('Samples computed: {}<br>'.format (tTotal * fSample));
+						autoTester.check ('Samples shown: {}<br>'.format (cut));
+						var orig = num.array ((function () {
+							var __accu0__ = [];
+							for (var t of (function () {
+								var __accu1__ = [];
+								for (var iSample = 0; iSample < tTotal * fSample; iSample++) {
+									__accu1__.append (iSample / fSample);
+								}
+								return __accu1__;
+							}) ()) {
+								__accu0__.append (complex ((0.3 + sin (((2 * pi) * fSin) * t)) + 0.5 * cos (((2 * pi) * fCos) * t), 0));
+							}
+							return __accu0__;
+						}) (), 'complex128');
+						__call__ (autoTester.check, autoTester, 'Original samples', __getslice__ (__call__ (__call__ (num.round, num, __add__ (orig, delta), 3).tolist, __call__ (num.round, num, __add__ (orig, delta), 3)), 0, cut, 1), '<br>');
+						if (transpiled) {
+							var timeStartFft = __call__ (getNow, null);
+						}
+						var freqs = __call__ (fft.fft, fft, orig);
+						if (transpiled) {
+							var timeStopFft = __call__ (getNow, null);
+						}
+						__call__ (autoTester.check, autoTester, 'Frequencies', __getslice__ (__call__ (__call__ (num.round, num, __add__ (freqs, delta), 3).tolist, __call__ (num.round, num, __add__ (freqs, delta), 3)), 0, cut, 1), '<br>');
+						if (transpiled) {
+							var timeStartIfft = __call__ (getNow, null);
+						}
+						var reconstr = __call__ (fft.ifft, fft, freqs);
+						if (transpiled) {
+							var timeStopIfft = __call__ (getNow, null);
+						}
+						__call__ (autoTester.check, autoTester, 'Reconstructed samples', __getslice__ (__call__ (__call__ (num.round, num, __add__ (reconstr, delta), 3).tolist, __call__ (num.round, num, __add__ (reconstr, delta), 3)), 0, cut, 1), '<br>');
+						if (transpiled) {
+							print ('FFT for {} samples took {} ms'.format (tTotal * fSample, timeStopFft - timeStartFft));
+							print ('IFFT for {} samples took {} ms'.format (tTotal * fSample, timeStopIfft - timeStartIfft));
+						}
+						autoTester.check ('<br>------ 2D ------<br>');
+						var orig2 = __call__ (num.zeros, num, tuple ([128, 128]), 'complex128');
+						orig2.__setitem__ ([tuple ([32, 96, 1]), tuple ([32, 96, 1])], __call__ (num.ones, num, tuple ([64, 64]), 'complex128'));
+						__call__ (autoTester.check, autoTester, 'Original samples', __call__ (__call__ (num.round, num, __add__ (orig2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])]).tolist, __call__ (num.round, num, __add__ (orig2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])])), '<br>');
+						if (transpiled) {
+							var timeStartFft = __call__ (getNow, null);
+						}
+						var freqs2 = __call__ (fft.fft2, fft, orig2);
+						if (transpiled) {
+							var timeStopFft = __call__ (getNow, null);
+						}
+						__call__ (autoTester.check, autoTester, 'Frequencies', __call__ (__call__ (num.round, num, __add__ (freqs2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])]).tolist, __call__ (num.round, num, __add__ (freqs2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])])), '<br>');
+						if (transpiled) {
+							var timeStartIfft = __call__ (getNow, null);
+						}
+						var reconstr2 = __call__ (fft.ifft2, fft, freqs2);
+						if (transpiled) {
+							var timeStopIfft = __call__ (getNow, null);
+						}
+						if (transpiled) {
+							__call__ (print, null, __call__ ('FFT2 for {} samples took {} ms'.format, 'FFT2 for {} samples took {} ms', orig2.size, __sub__ (timeStopFft, timeStartFft)));
+							__call__ (print, null, __call__ ('IFFT2 for {} samples took {} ms'.format, 'IFFT2 for {} samples took {} ms', orig2.size, __sub__ (timeStopIfft, timeStartIfft)));
+						}
+						__call__ (autoTester.check, autoTester, 'Reconstructed samples', __call__ (__call__ (num.round, num, __add__ (reconstr2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])]).tolist, __call__ (num.round, num, __add__ (reconstr2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])])), '<br>');
+					};
+					__pragma__ ('<use>' +
+						'math' +
+						'numscrypt' +
+						'numscrypt.fft' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.cos = cos;
+						__all__.fCos = fCos;
+						__all__.fSample = fSample;
+						__all__.fSin = fSin;
+						__all__.getNow = getNow;
+						__all__.pi = pi;
+						__all__.run = run;
+						__all__.sin = sin;
+						__all__.tCurrent = tCurrent;
+						__all__.tTotal = tTotal;
+						__all__.transpiled = transpiled;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'module_linalg', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'module_linalg';
+					if (__envir__.executor_name == __envir__.transpiler_name) {
+						var num =  __init__ (__world__.numscrypt);
+						var linalg =  __init__ (__world__.numscrypt.linalg);
+					}
+					var run = function (autoTester) {
+						var r = num.array (list ([list ([2.12, -(2.11), -(1.23)]), list ([2.31, 1.14, 3.15]), list ([1.13, 1.98, 2.81])]));
+						autoTester.check ('Matrix r', num.round (r, 2).tolist (), '<br>');
+						var ri = linalg.inv (r);
+						autoTester.check ('Matrix ri', num.round (ri, 2).tolist (), '<br>');
+						var rid = __matmul__ (r, ri);
+						autoTester.check ('r @ ri', (function () {
+							var __accu0__ = [];
+							for (var row of rid.tolist ()) {
+								__accu0__.append ((function () {
+									var __accu1__ = [];
+									for (var elem of row) {
+										__accu1__.append (int (round (elem)));
+									}
+									return __accu1__;
+								}) ());
+							}
+							return __accu0__;
+						}) (), '<br>');
+						var delta = 0.001;
+						__call__ (autoTester.check, autoTester, 'r * r', __call__ (__call__ (num.round, num, __add__ (__mul__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__mul__ (r, r), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'r / r', __call__ (__call__ (num.round, num, __add__ (__truediv__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__truediv__ (r, r), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'r + r', __call__ (__call__ (num.round, num, __add__ (__add__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__add__ (r, r), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'r - r', __call__ (__call__ (num.round, num, __add__ (__sub__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__sub__ (r, r), delta), 3)), '<br>');
+						var c = __call__ (num.array, num, list ([list ([__sub__ (2.12, complex (0, 3.15)), __neg__ (2.11), __neg__ (1.23)]), list ([2.31, 1.14, __add__ (3.15, complex (0, 2.75))]), list ([1.13, __sub__ (1.98, complex (0, 4.33)), 2.81])]), 'complex128');
+						autoTester.check ('Matrix c', num.round (c, 2).tolist (), '<br>');
+						var ci = linalg.inv (c);
+						autoTester.check ('Matrix ci', num.round (ci, 2).tolist (), '<br>');
+						var cid = __matmul__ (c, ci);
+						var delta = __add__ (0.001, complex (0, 0.001));
+						__call__ (autoTester.check, autoTester, 'c * c', __call__ (__call__ (num.round, num, __add__ (__mul__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__mul__ (c, c), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'c / c', __call__ (__call__ (num.round, num, __add__ (__truediv__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__truediv__ (c, c), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'c + c', __call__ (__call__ (num.round, num, __add__ (__add__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__add__ (c, c), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'c - c', __call__ (__call__ (num.round, num, __add__ (__sub__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__sub__ (c, c), delta), 3)), '<br>');
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+						'numscrypt.linalg' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.run = run;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'numscrypt', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var itertools = {};
+					var __name__ = 'numscrypt';
+					__nest__ (itertools, '', __init__ (__world__.itertools));
+					var ns_ctors = dict ({'int32': Int32Array, 'float32': Float32Array, 'float64': Float64Array});
+					var ns_complex = function (dtype) {
+						return __in__ (dtype, tuple (['complex64', 'complex128']));
+					};
+					var ns_buffertype = function (dtype) {
+						return (dtype == 'complex64' ? 'float32' : (dtype == 'complex128' ? 'float64' : dtype));
+					};
+					var ns_complextype = function (dtype) {
+						return (dtype == 'float32' ? 'complex64' : (dtype == 'float64' ? 'complex128' : null));
+					};
+					var ns_createbuf = function (imag, dtype, size) {
+						return (!(imag) || ns_complex (dtype) ? new ns_ctors [ns_buffertype (dtype)] (size) : null);
+					};
+					var ndarray = __class__ ('ndarray', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, shape, dtype, realbuf, imagbuf) {
+							if (typeof realbuf == 'undefined' || (realbuf != null && realbuf .hasOwnProperty ("__kwargtrans__"))) {;
+								var realbuf = null;
+							};
+							if (typeof imagbuf == 'undefined' || (imagbuf != null && imagbuf .hasOwnProperty ("__kwargtrans__"))) {;
+								var imagbuf = null;
+							};
+							self.dtype = dtype;
+							self.ns_complex = ns_complex (dtype);
+							self.realbuf = realbuf;
+							if (self.ns_complex) {
+								self.imagbuf = imagbuf;
+							}
+							self.setshape (shape);
+						}, '__init__');},
+						get setshape () {return __get__ (this, function (self, shape) {
+							self.shape = shape;
+							self.ndim = shape.length;
+							self.ns_nrows = shape [0];
+							if (self.ndim == 1) {
+								self.size = self.ns_nrows;
+							}
+							else {
+								self.ns_ncols = shape [1];
+								self.size = self.ns_nrows * self.ns_ncols;
+							}
+						}, 'setshape');},
+						get astype () {return __get__ (this, function (self, dtype) {
+							var result = empty (self.shape, dtype);
+							result.realbuf.set (self.realbuf);
+							if (self.ns_complex) {
+								result.imagbuf.set (self.imagbuf);
+							}
+							return result;
+						}, 'astype');},
+						get tolist () {return __get__ (this, function (self) {
+							if (self.ns_complex) {
+								var flat = (function () {
+									var __accu0__ = [];
+									for (var [real, imag] of zip (list (self.realbuf), list (self.imagbuf))) {
+										__accu0__.append (complex (real, imag));
+									}
+									return __accu0__;
+								}) ();
+							}
+							else {
+								var flat = self.realbuf;
+							}
+							if (self.ndim == 1) {
+								return list (flat);
+							}
+							else {
+								return (function () {
+									var __accu0__ = [];
+									for (var irow = 0; irow < self.ns_nrows; irow++) {
+										__accu0__.append ((function () {
+											var __accu1__ = [];
+											for (var icol = 0; icol < self.ns_ncols; icol++) {
+												__accu1__.append (flat [self.ns_ncols * irow + icol]);
+											}
+											return __accu1__;
+										}) ());
+									}
+									return __accu0__;
+								}) ();
+							}
+						}, 'tolist');},
+						get __repr__ () {return __get__ (this, function (self) {
+							return 'array({})'.format (repr (self.tolist ()));
+						}, '__repr__');},
+						get __str__ () {return __get__ (this, function (self) {
+							if (self.ndim == 1) {
+								return str (self.tolist ());
+							}
+							else {
+								return '[\n\t{}\n]\n'.format ('\n\t'.join ((function () {
+									var __accu0__ = [];
+									for (var row of self.tolist ()) {
+										__accu0__.append (str (row));
+									}
+									return __accu0__;
+								}) ()));
+							}
+						}, '__str__');},
+						get reshape () {return __get__ (this, function (self, shape) {
+							if (self.ndim == 1) {
+								return tuple ([array (self, self.dtype)]);
+							}
+							else {
+								var result = array (self, self.dtype);
+								result.setshape (self.ns_ncols, self.ns_nrows);
+								return result;
+							}
+						}, 'reshape');},
+						get transpose () {return __get__ (this, function (self) {
+							if (self.ndim == 1) {
+								var result = array (self, dtype);
+							}
+							else {
+								var result = empty (tuple ([self.ns_ncols, self.ns_nrows]), self.dtype);
+								var itarget = 0;
+								if (self.ns_complex) {
+									for (var icol = 0; icol < self.ns_ncols; icol++) {
+										var isource = icol;
+										for (var irow = 0; irow < self.ns_nrows; irow++) {
+											var isource = self.ns_ncols * irow + icol;
+											result.imagbuf [itarget] = self.imagbuf [isource];
+											result.realbuf [itarget++] = self.realbuf [isource];
+											isource += self.ns_ncols;
+										}
+									}
+								}
+								else {
+									for (var icol = 0; icol < self.ns_ncols; icol++) {
+										var isource = icol;
+										for (var irow = 0; irow < self.ns_nrows; irow++) {
+											result.realbuf [itarget++] = self.realbuf [isource];
+											isource += self.ns_ncols;
+										}
+									}
+								}
+							}
+							return result;
+						}, 'transpose');},
+						get __getitem__ () {return __get__ (this, function (self, key) {
+							if (self.ndim == 1) {
+								if (py_typeof (key) == tuple) {
+									if (key [1] == null) {
+										key [1] = self.size;
+									}
+									else if (key [1] < 0) {
+										key [1] += self.size;
+									}
+									var result = empty (list ([(key [1] - key [0]) / key [2]]), self.dtype);
+									var itarget = 0;
+									if (self.ns_complex) {
+										for (var isource of range (...self.shape)) {
+											result.realbuf [itarget] = self.realbuf [isource];
+											result.imagbuf [itarget++] = self.imagbuf [isource];
+										}
+									}
+									else {
+										for (var isource of range (...self.shape)) {
+											result.realbuf [itarget++] = self.realbuf [isource];
+										}
+									}
+									return result;
+								}
+								else if (self.ns_complex) {
+									return complex (self.realbuf [key], self.imagbuf [key]);
+								}
+								else {
+									return self.realbuf [key];
+								}
+							}
+							else {
+								var rowkey = key [0];
+								var colkey = key [1];
+								var rowistup = py_typeof (rowkey) == tuple;
+								var colistup = py_typeof (colkey) == tuple;
+								if (rowistup) {
+									if (rowkey [1] == null) {
+										rowkey [1] = self.ns_nrows;
+									}
+									else if (rowkey [1] < 0) {
+										rowkey [1] += self.ns_nrows;
+									}
+								}
+								if (colistup) {
+									if (colkey [1] == null) {
+										colkey [1] = self.ns_ncols;
+									}
+									else if (colkey [1] < 0) {
+										colkey [1] += self.ns_ncols;
+									}
+								}
+								if (rowistup || colistup) {
+									if (!(rowistup)) {
+										var result = empty (tuple ([(colkey [1] - colkey [0]) / colkey [2]]), self.dtype);
+										var itarget = 0;
+										if (self.ns_complex) {
+											for (var isourcecol of range (...colkey)) {
+												var isource = self.ns_ncols * rowkey + isourcecol;
+												result.realbuf [itarget] = self.realbuf [isource];
+												result.imagbuf [itarget++] = self.imagbuf [isource];
+											}
+										}
+										else {
+											for (var isourcecol of range (...colkey)) {
+												result.realbuf [itarget++] = self.realbuf [self.ns_ncols * rowkey + isourcecol];
+											}
+										}
+									}
+									else if (!(colistup)) {
+										var result = empty (tuple ([(rowkey [1] - rowkey [0]) / rowkey [2]]), self.dtype);
+										var itarget = 0;
+										if (self.ns_complex) {
+											for (var isourcerow of range (...rowkey)) {
+												var isource = self.ns_ncols * isourcerow + colkey;
+												result.realbuf [itarget] = self.realbuf [isource];
+												result.imagbuf [itarget++] = self.imagbuf [isource];
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												result.realbuf [itarget++] = self.realbuf [self.ns_ncols * isourcerow + colkey];
+											}
+										}
+									}
+									else {
+										var result = empty (tuple ([(key [0] [1] - key [0] [0]) / key [0] [2], (key [1] [1] - key [1] [0]) / key [1] [2]]), self.dtype);
+										var itarget = 0;
+										if (self.ns_complex) {
+											for (var isourcerow of range (...rowkey)) {
+												for (var isourcecol of range (...colkey)) {
+													var isource = self.ns_ncols * isourcerow + isourcecol;
+													result.realbuf [itarget] = self.realbuf [isource];
+													result.imagbuf [itarget++] = self.imagbuf [isource];
+												}
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												for (var isourcecol of range (...colkey)) {
+													result.realbuf [itarget++] = self.realbuf [self.ns_ncols * isourcerow + isourcecol];
+												}
+											}
+										}
+									}
+									return result;
+								}
+								else if (self.ns_complex) {
+									var isource = self.ns_ncols * key [0] + key [1];
+									return complex (self.realbuf [isource], self.imagbuf [isource]);
+								}
+								else {
+									return self.realbuf [self.ns_ncols * key [0] + key [1]];
+								}
+							}
+						}, '__getitem__');},
+						get __setitem__ () {return __get__ (this, function (self, key, value) {
+							if (self.ndim == 1) {
+								if (py_typeof (key) == tuple) {
+									if (key [1] == null) {
+										key [1] = self.size;
+									}
+									else if (key [1] < 0) {
+										key [1] += self.size;
+									}
+									var isource = 0;
+									if (self.ns_complex) {
+										for (var itarget of range (...self.shape)) {
+											self.realbuf [itarget] = value.realbuf [isource];
+											self.imagbuf [itarget] = value.imagbuf [isource++];
+										}
+									}
+									else {
+										for (var itarget of range (...self.shape)) {
+											self.realbuf [itarget] = value.realbuf [isource++];
+										}
+									}
+									return result;
+								}
+								else if (self.ns_complex) {
+									self.realbuf [key] = value.real;
+									self.imagbuf [key] = value.imag;
+								}
+								else {
+									self.realbuf [key] = value;
+								}
+							}
+							else {
+								var rowkey = key [0];
+								var colkey = key [1];
+								var rowistup = py_typeof (rowkey) == tuple;
+								var colistup = py_typeof (colkey) == tuple;
+								if (rowistup) {
+									if (rowkey [1] == null) {
+										rowkey [1] = self.ns_nrows;
+									}
+									else if (rowkey [1] < 0) {
+										rowkey [1] += self.ns_nrows;
+									}
+								}
+								if (colistup) {
+									if (colkey [1] == null) {
+										colkey [1] = self.ns_ncols;
+									}
+									else if (colkey [1] < 0) {
+										colkey [1] += self.ns_ncols;
+									}
+								}
+								if (rowistup || colistup) {
+									if (!(rowistup)) {
+										var isource = 0;
+										if (self.ns_complex) {
+											for (var itargetcol of range (...colkey)) {
+												var itarget = self.ns_ncols * rowkey + itargetcol;
+												self.realbuf [itarget] = value.realbuf [isource];
+												self.imagbuf [itarget] = value.imagbuf [isource++];
+											}
+										}
+										else {
+											for (var itargetcol of range (...colkey)) {
+												result.realbuf [self.ns_ncols * rowkey + itargetcol] = self.realbuf [isource++];
+											}
+										}
+									}
+									else if (!(colistup)) {
+										var isource = 0;
+										if (self.ns_complex) {
+											for (var itargetrow of range (...rowkey)) {
+												var itarget = self.ns_ncols * itargetrow + colkey;
+												self.realbuf [itarget] = value.realbuf [isource];
+												self.imagbuf [itarget] = value.imagbuf [isource++];
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												self.realbuf [self.ns_ncols * isourcerow + colkey] = value [isource++];
+											}
+										}
+									}
+									else {
+										var isource = 0;
+										if (self.ns_complex) {
+											for (var itargetrow of range (...rowkey)) {
+												for (var itargetcol of range (...colkey)) {
+													var itarget = self.ns_ncols * itargetrow + itargetcol;
+													self.realbuf [itarget] = value.realbuf [isource];
+													self.imagbuf [itarget] = value.imagbuf [isource++];
+												}
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												for (var isourcecol of range (...colkey)) {
+													self.realbuf [self.ns_ncols * itargetrow + itargetcol] = value.realbuf [isource++];
+												}
+											}
+										}
+									}
+								}
+								else if (self.ns_complex) {
+									var itarget = self.ns_ncols * key [0] + key [1];
+									self.realbuf [itarget] = value.real;
+									self.imagbuf [itarget] = value.imag;
+								}
+								else {
+									self.realbuf [self.ns_ncols * key [0] + key [1]] = value;
+								}
+							}
+						}, '__setitem__');},
+						get real () {return __get__ (this, function (self) {
+							return ndarray (self.shape, ns_buffertype (self.dtype), self.realbuf);
+						}, 'real');},
+						get imag () {return __get__ (this, function (self) {
+							return ndarray (self.shape, ns_buffertype (self.dtype), self.imagbuf);
+						}, 'imag');},
+						get __neg__ () {return __get__ (this, function (self) {
+							var result = empty (self.shape, self.dtype);
+							if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = -(self.realbuf [i]);
+									result.imagbuf [i] = -(self.imagbuf [i]);
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = -(self.realbuf [i]);
+								}
+							}
+							return result;
+						}, '__neg__');},
+						get __ns_inv__ () {return __get__ (this, function (self) {
+							var result = empty (self.shape, self.dtype);
+							if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									var real = self.realbuf [i];
+									var imag = self.imagbuf [i];
+									var denom = real * real + imag * imag;
+									result.realbuf [i] = real / denom;
+									result.imagbuf [i] = -(imag) / denom;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = 1 / self.realbuf [i];
+								}
+							}
+							return result;
+						}, '__ns_inv__');},
+						get __add__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] + other.realbuf [i];
+										result.imagbuf [i] = self.imagbuf [i] + other.imagbuf [i];
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] + other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] + other.real;
+									result.imagbuf [i] = self.imagbuf [i] + other.imag;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] + other;
+								}
+							}
+							return result;
+						}, '__add__');},
+						get __radd__ () {return __get__ (this, function (self, scalar) {
+							return self.__add__ (scalar);
+						}, '__radd__');},
+						get __sub__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] - other.realbuf [i];
+										result.imagbuf [i] = self.imagbuf [i] - other.imagbuf [i];
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] - other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] - other.real;
+									result.imagbuf [i] = self.imagbuf [i] - other.imag;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] - other;
+								}
+							}
+							return result;
+						}, '__sub__');},
+						get __rsub__ () {return __get__ (this, function (self, scalar) {
+							return self.__neg__ ().__add__ (scalar);
+						}, '__rsub__');},
+						get __mul__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] * other.realbuf [i] - self.imagbuf [i] * other.imagbuf [i];
+										result.imagbuf [i] = self.realbuf [i] * other.imagbuf [i] + self.imagbuf [i] * other.realbuf [i];
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] * other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] * other.real - self.imagbuf [i] * other.imag;
+									result.imagbuf [i] = self.realbuf [i] * other.imag + self.imagbuf [i] * other.real;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] * other;
+								}
+							}
+							return result;
+						}, '__mul__');},
+						get __rmul__ () {return __get__ (this, function (self, scalar) {
+							return self.__mul__ (scalar);
+						}, '__rmul__');},
+						get __div__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										var real = other.realbuf [i];
+										var imag = other.imagbuf [i];
+										var denom = real * real + imag * imag;
+										result.realbuf [i] = (self.realbuf [i] * real + self.imagbuf [i] * imag) / denom;
+										result.imagbuf [i] = (self.imagbuf [i] * real - self.realbuf [i] * imag) / denom;
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] / other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								var real = other.real;
+								var imag = other.imag;
+								var denom = real * real + imag * imag;
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = (self.realbuf [i] * real + self.imagbuf [i] * imag) / denom;
+									result.imagbuf [i] = (self.imagbuf [i] * real - self.realbuf [i] * imag) / denom;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] / other;
+								}
+							}
+							return result;
+						}, '__div__');},
+						get __rdiv__ () {return __get__ (this, function (self, scalar) {
+							return self.__ns_inv__ ().__mul__ (scalar);
+						}, '__rdiv__');},
+						get __matmul__ () {return __get__ (this, function (self, other) {
+							var result = empty (tuple ([self.ns_nrows, other.ns_ncols]), self.dtype);
+							if (self.ns_complex) {
+								var iresult = 0;
+								for (var irow = 0; irow < self.ns_nrows; irow++) {
+									for (var icol = 0; icol < other.ns_ncols; icol++) {
+										result.realbuf [iresult] = 0;
+										result.imagbuf [iresult] = 0;
+										var iself = self.ns_ncols * irow;
+										var iother = icol;
+										for (var iterm = 0; iterm < self.ns_ncols; iterm++) {
+											result.realbuf [iresult] += self.realbuf [iself] * other.realbuf [iother] - self.imagbuf [iself] * other.imagbuf [iother];
+											result.imagbuf [iresult] += self.realbuf [iself] * other.imagbuf [iother] + self.imagbuf [iself++] * other.realbuf [iother];
+											iother += other.ns_ncols;
+										}
+										iresult++;
+									}
+								}
+							}
+							else {
+								var iresult = 0;
+								for (var irow = 0; irow < self.ns_nrows; irow++) {
+									for (var icol = 0; icol < other.ns_ncols; icol++) {
+										result.realbuf [iresult] = 0;
+										var iself = self.ns_ncols * irow;
+										var iother = icol;
+										for (var iterm = 0; iterm < self.ns_ncols; iterm++) {
+											result.realbuf [iresult] += self.realbuf [iself++] * other.realbuf [iother];
+											iother += other.ns_ncols;
+										}
+										iresult++;
+									}
+								}
+							}
+							return result;
+						}, '__matmul__');}
+					});
+					var empty = function (shape, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = ndarray (shape, dtype);
+						result.realbuf = ns_createbuf (false, dtype, result.size);
+						result.imagbuf = ns_createbuf (true, dtype, result.size);
+						return result;
+					};
+					var array = function (obj, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						if (Array.isArray (obj)) {
+							if (len (obj)) {
+								if (Array.isArray (obj [0])) {
+									var result = empty (tuple ([obj.length, obj [0].length]), dtype);
+									var iresult = 0;
+									if (result.ns_complex) {
+										for (var irow = 0; irow < result.ns_nrows; irow++) {
+											for (var icol = 0; icol < result.ns_ncols; icol++) {
+												var element = complex (obj [irow] [icol]);
+												result.realbuf [iresult] = element.real;
+												result.imagbuf [iresult++] = element.imag;
+											}
+										}
+									}
+									else {
+										for (var irow = 0; irow < result.ns_nrows; irow++) {
+											for (var icol = 0; icol < result.ns_ncols; icol++) {
+												result.realbuf [iresult++] = obj [irow] [icol];
+											}
+										}
+									}
+								}
+								else {
+									var result = empty (tuple ([obj.length]), dtype);
+									if (result.ns_complex) {
+										for (var i = 0; i < result.size; i++) {
+											var element = complex (obj [i]);
+											result.realbuf [i] = element.real;
+											result.imagbuf [i] = element.imag;
+										}
+									}
+									else {
+										for (var i = 0; i < result.size; i++) {
+											result.realbuf [i] = obj [i];
+										}
+									}
+								}
+							}
+							else {
+								var result = empty (tuple ([0]), dtype);
+							}
+						}
+						else {
+							var result = empty (obj.shape, dtype);
+							result.realbuf.set (obj.realbuf);
+							if (obj.ns_complex) {
+								result.imagbuf.set (obj.imagbuf);
+							}
+						}
+						return result;
+					};
+					var copy = function (obj) {
+						return array (obj, obj.dtype);
+					};
+					var hsplit = function (ary, nparts) {
+						var result = (function () {
+							var __accu0__ = [];
+							for (var ipart = 0; ipart < nparts; ipart++) {
+								__accu0__.append (empty (tuple ([ary.ns_nrows, ary.ns_ncols / nparts]), ary.dtype));
+							}
+							return __accu0__;
+						}) ();
+						var isource = 0;
+						if (ary.ns_complex) {
+							for (var irow = 0; irow < ary.ns_nrows; irow++) {
+								for (var part of result) {
+									var itarget = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										part.realbuf [itarget] = ary.realbuf [isource];
+										part.imagbuf [itarget++] = ary.imagbuf [isource++];
+									}
+								}
+							}
+						}
+						else {
+							for (var irow = 0; irow < ary.ns_nrows; irow++) {
+								for (var part of result) {
+									var itarget = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										part.realbuf [itarget++] = ary.realbuf [isource++];
+									}
+								}
+							}
+						}
+						return result;
+					};
+					var vsplit = function (ary, nparts) {
+						var result = (function () {
+							var __accu0__ = [];
+							for (var ipart = 0; ipart < nparts; ipart++) {
+								__accu0__.append (empty (tuple ([ary.ns_nrows / nparts, ary.ns_ncols]), array.dtype));
+							}
+							return __accu0__;
+						}) ();
+						var isource = 0;
+						if (ary.ns_complex) {
+							for (var part of result) {
+								for (var itarget = 0; itarget < part.size; itarget++) {
+									part.realbuf [itarget] = ary.realbuf [isource];
+									part.imagbuf [itarget] = ary.imagbuf [isource++];
+								}
+							}
+						}
+						else {
+							for (var part of result) {
+								for (var itarget = 0; itarget < part.size; itarget++) {
+									part.realbuf [itarget] = ary.realbuf [isource++];
+								}
+							}
+						}
+						return result;
+					};
+					var hstack = function (tup) {
+						var ncols = 0;
+						for (var part of tup) {
+							ncols += part.ns_ncols;
+						}
+						var result = empty (tuple ([tup [0].ns_nrows, ncols]), tup [0].dtype);
+						var itarget = 0;
+						if (result.ns_complex) {
+							for (var irow = 0; irow < result.ns_nrows; irow++) {
+								for (var part of tup) {
+									var isource = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										result.realbuf [itarget] = part.realbuf [isource];
+										result.imagbuf [itarget++] = part.imagbuf [isource++];
+									}
+								}
+							}
+						}
+						else {
+							for (var irow = 0; irow < result.ns_nrows; irow++) {
+								for (var part of tup) {
+									var isource = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										result.realbuf [itarget++] = part.realbuf [isource++];
+									}
+								}
+							}
+						}
+						return result;
+					};
+					var vstack = function (tup) {
+						var nrows = 0;
+						for (var part of tup) {
+							nrows += part.ns_nrows;
+						}
+						var result = empty (tuple ([nrows, tup [0].ns_ncols]), tup [0].dtype);
+						var itarget = 0;
+						if (result.ns_complex) {
+							for (var part of tup) {
+								for (var isource = 0; isource < part.size; isource++) {
+									result.realbuf [itarget] = part.realbuf [isource];
+									result.imagbuf [itarget++] = part.imagbuf [isource];
+								}
+							}
+						}
+						else {
+							for (var part of tup) {
+								for (var isource = 0; isource < part.size; isource++) {
+									result.realbuf [itarget++] = part.realbuf [isource];
+								}
+							}
+						}
+						return result;
+					};
+					var round = function (a, decimals) {
+						if (typeof decimals == 'undefined' || (decimals != null && decimals .hasOwnProperty ("__kwargtrans__"))) {;
+							var decimals = 0;
+						};
+						var result = empty (a.shape, a.dtype);
+						if (a.ns_complex) {
+							for (var i = 0; i < a.size; i++) {
+								result.realbuf [i] = a.realbuf [i].toFixed (decimals);
+								result.imagbuf [i] = a.imagbuf [i].toFixed (decimals);
+							}
+						}
+						else {
+							for (var i = 0; i < a.size; i++) {
+								result.realbuf [i] = a.realbuf [i].toFixed (decimals);
+							}
+						}
+						return result;
+					};
+					var zeros = function (shape, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = empty (shape, dtype);
+						if (result.ns_complex) {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 0;
+								result.imagbuf [i] = 0;
+							}
+						}
+						else {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 0;
+							}
+						}
+						return result;
+					};
+					var ones = function (shape, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = empty (shape, dtype);
+						if (result.ns_complex) {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 1;
+								result.imagbuf [i] = 0;
+							}
+						}
+						else {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 1;
+							}
+						}
+						return result;
+					};
+					var identity = function (n, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = zeros (tuple ([n, n]), dtype);
+						var i = 0;
+						var shift = n + 1;
+						for (var j = 0; j < n; j++) {
+							result.realbuf [i] = 1;
+							i += shift;
+						}
+						return result;
+					};
+					__pragma__ ('<use>' +
+						'itertools' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.array = array;
+						__all__.copy = copy;
+						__all__.empty = empty;
+						__all__.hsplit = hsplit;
+						__all__.hstack = hstack;
+						__all__.identity = identity;
+						__all__.ndarray = ndarray;
+						__all__.ns_buffertype = ns_buffertype;
+						__all__.ns_complex = ns_complex;
+						__all__.ns_complextype = ns_complextype;
+						__all__.ns_createbuf = ns_createbuf;
+						__all__.ns_ctors = ns_ctors;
+						__all__.ones = ones;
+						__all__.round = round;
+						__all__.vsplit = vsplit;
+						__all__.vstack = vstack;
+						__all__.zeros = zeros;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'numscrypt.fft', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'numscrypt.fft';
+					var ns =  __init__ (__world__.numscrypt);
+					/* 
+					 * Free FFT and convolution (JavaScript)
+					 * 
+					 * Copyright (c) 2014 Project Nayuki
+					 * http://www.nayuki.io/page/free-small-fft-in-multiple-languages
+					 *
+					 * (MIT License)
+					 * Permission is hereby granted, free of charge, to any person obtaining a copy of
+					 * this software and associated documentation files (the "Software"), to deal in
+					 * the Software without restriction, including without limitation the rights to
+					 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+					 * the Software, and to permit persons to whom the Software is furnished to do so,
+					 * subject to the following conditions:
+					 * - The above copyright notice and this permission notice shall be included in
+					 *	 all copies or substantial portions of the Software.
+					 * - The Software is provided "as is", without warranty of any kind, express or
+					 *	 implied, including but not limited to the warranties of merchantability,
+					 *	 fitness for a particular purpose and noninfringement. In no event shall the
+					 *	 authors or copyright holders be liable for any claim, damages or other
+					 *	 liability, whether in an action of contract, tort or otherwise, arising from,
+					 *	 out of or in connection with the Software or the use or other dealings in the
+					 *	 Software.
+					 *
+					 * Slightly restructured by Chris Cannam, cannam@all-day-breakfast.com
+					 *
+					 * Fix added by Jacques de Hooge, jdeh@geatec.com: 'this' added to inverse, indentation repaired
+					 */
+					
+					
+					
+					/* 
+					 * Construct an object for calculating the discrete Fourier transform (DFT) of size n, where n is a power of 2.
+					 */
+					function FFTNayuki(n) {
+						
+						this.n = n;
+						this.levels = -1;
+						
+						for (var i = 0; i < 32; i++) {
+							if (1 << i == n) {
+								this.levels = i;  // Equal to log2(n)
+							}
+						}
+						if (this.levels == -1) {
+							throw "Length is not a power of 2";
+						}
+					
+						this.cosTable = new Array(n / 2);
+						this.sinTable = new Array(n / 2);
+						for (var i = 0; i < n / 2; i++) {
+							this.cosTable[i] = Math.cos(2 * Math.PI * i / n);
+							this.sinTable[i] = Math.sin(2 * Math.PI * i / n);
+						}
+					
+						/* 
+						 * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
+						 * The vector's length must be equal to the size n that was passed to the object constructor, and this must be a power of 2. Uses the Cooley-Tukey decimation-in-time radix-2 algorithm.
+						 */
+						this.forward = function(real, imag) {
+						
+							var n = this.n;
+							
+							// Bit-reversed addressing permutation
+							for (var i = 0; i < n; i++) {
+									var j = reverseBits(i, this.levels);
+									if (j > i) {
+								var temp = real[i];
+								real[i] = real[j];
+								real[j] = temp;
+								temp = imag[i];
+								imag[i] = imag[j];
+								imag[j] = temp;
+									}
+							}
+							
+							// Cooley-Tukey decimation-in-time radix-2 FFT
+							for (var size = 2; size <= n; size *= 2) {
+								var halfsize = size / 2;
+									var tablestep = n / size;
+									for (var i = 0; i < n; i += size) {
+										for (var j = i, k = 0; j < i + halfsize; j++, k += tablestep) {
+											var tpre =	real[j+halfsize] * this.cosTable[k] +
+											imag[j+halfsize] * this.sinTable[k];
+											var tpim = -real[j+halfsize] * this.sinTable[k] +
+											imag[j+halfsize] * this.cosTable[k];
+											real[j + halfsize] = real[j] - tpre;
+											imag[j + halfsize] = imag[j] - tpim;
+											real[j] += tpre;
+											imag[j] += tpim;
+								}
+									}
+							}
+							
+							// Returns the integer whose value is the reverse of the lowest 'bits' bits of the integer 'x'.
+							function reverseBits(x, bits) {
+								var y = 0;
+								for (var i = 0; i < bits; i++) {
+								   y = (y << 1) | (x & 1);
+								   x >>>= 1;
+								}
+								return y;
+							}
+						}
+					
+						/* 
+						 * Computes the inverse discrete Fourier transform (IDFT) of the given complex vector, storing the result back into the vector.
+						 * The vector's length must be equal to the size n that was passed to the object constructor, and this must be a power of 2. This is a wrapper function. This transform does not perform scaling, so the inverse is not a true inverse.
+						 */
+						this.inverse = function(real, imag) {
+							this.forward(imag, real);	// Fix by JdeH: 'this' added
+						}
+					}
+					
+					
+					var fft = function (a, ns_fftn) {
+						if (typeof ns_fftn == 'undefined' || (ns_fftn != null && ns_fftn .hasOwnProperty ("__kwargtrans__"))) {;
+							var ns_fftn = null;
+						};
+						var fftn = (ns_fftn ? ns_fftn : new FFTNayuki (a.size));
+						var result = ns.copy (a);
+						fftn.forward (result.real ().realbuf, result.imag ().realbuf);
+						return result;
+					};
+					var ifft = function (a, ns_fftn) {
+						if (typeof ns_fftn == 'undefined' || (ns_fftn != null && ns_fftn .hasOwnProperty ("__kwargtrans__"))) {;
+							var ns_fftn = null;
+						};
+						var fftn = (ns_fftn ? ns_fftn : new FFTNayuki (a.size));
+						var real = a.real ().__div__ (a.size);
+						var imag = a.imag ().__div__ (a.size);
+						fftn.inverse (real.realbuf, imag.realbuf);
+						return ns.ndarray (real.shape, a.dtype, real.realbuf, imag.realbuf);
+					};
+					var fft2 = function (a, ns_fftn) {
+						if (typeof ns_fftn == 'undefined' || (ns_fftn != null && ns_fftn .hasOwnProperty ("__kwargtrans__"))) {;
+							var ns_fftn = null;
+						};
+						if (a.ns_nrows != a.ns_ncols) {
+							var __except0__ = "Matrix isn't square";
+							__except0__.__cause__ = null;
+							throw __except0__;
+						}
+						var fftn = (ns_fftn ? ns_fftn : new FFTNayuki (a.ns_nrows));
+						var result = ns.empty (a.shape, a.dtype);
+						for (var irow = 0; irow < a.ns_nrows; irow++) {
+							result.__setitem__ ([irow, tuple ([0, null, 1])], __call__ (fft, null, a.__getitem__ ([irow, tuple ([0, null, 1])]), fftn));
+						}
+						for (var icol = 0; icol < a.ns_ncols; icol++) {
+							result.__setitem__ ([tuple ([0, null, 1]), icol], __call__ (fft, null, result.__getitem__ ([tuple ([0, null, 1]), icol]), fftn));
+						}
+						return result;
+					};
+					var ifft2 = function (a, ns_fftn) {
+						if (typeof ns_fftn == 'undefined' || (ns_fftn != null && ns_fftn .hasOwnProperty ("__kwargtrans__"))) {;
+							var ns_fftn = null;
+						};
+						if (a.ns_nrows != a.ns_ncols) {
+							var __except0__ = "Matrix isn't square";
+							__except0__.__cause__ = null;
+							throw __except0__;
+						}
+						var fftn = (ns_fftn ? ns_fftn : new FFTNayuki (a.ns_nrows));
+						var result = ns.empty (a.shape, a.dtype);
+						for (var irow = 0; irow < a.ns_nrows; irow++) {
+							result.__setitem__ ([irow, tuple ([0, null, 1])], __call__ (ifft, null, a.__getitem__ ([irow, tuple ([0, null, 1])]), fftn));
+						}
+						for (var icol = 0; icol < a.ns_ncols; icol++) {
+							result.__setitem__ ([tuple ([0, null, 1]), icol], __call__ (ifft, null, result.__getitem__ ([tuple ([0, null, 1]), icol]), fftn));
+						}
+						return result;
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.fft = fft;
+						__all__.fft2 = fft2;
+						__all__.ifft = ifft;
+						__all__.ifft2 = ifft2;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'numscrypt.linalg', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'numscrypt.linalg';
+					var ns =  __init__ (__world__.numscrypt);
+					var inv = function (a) {
+						if (a.ns_complex) {
+							return cinv (a);
+						}
+						else {
+							return rinv (a);
+						}
+					};
+					var rinv = function (a) {
+						var b = ns.hstack (tuple ([a, ns.identity (a.shape [0], a.dtype)]));
+						var real = b.realbuf;
+						var __left0__ = b.shape;
+						var nrows = __left0__ [0];
+						var ncols = __left0__ [1];
+						for (var ipiv = 0; ipiv < nrows; ipiv++) {
+							if (!(real [ipiv * ncols + ipiv])) {
+								for (var irow = ipiv + 1; irow < nrows; irow++) {
+									if (real [irow * ncols + ipiv]) {
+										for (var icol = 0; icol < ncols; icol++) {
+											var t = real [irow * ncols + icol];
+											real [irow * ncols + icol] = b [ipiv * ncols + icol];
+											real [ipiv * ncols + icol] = t;
+										}
+										break;
+									}
+								}
+							}
+							var piv = real [ipiv * ncols + ipiv];
+							for (var icol = ipiv; icol < ncols; icol++) {
+								real [ipiv * ncols + icol] /= piv;
+							}
+							for (var irow = 0; irow < nrows; irow++) {
+								if (irow != ipiv) {
+									var factor = real [irow * ncols + ipiv];
+									for (var icol = 0; icol < ncols; icol++) {
+										real [irow * ncols + icol] -= factor * real [ipiv * ncols + icol];
+									}
+								}
+							}
+						}
+						return ns.hsplit (b, 2) [1];
+					};
+					var cinv = function (a) {
+						var b = ns.hstack (tuple ([a, ns.identity (a.shape [0], a.dtype)]));
+						var real = b.realbuf;
+						var imag = b.imagbuf;
+						var __left0__ = b.shape;
+						var nrows = __left0__ [0];
+						var ncols = __left0__ [1];
+						for (var ipiv = 0; ipiv < nrows; ipiv++) {
+							var ipiv_flat = ipiv * ncols + ipiv;
+							if (!(real [ipiv_flat] || imag [ipiv_flat])) {
+								for (var irow = ipiv + 1; irow < nrows; irow++) {
+									var iswap = irow * ncols + ipiv;
+									if (real [iswap] || imag [iswap]) {
+										for (var icol = 0; icol < ncols; icol++) {
+											var isource = irow * ncols + icol;
+											var itarget = ipiv * ncols + icol;
+											var t = real [isource];
+											real [isource] = real [itarget];
+											real [itarget] = t;
+											var t = imag [isource_flat];
+											imag [isource] = imag [itarget];
+											imag [itarget] = t;
+										}
+										break;
+									}
+								}
+							}
+							var pivre = real [ipiv_flat];
+							var pivim = imag [ipiv_flat];
+							var denom = pivre * pivre + pivim * pivim;
+							for (var icol = ipiv; icol < ncols; icol++) {
+								var icur = ipiv * ncols + icol;
+								var oldre = real [icur];
+								var oldim = imag [icur];
+								real [icur] = (oldre * pivre + oldim * pivim) / denom;
+								imag [icur] = (oldim * pivre - oldre * pivim) / denom;
+							}
+							for (var irow = 0; irow < nrows; irow++) {
+								if (irow != ipiv) {
+									var ifac = irow * ncols + ipiv;
+									var facre = real [ifac];
+									var facim = imag [ifac];
+									for (var icol = 0; icol < ncols; icol++) {
+										var itarget = irow * ncols + icol;
+										var isource = ipiv * ncols + icol;
+										var oldre = real [isource];
+										var oldim = imag [isource];
+										real [itarget] -= facre * oldre - facim * oldim;
+										imag [itarget] -= facre * oldim + facim * oldre;
+									}
+								}
+							}
+						}
+						return ns.hsplit (b, 2) [1];
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.cinv = cinv;
+						__all__.inv = inv;
+						__all__.rinv = rinv;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'org.transcrypt.autotester', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var itertools = {};
+					var __name__ = 'org.transcrypt.autotester';
+					var HTMLGenerator = __init__ (__world__.org.transcrypt.autotester.html).HTMLGenerator;
+					var DataConverter = __init__ (__world__.org.transcrypt.autotester.html).DataConverter;
+					var JSTesterUI = __init__ (__world__.org.transcrypt.autotester.html).JSTesterUI;
+					__nest__ (itertools, '', __init__ (__world__.itertools));
+					var getFileLocation = function (ancestor) {
+						if (__envir__.executor_name == __envir__.transpiler_name) {
+							var s = null;
+							
+										var e = new Error();
+										if ( ! e.stack ) {
+										  console.log("MAJOR ISSUE: Browser Error lacks Stack");
+										} else {
+										  s = e.stack;
+										}
+										
+							var frames = null;
+							
+										var linereg = new RegExp("\n\r|\n", "g");
+										frames = s.toString().split(linereg);
+										
+							if (frames === null || len (frames) < 2) {
+								console.log("Failed to Split Stack");
+								return 'UNKNOWN:???';
+							}
+							var gpFrame = frames [ancestor * 2 + 1];
+							var frameReg = '([^(]*)\\(?([^:]*:)\\/{2,3}([^:/]*:?)([^:]*):(\\d+):(\\d+)';
+							var m = null;
+							
+										var r = new RegExp(frameReg);
+										m = r.exec(gpFrame);
+										
+							if (m) {
+								var filepath = m [4];
+								var pathParts = filepath.py_split ('/');
+								var filename = pathParts [len (pathParts) - 1];
+								var lineno = m [5];
+								return '{}:{}'.format (filename, lineno);
+							}
+							else {
+								console.log("Failed to Match Frame");
+								return 'UNKNOWN:???';
+							}
+						}
+					};
+					var AutoTester = __class__ ('AutoTester', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, symbols) {
+							if (typeof symbols == 'undefined' || (symbols != null && symbols .hasOwnProperty ("__kwargtrans__"))) {;
+								var symbols = list ([]);
+							};
+							self.symbols = symbols;
+							self._currTestlet = 'UNKNOWN';
+							self.testDict = dict ({});
+							self.refDict = dict ({});
+							if (__envir__.executor_name == __envir__.transpiler_name) {
+								self.ui = JSTesterUI ();
+							}
+							else {
+								self.ui = null;
+							}
+						}, '__init__');},
+						get sortedRepr () {return __get__ (this, function (self, any) {
+							var tryGetNumKey = function (key) {
+								if (py_typeof (key) == str) {
+									try {
+										return int (key);
+									}
+									catch (__except0__) {
+										try {
+											return float (key);
+										}
+										catch (__except1__) {
+											return key;
+										}
+									}
+								}
+								else {
+									return key;
+								}
+							};
+							if (py_typeof (any) == dict) {
+								return ('{' + ', '.join ((function () {
+									var __accu0__ = [];
+									for (var [index, key] of enumerate (sorted ((function () {
+										var __accu1__ = [];
+										for (var key of any.py_keys ()) {
+											__accu1__.append (tryGetNumKey (key));
+										}
+										return __accu1__;
+									}) (), __kwargtrans__ ({key: (function __lambda__ (aKey) {
+										return str (aKey);
+									})})))) {
+										__accu0__.append ('{}: {}'.format (repr (key), repr (any [key])));
+									}
+									return __accu0__;
+								}) ())) + '}';
+							}
+							else if (py_typeof (any) == set) {
+								if (len (any)) {
+									return ('{' + ', '.join (sorted ((function () {
+										var __accu0__ = [];
+										for (var item of list (any)) {
+											__accu0__.append (str (item));
+										}
+										return __accu0__;
+									}) ()))) + '}';
+								}
+								else {
+									return repr (any);
+								}
+							}
+							else if (py_typeof (any) == range) {
+								return repr (list (any));
+							}
+							else {
+								return repr (any);
+							}
+						}, 'sortedRepr');},
+						get check () {return __get__ (this, function (self) {
+							var ancestor = 2;
+							if (arguments.length) {
+								var __ilastarg0__ = arguments.length - 1;
+								if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+									var __allkwargs0__ = arguments [__ilastarg0__--];
+									for (var __attrib0__ in __allkwargs0__) {
+										switch (__attrib0__) {
+											case 'self': var self = __allkwargs0__ [__attrib0__]; break;
+											case 'ancestor': var ancestor = __allkwargs0__ [__attrib0__]; break;
+										}
+									}
+								}
+								var args = tuple ([].slice.apply (arguments).slice (1, __ilastarg0__ + 1));
+							}
+							else {
+								var args = tuple ();
+							}
+							var position = getFileLocation (ancestor);
+							var item = ' '.join ((function () {
+								var __accu0__ = [];
+								for (var arg of args) {
+									__accu0__.append (self.sortedRepr (arg));
+								}
+								return __accu0__;
+							}) ());
+							if (__envir__.executor_name == __envir__.transpiler_name) {
+								self.testDict [self._currTestlet].append (tuple ([position, item]));
+							}
+							else {
+								self.refDict [self._currTestlet].append (tuple ([position, item]));
+							}
+						}, 'check');},
+						get expectException () {return __get__ (this, function (self, func) {
+							try {
+								func ();
+								return 'no exception';
+							}
+							catch (__except0__) {
+								if (isinstance (__except0__, Exception)) {
+									var exc = __except0__;
+									return 'exception';
+								}
+								else {
+									throw __except0__;
+								}
+							}
+						}, 'expectException');},
+						get throwToError () {return __get__ (this, function (self, func) {
+							try {
+								return func ();
+							}
+							catch (__except0__) {
+								if (isinstance (__except0__, Exception)) {
+									var exc = __except0__;
+									return tuple ([null, '!!!{}'.format (str (exc))]);
+								}
+								else {
+									throw __except0__;
+								}
+							}
+						}, 'throwToError');},
+						get checkEval () {return __get__ (this, function (self, func) {
+							var ret = self.throwToError (func);
+							self.check (ret, __kwargtrans__ ({ancestor: 3}));
+						}, 'checkEval');},
+						get checkPad () {return __get__ (this, function (self, val, count) {
+							for (var i = 0; i < count; i++) {
+								self.check (val);
+							}
+						}, 'checkPad');},
+						get _getTotalErrorCnt () {return __get__ (this, function (self, testData, refData) {
+							var errCount = 0;
+							for (var [i, [refPos, refItem]] of enumerate (refData)) {
+								try {
+									var __left0__ = testData [i];
+									var testPos = __left0__ [0];
+									var testItem = __left0__ [1];
+									if (testItem != refItem) {
+										errCount++;
+									}
+								}
+								catch (__except0__) {
+									errCount++;
+								}
+							}
+							return errCount;
+						}, '_getTotalErrorCnt');},
+						get compare () {return __get__ (this, function (self) {
+							var dc = DataConverter ();
+							self.refDict = dc.getPythonResults ();
+							var totalErrors = 0;
+							var sKeys = sorted (self.refDict.py_keys ());
+							for (var key of sKeys) {
+								var refData = self.refDict [key];
+								try {
+									var testData = self.testDict [key];
+									if (testData === null) {
+										var __except0__ = KeyError ('No Test Data Module: {}'.format (key));
+										__except0__.__cause__ = null;
+										throw __except0__;
+									}
+								}
+								catch (__except0__) {
+									if (isinstance (__except0__, KeyError)) {
+										self.ui.appendSeqRowName (key, len (refData));
+										for (var [i, [refPos, refItem]] of enumerate (refData)) {
+											self.ui.appendTableResult (key, null, null, refPos, refItem, false);
+										}
+										continue;
+									}
+									else {
+										throw __except0__;
+									}
+								}
+								var errCount = self._getTotalErrorCnt (testData, refData);
+								var collapse = errCount == 0;
+								self.ui.appendSeqRowName (key, errCount);
+								for (var [i, [refPos, refItem]] of enumerate (refData)) {
+									try {
+										var __left0__ = testData [i];
+										var testPos = __left0__ [0];
+										var testItem = __left0__ [1];
+									}
+									catch (__except0__) {
+										var testPos = null;
+										var testItem = null;
+									}
+									self.ui.appendTableResult (key, testPos, testItem, refPos, refItem, collapse);
+								}
+								totalErrors += errCount;
+							}
+							self.ui.setOutputStatus (totalErrors == 0);
+						}, 'compare');},
+						get _cleanName () {return __get__ (this, function (self, py_name) {
+							var ret = py_name;
+							var invalidChars = list (['~', '!', '@', '$', '%', '^', '&', '*', '(', ')', '+', '=', ',', '.', '/', "'", ';', ':', '"', '?', '>', '<', '[', ']', '\\', '{', '}', '|', '`', '#', ' ']);
+							for (var ch of invalidChars) {
+								var ret = ret.py_replace (ch, '_');
+							}
+							return ret;
+						}, '_cleanName');},
+						get run () {return __get__ (this, function (self, testlet, testletName) {
+							var testletName = self._cleanName (testletName);
+							self._currTestlet = testletName;
+							if (__envir__.executor_name == __envir__.transpiler_name) {
+								self.testDict [self._currTestlet] = list ([]);
+							}
+							else {
+								self.refDict [self._currTestlet] = list ([]);
+							}
+							try {
+								testlet.run (self);
+							}
+							catch (__except0__) {
+								if (isinstance (__except0__, Exception)) {
+									var exc = __except0__;
+									if (self.ui !== null) {
+										self.ui.setOutputStatus (false);
+										self.ui.showException (testletName, exc);
+									}
+									else {
+										__except0__.__cause__ = null;
+										throw __except0__;
+									}
+								}
+								else {
+									throw __except0__;
+								}
+							}
+						}, 'run');},
+						get done () {return __get__ (this, function (self) {
+							if (__envir__.executor_name == __envir__.transpiler_name) {
+								self.compare ();
+							}
+							else {
+								var fnameBase = __main__.__file__.__getslice__ (0, -(3), 1).py_replace ('\\', '/').rsplit ('/', 1) [-(1)];
+								var hg = HTMLGenerator (fnameBase);
+								for (var minified of tuple ([false, true])) {
+									hg.generate_html (self.refDict, minified);
+								}
+							}
+						}, 'done');}
+					});
+					__pragma__ ('<use>' +
+						'itertools' +
+						'org.transcrypt.autotester.html' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.AutoTester = AutoTester;
+						__all__.DataConverter = DataConverter;
+						__all__.HTMLGenerator = HTMLGenerator;
+						__all__.JSTesterUI = JSTesterUI;
+						__all__.__name__ = __name__;
+						__all__.getFileLocation = getFileLocation;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'org.transcrypt.autotester.html', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'org.transcrypt.autotester.html';
+					var okColor = 'green';
+					var errorColor = 'red';
+					var highlightColor = 'yellow';
+					var testletNameColor = 'blue';
+					var messageDivId = 'message';
+					var referenceDivId = 'python';
+					var refResultDivId = 'pyresults';
+					var refPosDivId = 'pypos';
+					var testDivId = 'transcrypt';
+					var tableId = 'resulttable';
+					var resultsDivId = 'results';
+					var faultRowClass = 'faultrow';
+					var testletHeaderClass = 'testletheader';
+					var transValClass = 'trans-val';
+					var transPosClass = 'trans-pos';
+					var pyValClass = 'py-val';
+					var pyPosClass = 'py-pos';
+					var excAreaId = 'exc-area';
+					var excHeaderClass = 'exc-header';
+					var forceCollapseId = 'force-collapse';
+					var forceExpandId = 'force-expand';
+					var HTMLGenerator = __class__ ('HTMLGenerator', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, filenameBase) {
+							if (typeof filenameBase == 'undefined' || (filenameBase != null && filenameBase .hasOwnProperty ("__kwargtrans__"))) {;
+								var filenameBase = null;
+							};
+							self._fnameBase = filenameBase;
+						}, '__init__');},
+						get generate_html () {return __get__ (this, function (self, refDict, minified) {
+							if (typeof minified == 'undefined' || (minified != null && minified .hasOwnProperty ("__kwargtrans__"))) {;
+								var minified = false;
+							};
+							if (self._fnameBase === null) {
+								var __except0__ = ValueError ('Filename Base must be defined to generate');
+								__except0__.__cause__ = null;
+								throw __except0__;
+							}
+							var minInfix = (minified ? '.min' : '');
+							var fname = minInfix.join (list ([self._fnameBase, '.html']));
+							var jsFileName = minInfix.join (list ([self._fnameBase, '.js']));
+							var jsPath = '{}/{}'.format (__envir__.target_subdir, jsFileName);
+							f = open (fname, 'w');
+							f.write ('<html><head>');
+							self._writeCSS (f);
+							f.write ('</head><body>');
+							self._writeStatusHeaderTemplate (f);
+							var dc = DataConverter ();
+							dc.writeHiddenResults (f, refDict);
+							self._writeTableArea (f);
+							f.write ('<script src="{}"></script>\n\n'.format (jsPath));
+							f.write ('</body></html>');
+							f.close ();
+						}, 'generate_html');},
+						get _writeCSS () {return __get__ (this, function (self, f) {
+							var cssOut = '\n\t\t<style>\n\t\t  body {\n\t\t    max-width: 100%;\n\t\t  }\n\t\t  .faultrow > td {\n\t\t     background-color: LightCoral;\n\t\t  }\n\t\t  #resulttable {\n\t\t    border-collapse: collapse;\n\t\t    width: 100%;\n\t\t    table-layout: fixed;\n\t\t  }\n\t\t  #resulttable th, #resulttable td {\n\t\t    border: 1px solid grey;\n\t\t  }\n\t\t  .testletheader > td {\n\t\t    background-color: LightSkyBlue;\n\t\t  }\n\t\t  .header-pos {\n\t\t    width: 20%;\n\t\t  }\n\t\t  .header-val {\n\t\t    width: 30%;\n\t\t  }\n\t\t  .py-pos,.trans-pos {\n\t\t    width: 20%;\n\t\t    overflow: hidden;\n\t\t  }\n\t\t  .py-val, .trans-val {\n\t\t    width: 30%;\n\t\t    overflow-x: auto;\n\t\t  }\n\t\t  .exc-header {\n\t      color: red;\n\t\t  }\n\t\t  .collapsed {\n\t\t    display: None;\n\t\t  }\n\t\t</style>\n\t\t';
+							f.write (cssOut);
+						}, '_writeCSS');},
+						get _writeStatusHeaderTemplate () {return __get__ (this, function (self, f) {
+							f.write ('<b>Status:</b>\n');
+							f.write ('<div id="{}"></div><br><br>\n\n'.format (messageDivId));
+						}, '_writeStatusHeaderTemplate');},
+						get _writeTableArea () {return __get__ (this, function (self, f) {
+							f.write ('<div id="{}"></div>'.format (excAreaId));
+							f.write ('<div id="{}">'.format (resultsDivId));
+							f.write ('<div> <a id="{}" href="#"> Collapse All</a> <a id="{}" href="#">Expand All</a></div>'.format (forceCollapseId, forceExpandId));
+							f.write ('<table id="{}"><thead><tr> <th colspan="2"> CPython </th> <th colspan="2"> Transcrypt </th> </tr>'.format (tableId));
+							f.write ('<tr> <th class="header-pos"> Location </th> <th class="header-val"> Value </th> <th class="header-val"> Value </th> <th class="header-pos"> Location </th> </tr></thead><tbody></tbody>');
+							f.write ('</table>');
+							f.write ('</div>');
+						}, '_writeTableArea');}
+					});
+					var DataConverter = __class__ ('DataConverter', [object], {
+						__module__: __name__,
+						get writeHiddenResults () {return __get__ (this, function (self, f, refDict) {
+							f.write ('<div id="{}" style="display: None">'.format (referenceDivId));
+							for (var key of refDict.py_keys ()) {
+								var itemData = ' | '.join ((function () {
+									var __accu0__ = [];
+									for (var x of refDict [key]) {
+										__accu0__.append (x [1]);
+									}
+									return __accu0__;
+								}) ());
+								var posContent = ' | '.join ((function () {
+									var __accu0__ = [];
+									for (var x of refDict [key]) {
+										__accu0__.append (x [0]);
+									}
+									return __accu0__;
+								}) ());
+								f.write ('<div id="{}">\n'.format (key));
+								f.write ('<div id="{}">{}</div>\n\n'.format (refResultDivId, itemData));
+								f.write ('<div id="{}">{}</div>\n'.format (refPosDivId, posContent));
+								f.write ('</div>\n');
+							}
+							f.write ('</div></div>\n');
+						}, 'writeHiddenResults');},
+						get getPythonResults () {return __get__ (this, function (self) {
+							var refData = document.getElementById (referenceDivId);
+							var refDict = dict ({});
+							for (var child of refData.children) {
+								var keyName = child.getAttribute ('id');
+								var __left0__ = self._extractPosResult (child);
+								var posData = __left0__ [0];
+								var resultData = __left0__ [1];
+								refDict [keyName] = zip (posData, resultData);
+							}
+							return refDict;
+						}, 'getPythonResults');},
+						get _extractPosResult () {return __get__ (this, function (self, elem) {
+							var resultData = null;
+							var posData = null;
+							for (var e of elem.children) {
+								var idStr = e.getAttribute ('id');
+								if (idStr == refResultDivId) {
+									var resultData = e.innerHTML.py_split (' | ');
+								}
+								else if (idStr == refPosDivId) {
+									var posData = e.innerHTML.py_split (' | ');
+								}
+								else {
+									// pass;
+								}
+							}
+							return tuple ([posData, resultData]);
+						}, '_extractPosResult');}
+					});
+					var getRowClsName = function (py_name) {
+						return 'mod-' + py_name;
+					};
+					var JSTesterUI = __class__ ('JSTesterUI', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							self.expander = TestModuleExpander ();
+						}, '__init__');},
+						get setOutputStatus () {return __get__ (this, function (self, success) {
+							if (success) {
+								document.getElementById (messageDivId).innerHTML = '<div style="color: {}">Test succeeded</div>'.format (okColor);
+							}
+							else {
+								document.getElementById (messageDivId).innerHTML = '<div style="color: {}"><b>Test failed</b></div>'.format (errorColor);
+							}
+						}, 'setOutputStatus');},
+						get appendSeqRowName () {return __get__ (this, function (self, py_name, errCount) {
+							var table = document.getElementById (tableId);
+							var row = table.insertRow (-(1));
+							row.id = py_name;
+							row.classList.add (testletHeaderClass);
+							self.expander.setupCollapseableHeader (row, errCount == 0);
+							var headerCell = row.insertCell (0);
+							headerCell.innerHTML = (py_name + ' | Errors = ') + str (errCount);
+							headerCell.colSpan = 4;
+							headerCell.style.textAlign = 'center';
+						}, 'appendSeqRowName');},
+						get appendTableResult () {return __get__ (this, function (self, py_name, testPos, testItem, refPos, refItem, collapse) {
+							if (typeof collapse == 'undefined' || (collapse != null && collapse .hasOwnProperty ("__kwargtrans__"))) {;
+								var collapse = false;
+							};
+							var clsName = getRowClsName (py_name);
+							var table = document.getElementById (tableId);
+							var row = table.insertRow (-(1));
+							row.classList.add (clsName);
+							if (testItem != refItem) {
+								row.classList.add (faultRowClass);
+								var refPos = '!!!' + refPos;
+							}
+							else {
+								self.expander.setCollapsed (row, collapse);
+							}
+							var cpy_pos = row.insertCell (0);
+							cpy_pos.innerHTML = refPos;
+							cpy_pos.classList.add (pyPosClass);
+							var cpy_val = row.insertCell (1);
+							cpy_val.innerHTML = refItem;
+							cpy_val.classList.add (pyValClass);
+							var trans_val = row.insertCell (2);
+							if (testItem !== null) {
+								trans_val.innerHTML = testItem;
+							}
+							trans_val.classList.add (transValClass);
+							var trans_pos = row.insertCell (3);
+							if (testPos !== null) {
+								trans_pos.innerHTML = testPos;
+							}
+							trans_pos.classList.add (transPosClass);
+						}, 'appendTableResult');},
+						get showException () {return __get__ (this, function (self, testname, exc) {
+							var excElem = document.getElementById (excAreaId);
+							var header = document.createElement ('H2');
+							header.classList.add (excHeaderClass);
+							header.innerHTML = 'Exception Thrown in JS Runtime';
+							excElem.appendChild (header);
+							var content = document.createElement ('p');
+							content.innerHTML = 'Exception in {}: {}'.format (testname, str (exc));
+							excElem.appendChild (content);
+							var stacktrace = document.createElement ('p');
+							if (exc.stack !== null) {
+								stacktrace.innerHTML = str (exc.stack);
+							}
+							else {
+								stacktrace.innerHTML = 'No Stack Trace Available!';
+							}
+						}, 'showException');}
+					});
+					var TestModuleExpander = __class__ ('TestModuleExpander', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							self.collapsedClass = 'collapsed';
+							self.modCollapseClass = 'mod-collapsed';
+							self._expandCollapseAllFuncs ();
+						}, '__init__');},
+						get setCollapsed () {return __get__ (this, function (self, row, collapse) {
+							if (collapse) {
+								row.classList.add (self.collapsedClass);
+							}
+							else {
+								row.classList.remove (self.collapsedClass);
+							}
+						}, 'setCollapsed');},
+						get setupCollapseableHeader () {return __get__ (this, function (self, row, startCollapsed) {
+							if (typeof startCollapsed == 'undefined' || (startCollapsed != null && startCollapsed .hasOwnProperty ("__kwargtrans__"))) {;
+								var startCollapsed = false;
+							};
+							if (startCollapsed) {
+								row.classList.add (self.modCollapseClass);
+							}
+							var toggleCollapse = function (evt) {
+								var headerRow = evt.target.parentElement;
+								var doCollapse = !(headerRow.classList.contains (self.modCollapseClass));
+								self.collapseModule (headerRow, doCollapse);
+							};
+							row.onclick = toggleCollapse;
+						}, 'setupCollapseableHeader');},
+						get collapseModule () {return __get__ (this, function (self, headerRow, doCollapse) {
+							var py_name = headerRow.id;
+							var table = document.getElementById (tableId);
+							var clsName = getRowClsName (py_name);
+							var allRows = table.tHead.children;
+							var rows = filter ((function __lambda__ (x) {
+								return x.classList.contains (clsName);
+							}), allRows);
+							for (var row of rows) {
+								self.setCollapsed (row, doCollapse);
+							}
+							if (doCollapse) {
+								headerRow.classList.add (self.modCollapseClass);
+							}
+							else {
+								headerRow.classList.remove (self.modCollapseClass);
+							}
+						}, 'collapseModule');},
+						get _expandCollapseAllFuncs () {return __get__ (this, function (self) {
+							var applyToAll = function (evt, collapse) {
+								var table = document.getElementById (tableId);
+								var filtFunc = (function __lambda__ (x) {
+									return x.classList.contains (testletHeaderClass);
+								});
+								var headerRows = filter (filtFunc, table.tHead.children);
+								for (var headerRow of headerRows) {
+									self.collapseModule (headerRow, collapse);
+								}
+							};
+							var collapseAll = function (evt) {
+								evt.preventDefault ();
+								applyToAll (evt, true);
+								return false;
+							};
+							var expandAll = function (evt) {
+								evt.preventDefault ();
+								applyToAll (evt, false);
+								return false;
+							};
+							var forceCollapse = document.getElementById (forceCollapseId);
+							forceCollapse.onclick = collapseAll;
+							var forceExpand = document.getElementById (forceExpandId);
+							forceExpand.onclick = expandAll;
+						}, '_expandCollapseAllFuncs');}
+					});
+					__pragma__ ('<all>')
+						__all__.DataConverter = DataConverter;
+						__all__.HTMLGenerator = HTMLGenerator;
+						__all__.JSTesterUI = JSTesterUI;
+						__all__.TestModuleExpander = TestModuleExpander;
+						__all__.__name__ = __name__;
+						__all__.errorColor = errorColor;
+						__all__.excAreaId = excAreaId;
+						__all__.excHeaderClass = excHeaderClass;
+						__all__.faultRowClass = faultRowClass;
+						__all__.forceCollapseId = forceCollapseId;
+						__all__.forceExpandId = forceExpandId;
+						__all__.getRowClsName = getRowClsName;
+						__all__.highlightColor = highlightColor;
+						__all__.messageDivId = messageDivId;
+						__all__.okColor = okColor;
+						__all__.pyPosClass = pyPosClass;
+						__all__.pyValClass = pyValClass;
+						__all__.refPosDivId = refPosDivId;
+						__all__.refResultDivId = refResultDivId;
+						__all__.referenceDivId = referenceDivId;
+						__all__.resultsDivId = resultsDivId;
+						__all__.tableId = tableId;
+						__all__.testDivId = testDivId;
+						__all__.testletHeaderClass = testletHeaderClass;
+						__all__.testletNameColor = testletNameColor;
+						__all__.transPosClass = transPosClass;
+						__all__.transValClass = transValClass;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	(function () {
+		var basics = {};
+		var module_fft = {};
+		var module_linalg = {};
+		var org = {};
+		var __name__ = '__main__';
+		__nest__ (org, 'transcrypt.autotester', __init__ (__world__.org.transcrypt.autotester));
+		__nest__ (basics, '', __init__ (__world__.basics));
+		__nest__ (module_linalg, '', __init__ (__world__.module_linalg));
+		__nest__ (module_fft, '', __init__ (__world__.module_fft));
+		var autoTester = org.transcrypt.autotester.AutoTester ();
+		autoTester.run (basics, 'basics');
+		autoTester.run (module_linalg, 'module_linalg');
+		autoTester.run (module_fft, 'module_fft');
+		autoTester.done ();
+		__pragma__ ('<use>' +
+			'basics' +
+			'module_fft' +
+			'module_linalg' +
+			'org.transcrypt.autotester' +
+		'</use>')
+		__pragma__ ('<all>')
+			__all__.__name__ = __name__;
+			__all__.autoTester = autoTester;
+		__pragma__ ('</all>')
+	}) ();
+   return __all__;
+}
+window ['autotest'] = autotest ();
diff --git a/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.min.js b/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.min.js
new file mode 100644
index 0000000..ba83e8c
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.min.js
@@ -0,0 +1,175 @@
+'use strict';var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(h,v,B){h!=Array.prototype&&h!=Object.prototype&&(h[v]=B.value)};$jscomp.getGlobal=function(h){return"undefined"!=typeof window&&window===h?h:"undefined"!=typeof global&&null!=global?global:h};$jscomp.global=$jscomp.getGlobal(this);
+$jscomp.SYMBOL_PREFIX="jscomp_symbol_";$jscomp.initSymbol=function(){$jscomp.initSymbol=function(){};$jscomp.global.Symbol||($jscomp.global.Symbol=$jscomp.Symbol)};$jscomp.symbolCounter_=0;$jscomp.Symbol=function(h){return $jscomp.SYMBOL_PREFIX+(h||"")+$jscomp.symbolCounter_++};
+$jscomp.initSymbolIterator=function(){$jscomp.initSymbol();var h=$jscomp.global.Symbol.iterator;h||(h=$jscomp.global.Symbol.iterator=$jscomp.global.Symbol("iterator"));"function"!=typeof Array.prototype[h]&&$jscomp.defineProperty(Array.prototype,h,{configurable:!0,writable:!0,value:function(){return $jscomp.arrayIterator(this)}});$jscomp.initSymbolIterator=function(){}};$jscomp.arrayIterator=function(h){var v=0;return $jscomp.iteratorPrototype(function(){return v<h.length?{done:!1,value:h[v++]}:{done:!0}})};
+$jscomp.iteratorPrototype=function(h){$jscomp.initSymbolIterator();h={next:h};h[$jscomp.global.Symbol.iterator]=function(){return this};return h};$jscomp.makeIterator=function(h){$jscomp.initSymbolIterator();$jscomp.initSymbol();$jscomp.initSymbolIterator();var v=h[Symbol.iterator];return v?v.call(h):$jscomp.arrayIterator(h)};$jscomp.arrayFromIterator=function(h){for(var v,B=[];!(v=h.next()).done;)B.push(v.value);return B};$jscomp.arrayFromIterable=function(h){return h instanceof Array?h:$jscomp.arrayFromIterator($jscomp.makeIterator(h))};
+$jscomp.polyfill=function(h,v,B,z){if(v){B=$jscomp.global;h=h.split(".");for(z=0;z<h.length-1;z++){var K=h[z];K in B||(B[K]={});B=B[K]}h=h[h.length-1];z=B[h];v=v(z);v!=z&&null!=v&&$jscomp.defineProperty(B,h,{configurable:!0,writable:!0,value:v})}};$jscomp.polyfill("Object.getOwnPropertySymbols",function(h){return h?h:function(){return[]}},"es6","es5");
+$jscomp.checkStringArgs=function(h,v,B){if(null==h)throw new TypeError("The 'this' value for String.prototype."+B+" must not be null or undefined");if(v instanceof RegExp)throw new TypeError("First argument to String.prototype."+B+" must not be a regular expression");return h+""};
+$jscomp.polyfill("String.prototype.startsWith",function(h){return h?h:function(v,h){var B=$jscomp.checkStringArgs(this,v,"startsWith");v+="";var K=B.length,D=v.length;h=Math.max(0,Math.min(h|0,B.length));for(var L=0;L<D&&h<K;)if(B[h++]!=v[L++])return!1;return L>=D}},"es6","es3");
+$jscomp.polyfill("Array.from",function(h){return h?h:function(v,h,z){$jscomp.initSymbolIterator();h=null!=h?h:function(h){return h};var B=[],D=v[Symbol.iterator];if("function"==typeof D)for(v=D.call(v);!(D=v.next()).done;)B.push(h.call(z,D.value));else{D=v.length;for(var L=0;L<D;L++)B.push(h.call(z,v[L]))}return B}},"es6","es3");
+$jscomp.iteratorFromArray=function(h,v){$jscomp.initSymbolIterator();h instanceof String&&(h+="");var B=0,z={next:function(){if(B<h.length){var K=B++;return{value:v(K,h[K]),done:!1}}z.next=function(){return{done:!0,value:void 0}};return z.next()}};z[Symbol.iterator]=function(){return z};return z};$jscomp.polyfill("Array.prototype.keys",function(h){return h?h:function(){return $jscomp.iteratorFromArray(this,function(h){return h})}},"es6","es3");
+$jscomp.polyfill("Math.hypot",function(h){return h?h:function(h,B,z){h=Number(h);B=Number(B);var v,D=Math.max(Math.abs(h),Math.abs(B));for(v=2;v<arguments.length;v++)D=Math.max(D,Math.abs(arguments[v]));if(1E100<D||1E-100>D){h/=D;B/=D;var L=h*h+B*B;for(v=2;v<arguments.length;v++){var x=Number(arguments[v])/D;L+=x*x}return Math.sqrt(L)*D}L=h*h+B*B;for(v=2;v<arguments.length;v++)x=Number(arguments[v]),L+=x*x;return Math.sqrt(L)}},"es6","es3");
+$jscomp.polyfill("Math.sinh",function(h){if(h)return h;var v=Math.exp;return function(h){h=Number(h);return 0===h?h:(v(h)-v(-h))/2}},"es6","es3");$jscomp.polyfill("Math.cosh",function(h){if(h)return h;var v=Math.exp;return function(h){h=Number(h);return(v(h)+v(-h))/2}},"es6","es3");$jscomp.polyfill("Math.tanh",function(h){return h?h:function(h){h=Number(h);if(0===h)return h;var v=Math.exp(-2*Math.abs(h));v=(1-v)/(1+v);return 0>h?-v:v}},"es6","es3");
+$jscomp.polyfill("Math.asinh",function(h){return h?h:function(h){h=Number(h);if(0===h)return h;var v=Math.log(Math.abs(h)+Math.sqrt(h*h+1));return 0>h?-v:v}},"es6","es3");$jscomp.polyfill("Math.acosh",function(h){return h?h:function(h){h=Number(h);return Math.log(h+Math.sqrt(h*h-1))}},"es6","es3");$jscomp.polyfill("Math.log1p",function(h){return h?h:function(h){h=Number(h);if(.25>h&&-.25<h){for(var v=h,z=1,K=h,D=0,L=1;D!=K;)v*=h,L*=-1,K=(D=K)+L*v/++z;return K}return Math.log(1+h)}},"es6","es3");
+$jscomp.polyfill("Math.atanh",function(h){if(h)return h;var v=Math.log1p;return function(h){h=Number(h);return(v(h)-v(-h))/2}},"es6","es3");$jscomp.polyfill("Math.trunc",function(h){return h?h:function(h){h=Number(h);if(isNaN(h)||Infinity===h||-Infinity===h||0===h)return h;var v=Math.floor(Math.abs(h));return 0>h?-v:v}},"es6","es3");
+function autotest(){function h(a){return void 0===a||null===a?!1:0<=["boolean","number"].indexOf(typeof a)?a:a.__bool__ instanceof Function?a.__bool__()?a:!1:a.__len__ instanceof Function?0!==a.__len__()?a:!1:a instanceof Function?a:0!==N(a)?a:!1}function v(a){this.iterable=a;this.index=0}function B(a){this.iterable=a;this.index=0}function z(a,b,m){void 0==b&&(b=a,a=0);void 0==m&&(m=1);if(0<m&&a>=b||0>m&&a<=b)return[];for(var p=[];0<m?a<b:a>b;a+=m)p.push(a);return p}function K(a){return fa(z(N(a)),
+a)}function D(a){if(null==a||"object"==typeof a)return a;var b={},m;for(m in obj)a.hasOwnProperty(m)&&(b[m]=a[m]);return b}function L(a){if(null==a||"object"==typeof a)return a;var b={},m;for(m in obj)a.hasOwnProperty(m)&&(b[m]=L(a[m]));return b}function x(a){return a?Array.from(a):[]}function r(a){a=a?[].slice.apply(a):[];a.__class__=r;return a}function T(a){var b=[];if(a)for(var m=0;m<a.length;m++)b.add(a[m]);b.__class__=T;return b}function oa(a,b){if(void 0==a)return new Uint8Array(0);b=J(a);if(b==
+X)return new Uint8Array(a);if(b==G){b=new Uint8Array(N(a));for(var m=0;m<N(a);m++)b[m]=a.charCodeAt(m);return b}if(b==x||b==r)return new Uint8Array(a);throw va;}function G(a){try{return a.__str__()}catch(b){try{return U(a)}catch(m){return String(a)}}}function wa(){var a=[],b;for(b in this)ba(b)||a.push(b);return a}function xa(){var a=[],b;for(b in this)ba(b)||a.push([b,this[b]]);return a}function ya(a){delete this[a]}function za(){for(var a in this)delete this[a]}function Aa(a,b){a=this[a];return void 0==
+a?void 0==b?null:b:a}function Ba(a,b){var m=this[a];if(void 0!=m)return m;b=void 0==b?null:b;return this[a]=b}function Ca(a,b){var m=this[a];if(void 0!=m)return delete this[a],m;if(void 0===b)throw ha(a,Error());return b}function Da(){var a=Object.keys(this)[0];if(null==a)throw ha("popitem(): dictionary is empty",Error());var b=r([a,this[a]]);delete this[a];return b}function Ea(a){for(var b in a)this[b]=a[b]}function Fa(){var a=[],b;for(b in this)ba(b)||a.push(this[b]);return a}function Ga(a){return this[a]}
+function Ha(a,b){this[a]=b}function P(a){var b={};if(!a||a instanceof Array){if(a)for(var m=0;m<a.length;m++){var p=a[m];if(!(p instanceof Array)||2!=p.length)throw ca("dict update sequence element #"+m+" has length "+p.length+"; 2 is required",Error());var q=p[0];p=p[1];!(a instanceof Array)&&a instanceof Object&&(W(a,P)||(p=P(p)));b[q]=p}}else if(W(a,P))for(p=a.py_keys(),m=0;m<p.length;m++)q=p[m],b[q]=a[q];else if(a instanceof Object)b=a;else throw ca("Invalid type of object for dict creation",
+Error());O(b,"__class__",{value:P,enumerable:!1,writable:!0});O(b,"py_keys",{value:wa,enumerable:!1});O(b,"__iter__",{value:function(){new v(this.py_keys())},enumerable:!1});$jscomp.initSymbol();$jscomp.initSymbolIterator();O(b,Symbol.iterator,{value:function(){new B(this.py_keys())},enumerable:!1});O(b,"py_items",{value:xa,enumerable:!1});O(b,"py_del",{value:ya,enumerable:!1});O(b,"py_clear",{value:za,enumerable:!1});O(b,"py_get",{value:Aa,enumerable:!1});O(b,"py_setdefault",{value:Ba,enumerable:!1});
+O(b,"py_pop",{value:Ca,enumerable:!1});O(b,"py_popitem",{value:Da,enumerable:!1});O(b,"py_update",{value:Ea,enumerable:!1});O(b,"py_values",{value:Fa,enumerable:!1});O(b,"__getitem__",{value:Ga,enumerable:!1});O(b,"__setitem__",{value:Ha,enumerable:!1});return b}var n={},H=function(a,b,m){if(""!=b){b=b.split(".");for(var p=b.length,q=0;q<b.length;q++){if(!a.hasOwnProperty(b[q])){p=q;break}a=a[b[q]]}for(q=p;q<b.length;q++)a[b[q]]={},a=a[b[q]]}for(var l in m)a[l]=m[l]};n.__nest__=H;var F=function(a){a.__inited__||
+(a.__all__.__init__(a.__all__),a.__inited__=!0);return a.__all__};n.__init__=F;var u=function(a,b,m){return a&&(a.hasOwnProperty("__class__")||"string"==typeof a||a instanceof String)?(m&&Object.defineProperty(a,m,{value:function(){var m=[].slice.apply(arguments);return b.apply(null,[a].concat(m))},writable:!0,enumerable:!0,configurable:!0}),function(){var m=[].slice.apply(arguments);return b.apply(null,[a].concat(m))}):b};n.__get__=u;n.__getcm__=function(a,b,m){return a.hasOwnProperty("__class__")?
+function(){var m=[].slice.apply(arguments);return b.apply(null,[a.__class__].concat(m))}:function(){var m=[].slice.apply(arguments);return b.apply(null,[a].concat(m))}};n.__getsm__=function(a,b,m){return b};var ia={__name__:"type",__bases__:[],__new__:function(a,b,m,p){for(var q,l,e=function(){var a=[].slice.apply(arguments);return e.__new__(a)},k=m.length-1;0<=k;k--){var g=m[k],c;for(c in g)q=Object.getOwnPropertyDescriptor(g,c),Object.defineProperty(e,c,q);var d=$jscomp.makeIterator(Object.getOwnPropertySymbols(g));
+for(q=d.next();!q.done;q=d.next())l=q.value,q=Object.getOwnPropertyDescriptor(g,l),Object.defineProperty(e,l,q)}e.__metaclass__=a;e.__name__=b.startsWith("py_")?b.slice(3):b;e.__bases__=m;for(c in p)q=Object.getOwnPropertyDescriptor(p,c),Object.defineProperty(e,c,q);a=$jscomp.makeIterator(Object.getOwnPropertySymbols(p));for(q=a.next();!q.done;q=a.next())l=q.value,q=Object.getOwnPropertyDescriptor(p,l),Object.defineProperty(e,l,q);return e}};ia.__metaclass__=ia;n.py_metatype=ia;var V={__init__:function(a){},
+__metaclass__:ia,__name__:"object",__bases__:[],__new__:function(a){var b=Object.create(this,{__class__:{value:this,enumerable:!0}});if("__getattr__"in this||"__setattr__"in this)b=new Proxy(b,{get:function(a,b){var m=a[b];return void 0==m?a.__getattr__(b):m},set:function(a,b,q){try{a.__setattr__(b,q)}catch(l){a[b]=q}return!0}});this.__init__.apply(null,[b].concat(a));return b}};n.object=V;var E=function(a,b,m,p){void 0==p&&(p=b[0].__metaclass__);return p.__new__(p,a,b,m)};n.__class__=E;n.__pragma__=
+function(){};H(n,"org.transcrypt.__base__",{__all__:{__inited__:!1,__init__:function(a){var b=E("__Envir__",[V],{__module__:"org.transcrypt.__base__",get __init__(){return u(this,function(a){a.interpreter_name="python";a.transpiler_name="transcrypt";a.transpiler_version="3.6.66";a.target_subdir="__javascript__"},"__init__")}}),m=b();a.__Envir__=b;a.__envir__=m;a.__name__="org.transcrypt.__base__"}}});H(n,"org.transcrypt.__standard__",{__all__:{__inited__:!1,__init__:function(a){var b=E("Exception",
+[V],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a){var b=P();if(arguments.length){var c=arguments.length-1;if(arguments[c]&&arguments[c].hasOwnProperty("__kwargtrans__")){var d=arguments[c--],e;for(e in d)switch(e){case "self":a=d[e];break;default:b[e]=d[e]}delete b.__kwargtrans__}c=r([].slice.apply(arguments).slice(1,c+1))}else c=r();a.__args__=c;try{a.stack=b.error.stack}catch(Ma){a.stack="No stack trace available"}},"__init__")},get __repr__(){return u(this,
+function(a){return N(a.__args__)?"{}{}".format(a.__class__.__name__,U(r(a.__args__))):"{}()".format(a.__class__.__name__)},"__repr__")},get __str__(){return u(this,function(a){return 1<N(a.__args__)?G(r(a.__args__)):N(a.__args__)?G(a.__args__[0]):""},"__str__")}}),m=E("IterableError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a,c){b.__init__(a,"Can't iterate over non-iterable",Q({error:c}))},"__init__")}}),p=E("StopIteration",[b],{__module__:"org.transcrypt.__standard__",
+get __init__(){return u(this,function(a,c){b.__init__(a,"Iterator exhausted",Q({error:c}))},"__init__")}}),q=E("ValueError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a,c,d){b.__init__(a,c,Q({error:d}))},"__init__")}}),l=E("KeyError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a,c,d){b.__init__(a,c,Q({error:d}))},"__init__")}}),e=E("AssertionError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,
+function(a,c,d){c?b.__init__(a,c,Q({error:d})):b.__init__(a,Q({error:d}))},"__init__")}}),k=E("NotImplementedError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a,c,d){b.__init__(a,c,Q({error:d}))},"__init__")}}),g=E("IndexError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a,c,d){b.__init__(a,c,Q({error:d}))},"__init__")}}),c=E("AttributeError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,
+function(a,c,d){b.__init__(a,c,Q({error:d}))},"__init__")}}),d=E("py_TypeError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a,c,d){b.__init__(a,c,Q({error:d}))},"__init__")}}),w=E("Warning",[b],{__module__:"org.transcrypt.__standard__"}),y=E("UserWarning",[w],{__module__:"org.transcrypt.__standard__"}),M=E("DeprecationWarning",[w],{__module__:"org.transcrypt.__standard__"}),C=E("RuntimeWarning",[w],{__module__:"org.transcrypt.__standard__"}),h=function(a,c,
+b){if("undefined"==typeof c||null!=c&&c.hasOwnProperty("__kwargtrans__"))c=null;if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=!1;if(arguments.length){var d=arguments.length-1;if(arguments[d]&&arguments[d].hasOwnProperty("__kwargtrans__")){d=arguments[d--];for(var e in d)switch(e){case "iterable":a=d[e];break;case "key":c=d[e];break;case "reverse":b=d[e]}}}c?a.sort(function(a,b){if(arguments.length){var d=arguments.length-1;if(arguments[d]&&arguments[d].hasOwnProperty("__kwargtrans__")){d=
+arguments[d--];for(var e in d)switch(e){case "a":a=d[e];break;case "b":b=d[e]}}}return c(a)>c(b)?1:-1}):a.sort();b&&a.reverse()},n=E("complex",[V],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a,c,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=null;null==b?J(c)==n?(a.real=c.real,a.imag=c.imag):(a.real=c,a.imag=0):(a.real=c,a.imag=b)},"__init__")},get __neg__(){return u(this,function(a){return n(-a.real,-a.imag)},"__neg__")},get __exp__(){return u(this,
+function(a){var c=Math.exp(a.real);return n(c*Math.cos(a.imag),c*Math.sin(a.imag))},"__exp__")},get __log__(){return u(this,function(a){return n(Math.log(Math.sqrt(a.real*a.real+a.imag*a.imag)),Math.atan2(a.imag,a.real))},"__log__")},get __pow__(){return u(this,function(a,c){return a.__log__().__mul__(c).__exp__()},"__pow__")},get __rpow__(){return u(this,function(a,c){return a.__mul__(Math.log(c)).__exp__()},"__rpow__")},get __mul__(){return u(this,function(a,c){return"number"===typeof c?n(a.real*
+c,a.imag*c):n(a.real*c.real-a.imag*c.imag,a.real*c.imag+a.imag*c.real)},"__mul__")},get __rmul__(){return u(this,function(a,c){return n(a.real*c,a.imag*c)},"__rmul__")},get __div__(){return u(this,function(a,c){if("number"===typeof c)return n(a.real/c,a.imag/c);var b=c.real*c.real+c.imag*c.imag;return n((a.real*c.real+a.imag*c.imag)/b,(a.imag*c.real-a.real*c.imag)/b)},"__div__")},get __rdiv__(){return u(this,function(a,c){var b=a.real*a.real;return n(c*a.real/b,c*a.imag/b)},"__rdiv__")},get __add__(){return u(this,
+function(a,c){return"number"===typeof c?n(a.real+c,a.imag):n(a.real+c.real,a.imag+c.imag)},"__add__")},get __radd__(){return u(this,function(a,c){return n(a.real+c,a.imag)},"__radd__")},get __sub__(){return u(this,function(a,c){return"number"===typeof c?n(a.real-c,a.imag):n(a.real-c.real,a.imag-c.imag)},"__sub__")},get __rsub__(){return u(this,function(a,c){return n(c-a.real,-a.imag)},"__rsub__")},get __repr__(){return u(this,function(a){return"({}{}{}j)".format(a.real,0<=a.imag?"+":"",a.imag)},"__repr__")},
+get __str__(){return u(this,function(a){return __repr__(a).__getslice__(1,-1,1)},"__str__")}}),t=E("__Terminal__",[V],{__module__:"org.transcrypt.__standard__",get __init__(){return u(this,function(a){a.buffer="";try{a.element=document.getElementById("__terminal__")}catch(La){a.element=null}a.element&&(a.element.style.overflowX="auto",a.element.style.boxSizing="border-box",a.element.style.padding="5px",a.element.innerHTML="_")},"__init__")},get print(){return u(this,function(a){var c=" ";var b="\n";
+if(arguments.length){var d=arguments.length-1;if(arguments[d]&&arguments[d].hasOwnProperty("__kwargtrans__")){var e=arguments[d--],w;for(w in e)switch(w){case "self":a=e[w];break;case "sep":c=e[w];break;case "end":b=e[w]}}var y=r([].slice.apply(arguments).slice(1,d+1))}else y=r();a.buffer="{}{}{}".format(a.buffer,c.join(function(){for(var a=[],c=$jscomp.makeIterator(y),b=c.next();!b.done;b=c.next())a.append(G(b.value));return a}()),b).__getslice__(-4096,null,1);a.element?(a.element.innerHTML=a.buffer.py_replace("\n",
+"<br>").py_replace(" ","&nbsp"),a.element.scrollTop=a.element.scrollHeight):console.log(c.join(function(){for(var a=[],c=$jscomp.makeIterator(y),b=c.next();!b.done;b=c.next())a.append(G(b.value));return a}()))},"print")},get input(){return u(this,function(a,c){if(arguments.length){var b=arguments.length-1;if(arguments[b]&&arguments[b].hasOwnProperty("__kwargtrans__")){b=arguments[b--];for(var d in b)switch(d){case "self":a=b[d];break;case "question":c=b[d]}}}a.print("{}".format(c),Q({end:""}));d=
+window.prompt("\n".join(a.buffer.py_split("\n").__getslice__(-16,null,1)));a.print(d);return d},"input")}}),v=t();a.AssertionError=e;a.AttributeError=c;a.DeprecationWarning=M;a.Exception=b;a.IndexError=g;a.IterableError=m;a.KeyError=l;a.NotImplementedError=k;a.RuntimeWarning=C;a.StopIteration=p;a.py_TypeError=d;a.UserWarning=y;a.ValueError=q;a.Warning=w;a.__Terminal__=t;a.__name__="org.transcrypt.__standard__";a.__sort__=h;a.__terminal__=v;a.complex=n;a.filter=function(a,c){null==a&&(a=aa);var b=
+[];c=$jscomp.makeIterator(c);for(var d=c.next();!d.done;d=c.next())d=d.value,a(d)&&b.append(d);return b};a.map=function(a,c){var b=[];c=$jscomp.makeIterator(c);for(var d=c.next();!d.done;d=c.next())b.append(a(d.value));return b};a.sorted=function(a,c,b){if("undefined"==typeof c||null!=c&&c.hasOwnProperty("__kwargtrans__"))c=null;if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=!1;if(arguments.length){var d=arguments.length-1;if(arguments[d]&&arguments[d].hasOwnProperty("__kwargtrans__"))for(e in d=
+arguments[d--],d)switch(e){case "iterable":a=d[e];break;case "key":c=d[e];break;case "reverse":b=d[e]}}var e=J(a)==P?D(a.py_keys()):D(a);h(e,c,b);return e}}}});var t=function(){var a=[].slice.apply(arguments);return"object"==typeof a[0]&&"__call__"in a[0]?a[0].__call__.apply(a[1],a.slice(2)):a[0].apply(a[1],a.slice(2))};n.__call__=t;H(n,"",F(n.org.transcrypt.__base__));var I=n.__envir__;H(n,"",F(n.org.transcrypt.__standard__));var ja=n.Exception,Ia=n.StopIteration,ca=n.ValueError,ha=n.KeyError,Ja=
+n.AssertionError,va=n.py_TypeError,Ka=n.__sort__,na=n.sorted,pa=n.filter,R=n.complex;n.print=n.__terminal__.print;n.input=n.__terminal__.input;var ka=n.print;I.executor_name=I.transpiler_name;var qa={__file__:""};n.main=qa;n.__except__=null;var Q=function(a){a.__kwargtrans__=null;a.constructor=Object;return a};n.__kwargtrans__=Q;n.__globals__=function(a){return W(a,P)?a:P(a)};n.__super__=function(a,b){a=$jscomp.makeIterator(a.__bases__);for(var m=a.next();!m.done;m=a.next())if(m=m.value,b in m)return m[b];
+throw new ja("Superclass method not found");};n.property=function(a,b){b||(b=function(){});return{get:function(){return a(this)},set:function(a){b(this,a)},enumerable:!0}};var O=function(a,b,m){a.hasOwnProperty(b)||Object.defineProperty(a,b,m)};n.__setProperty__=O;n.assert=function(a,b){if(!a)throw Ja(b,Error());};n.__merge__=function(a,b){var m={},p;for(p in a)m[p]=a[p];for(p in b)m[p]=b[p];return m};n.dir=function(a){var b=[],m;for(m in a)b.push(m);b.sort();return b};n.setattr=function(a,b,m){a[b]=
+m};n.getattr=function(a,b){return a[b]};n.hasattr=function(a,b){try{return b in a}catch(m){return!1}};n.delattr=function(a,b){delete a[b]};var ra=function(a,b){return J(b)==P?b.hasOwnProperty(a):b.indexOf?-1<b.indexOf(a):b.hasOwnProperty(a)};n.__in__=ra;var ba=function(a){return a.startswith("__")&&a.endswith("__")||"constructor"==a||a.startswith("py_")};n.__specialattrib__=ba;var N=function(a){if(void 0===a||null===a)return 0;if(a.__len__ instanceof Function)return a.__len__();if(void 0!==a.length)return a.length;
+var b=0,m;for(m in a)ba(m)||b++;return b};n.len=N;n.__t__=h;var aa=function(a){return!!h(a)};aa.__name__="bool";n.bool=aa;var da=function(a){if("inf"==a)return Infinity;if("-inf"==a)return-Infinity;if(isNaN(parseFloat(a))){if(!1===a)return 0;if(!0===a)return 1;throw ca("could not convert string to float: '"+G(a)+"'",Error());}return+a};da.__name__="float";n.float=da;var X=function(a){return da(a)|0};X.__name__="int";n.int=X;var J=function(a){var b=typeof a;if("object"==b)try{return a.__class__}catch(m){return b}else return"boolean"==
+b?aa:"string"==b?G:"number"==b?0==a%1?X:da:null};n.py_typeof=J;var W=function(a,b){function m(a){if(a==b)return!0;for(var e=0;e<a.__bases__.length;e++)if(m(a.__bases__[e],b))return!0;return!1}if(b instanceof Array){for(var p=$jscomp.makeIterator(b),q=p.next();!q.done;q=p.next())if(W(a,q.value))return!0;return!1}try{return"__class__"in a?m(a.__class__):a instanceof b}catch(l){return a=J(a),a==b||a==aa&&b==X}};n.isinstance=W;n.callable=function(a){return"object"==typeof a&&"__call__"in a?!0:"function"===
+typeof a};var U=function(a){try{return a.__repr__()}catch(l){try{return a.__str__()}catch(e){try{if(null==a)return"None";if(a.constructor==Object){var b="{",m=!1,p;for(p in a)if(!ba(p)){var q=p.isnumeric()?p:"'"+p+"'";m?b+=", ":m=!0;b+=q+": "+U(a[p])}return b+"}"}return"boolean"==typeof a?a.toString().capitalize():a.toString()}catch(k){return"<object of type: "+typeof a+">"}}}};n.repr=U;n.chr=function(a){return String.fromCharCode(a)};n.ord=function(a){return a.charCodeAt(0)};n.max=Math.max;n.min=
+Math.min;var sa=function(a,b){if(b){var m=Math.pow(10,b);a*=m}var p=Math.round(a);.5==p-a&&p%2&&--p;b&&(p/=m);return p};n.round=sa;v.prototype.__next__=function(){if(this.index<this.iterable.length)return this.iterable[this.index++];throw Ia(Error());};B.prototype.next=function(){return this.index<this.iterable.py_keys.length?{value:this.index++,done:!1}:{value:void 0,done:!0}};n.py_reversed=function(a){a=a.slice();a.reverse();return a};var fa=function(){for(var a=[].slice.call(arguments),b=0;b<a.length;b++)"string"==
+typeof a[b]?a[b]=a[b].split(""):Array.isArray(a[b])||(a[b]=Array.from(a[b]));return(0==a.length?[]:a.reduce(function(a,b){return a.length<b.length?a:b})).map(function(b,p){return a.map(function(a){return a[p]})})};n.zip=fa;n.range=z;n.any=function(a){a=$jscomp.makeIterator(a);for(var b=a.next();!b.done;b=a.next())if(aa(b.value))return!0;return!1};n.all=function(a){a=$jscomp.makeIterator(a);for(var b=a.next();!b.done;b=a.next())if(!aa(b.value))return!1;return!0};n.sum=function(a){var b=0;a=$jscomp.makeIterator(a);
+for(var m=a.next();!m.done;m=a.next())b+=m.value;return b};n.enumerate=K;n.copy=D;n.deepcopy=L;n.list=x;Array.prototype.__class__=x;x.__name__="list";Array.prototype.__iter__=function(){return new v(this)};Array.prototype.__getslice__=function(a,b,m){0>a&&(a=this.length+a);null==b?b=this.length:0>b?b=this.length+b:b>this.length&&(b=this.length);for(var p=x([]);a<b;a+=m)p.push(this[a]);return p};Array.prototype.__setslice__=function(a,b,m,p){0>a&&(a=this.length+a);null==b?b=this.length:0>b&&(b=this.length+
+b);if(null==m)Array.prototype.splice.apply(this,[a,b-a].concat(p));else for(var q=0;a<b;a+=m)this[a]=p[q++]};Array.prototype.__repr__=function(){if(this.__class__==T&&!this.length)return"set()";for(var a=this.__class__&&this.__class__!=x?this.__class__==r?"(":"{":"[",b=0;b<this.length;b++)b&&(a+=", "),a+=U(this[b]);this.__class__==r&&1==this.length&&(a+=",");return a+=this.__class__&&this.__class__!=x?this.__class__==r?")":"}":"]"};Array.prototype.__str__=Array.prototype.__repr__;Array.prototype.append=
+function(a){this.push(a)};Array.prototype.py_clear=function(){this.length=0};Array.prototype.extend=function(a){this.push.apply(this,a)};Array.prototype.insert=function(a,b){this.splice(a,0,b)};Array.prototype.remove=function(a){a=this.indexOf(a);if(-1==a)throw ca("list.remove(x): x not in list",Error());this.splice(a,1)};Array.prototype.index=function(a){return this.indexOf(a)};Array.prototype.py_pop=function(a){return void 0==a?this.pop():this.splice(a,1)[0]};Array.prototype.py_sort=function(){Ka.apply(null,
+[this].concat([].slice.apply(arguments)))};Array.prototype.__add__=function(a){return x(this.concat(a))};Array.prototype.__mul__=function(a){for(var b=this,m=1;m<a;m++)b=b.concat(this);return b};Array.prototype.__rmul__=Array.prototype.__mul__;n.tuple=r;r.__name__="tuple";n.set=T;T.__name__="set";Array.prototype.__bindexOf__=function(a){a+="";for(var b=0,m=this.length-1;b<=m;){var p=(b+m)/2|0,q=this[p]+"";if(q<a)b=p+1;else if(q>a)m=p-1;else return p}return-1};Array.prototype.add=function(a){-1==this.indexOf(a)&&
+this.push(a)};Array.prototype.discard=function(a){a=this.indexOf(a);-1!=a&&this.splice(a,1)};Array.prototype.isdisjoint=function(a){this.sort();for(var b=0;b<a.length;b++)if(-1!=this.__bindexOf__(a[b]))return!1;return!0};Array.prototype.issuperset=function(a){this.sort();for(var b=0;b<a.length;b++)if(-1==this.__bindexOf__(a[b]))return!1;return!0};Array.prototype.issubset=function(a){return T(a.slice()).issuperset(this)};Array.prototype.union=function(a){for(var b=T(this.slice().sort()),m=0;m<a.length;m++)-1==
+b.__bindexOf__(a[m])&&b.push(a[m]);return b};Array.prototype.intersection=function(a){this.sort();for(var b=T(),m=0;m<a.length;m++)-1!=this.__bindexOf__(a[m])&&b.push(a[m]);return b};Array.prototype.difference=function(a){a=T(a.slice().sort());for(var b=T(),m=0;m<this.length;m++)-1==a.__bindexOf__(this[m])&&b.push(this[m]);return b};Array.prototype.symmetric_difference=function(a){return this.union(a).difference(this.intersection(a))};Array.prototype.py_update=function(){var a=[].concat.apply(this.slice(),
+arguments).sort();this.py_clear();for(var b=0;b<a.length;b++)a[b]!=a[b-1]&&this.push(a[b])};Array.prototype.__eq__=function(a){if(this.length!=a.length)return!1;this.__class__==T&&(this.sort(),a.sort());for(var b=0;b<this.length;b++)if(this[b]!=a[b])return!1;return!0};Array.prototype.__ne__=function(a){return!this.__eq__(a)};Array.prototype.__le__=function(a){return this.issubset(a)};Array.prototype.__ge__=function(a){return this.issuperset(a)};Array.prototype.__lt__=function(a){return this.issubset(a)&&
+!this.issuperset(a)};Array.prototype.__gt__=function(a){return this.issuperset(a)&&!this.issubset(a)};n.bytearray=oa;n.bytes=oa;Uint8Array.prototype.__add__=function(a){var b=new Uint8Array(this.length+a.length);b.set(this);b.set(a,this.length);return b};Uint8Array.prototype.__mul__=function(a){for(var b=new Uint8Array(a*this.length),m=0;m<a;m++)b.set(this,m*this.length);return b};Uint8Array.prototype.__rmul__=Uint8Array.prototype.__mul__;n.str=G;String.prototype.__class__=G;G.__name__="str";String.prototype.__iter__=
+function(){new v(this)};String.prototype.__repr__=function(){return(-1==this.indexOf("'")?"'"+this+"'":'"'+this+'"').py_replace("\t","\\t").py_replace("\n","\\n")};String.prototype.__str__=function(){return this};String.prototype.capitalize=function(){return this.charAt(0).toUpperCase()+this.slice(1)};String.prototype.endswith=function(a){return""==a||this.slice(-a.length)==a};String.prototype.find=function(a,b){return this.indexOf(a,b)};String.prototype.__getslice__=function(a,b,m){0>a&&(a=this.length+
+a);null==b?b=this.length:0>b&&(b=this.length+b);var p="";if(1==m)p=this.substring(a,b);else for(;a<b;a+=m)p=p.concat(this.charAt(a));return p};O(String.prototype,"format",{get:function(){return u(this,function(a){var b=r([].slice.apply(arguments).slice(1)),m=0;return a.replace(/\{(\w*)\}/g,function(a,q){""==q&&(q=m++);if(q==+q)return void 0==b[q]?a:G(b[q]);for(var l=0;l<b.length;l++)if("object"==typeof b[l]&&void 0!=b[l][q])return G(b[l][q]);return a})})},enumerable:!0});String.prototype.isalnum=
+function(){return/^[0-9a-zA-Z]{1,}$/.test(this)};String.prototype.isalpha=function(){return/^[a-zA-Z]{1,}$/.test(this)};String.prototype.isdecimal=function(){return/^[0-9]{1,}$/.test(this)};String.prototype.isdigit=function(){return this.isdecimal()};String.prototype.islower=function(){return/^[a-z]{1,}$/.test(this)};String.prototype.isupper=function(){return/^[A-Z]{1,}$/.test(this)};String.prototype.isspace=function(){return/^[\s]{1,}$/.test(this)};String.prototype.isnumeric=function(){return!isNaN(parseFloat(this))&&
+isFinite(this)};String.prototype.join=function(a){a=Array.from(a);return a.join(this)};String.prototype.lower=function(){return this.toLowerCase()};String.prototype.py_replace=function(a,b,m){return this.split(a,m).join(b)};String.prototype.lstrip=function(){return this.replace(/^\s*/g,"")};String.prototype.rfind=function(a,b){return this.lastIndexOf(a,b)};String.prototype.rsplit=function(a,b){if(void 0==a||null==a){a=/\s+/;var m=this.strip()}else m=this;if(void 0==b||-1==b)return m.split(a);m=m.split(a);
+return b<m.length?(b=m.length-b,[m.slice(0,b).join(a)].concat(m.slice(b))):m};String.prototype.rstrip=function(){return this.replace(/\s*$/g,"")};String.prototype.py_split=function(a,b){if(void 0==a||null==a){a=/\s+/;var m=this.strip()}else m=this;if(void 0==b||-1==b)return m.split(a);m=m.split(a);return b<m.length?m.slice(0,b).concat([m.slice(b).join(a)]):m};String.prototype.startswith=function(a){return 0==this.indexOf(a)};String.prototype.strip=function(){return this.trim()};String.prototype.upper=
+function(){return this.toUpperCase()};String.prototype.__mul__=function(a){for(var b=this,m=1;m<a;m++)b+=this;return b};String.prototype.__rmul__=String.prototype.__mul__;n.dict=P;P.__name__="dict";O(Function.prototype,"__setdoc__",{value:function(a){this.__doc__=a;return this},enumerable:!1});var la=function(a){return"object"==typeof a&&"__neg__"in a?a.__neg__():-a};n.__neg__=la;n.__matmul__=function(a,b){return a.__matmul__(b)};n.pow=function(a,b){return"object"==typeof a&&"__pow__"in a?a.__pow__(b):
+"object"==typeof b&&"__rpow__"in b?b.__rpow__(a):Math.pow(a,b)};n.__jsmod__=function(a,b){return"object"==typeof a&&"__mod__"in a?a.__mod__(b):"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):a%b};n.mod=function(a,b){return"object"==typeof a&&"__mod__"in a?a.__mod__(b):"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):(a%b+b)%b};var Y=function(a,b){return"object"==typeof a&&"__mul__"in a?a.__mul__(b):"object"==typeof b&&"__rmul__"in b?b.__rmul__(a):"string"==typeof a?a.__mul__(b):"string"==typeof b?
+b.__rmul__(a):a*b};n.__mul__=Y;var Z=function(a,b){return"object"==typeof a&&"__truediv__"in a?a.__truediv__(b):"object"==typeof b&&"__rtruediv__"in b?b.__rtruediv__(a):"object"==typeof a&&"__div__"in a?a.__div__(b):"object"==typeof b&&"__rdiv__"in b?b.__rdiv__(a):a/b};n.__truediv__=Z;n.__floordiv__=function(a,b){return"object"==typeof a&&"__floordiv__"in a?a.__floordiv__(b):"object"==typeof b&&"__rfloordiv__"in b?b.__rfloordiv__(a):"object"==typeof a&&"__div__"in a?a.__div__(b):"object"==typeof b&&
+"__rdiv__"in b?b.__rdiv__(a):Math.floor(a/b)};var A=function(a,b){return"object"==typeof a&&"__add__"in a?a.__add__(b):"object"==typeof b&&"__radd__"in b?b.__radd__(a):a+b};n.__add__=A;var S=function(a,b){return"object"==typeof a&&"__sub__"in a?a.__sub__(b):"object"==typeof b&&"__rsub__"in b?b.__rsub__(a):a-b};n.__sub__=S;n.__lshift__=function(a,b){return"object"==typeof a&&"__lshift__"in a?a.__lshift__(b):"object"==typeof b&&"__rlshift__"in b?b.__rlshift__(a):a<<b};n.__rshift__=function(a,b){return"object"==
+typeof a&&"__rshift__"in a?a.__rshift__(b):"object"==typeof b&&"__rrshift__"in b?b.__rrshift__(a):a>>b};n.__or__=function(a,b){return"object"==typeof a&&"__or__"in a?a.__or__(b):"object"==typeof b&&"__ror__"in b?b.__ror__(a):a|b};n.__xor__=function(a,b){return"object"==typeof a&&"__xor__"in a?a.__xor__(b):"object"==typeof b&&"__rxor__"in b?b.__rxor__(a):a^b};n.__and__=function(a,b){return"object"==typeof a&&"__and__"in a?a.__and__(b):"object"==typeof b&&"__rand__"in b?b.__rand__(a):a&b};n.__eq__=
+function(a,b){return"object"==typeof a&&"__eq__"in a?a.__eq__(b):a==b};n.__ne__=function(a,b){return"object"==typeof a&&"__ne__"in a?a.__ne__(b):a!=b};n.__lt__=function(a,b){return"object"==typeof a&&"__lt__"in a?a.__lt__(b):a<b};n.__le__=function(a,b){return"object"==typeof a&&"__le__"in a?a.__le__(b):a<=b};n.__gt__=function(a,b){return"object"==typeof a&&"__gt__"in a?a.__gt__(b):a>b};n.__ge__=function(a,b){return"object"==typeof a&&"__ge__"in a?a.__ge__(b):a>=b};n.__imatmul__=function(a,b){return"__imatmul__"in
+a?a.__imatmul__(b):a.__matmul__(b)};n.ipow=function(a,b){return"object"==typeof a&&"__pow__"in a?a.__ipow__(b):"object"==typeof a&&"__ipow__"in a?a.__pow__(b):"object"==typeof b&&"__rpow__"in b?b.__rpow__(a):Math.pow(a,b)};n.ijsmod__=function(a,b){return"object"==typeof a&&"__imod__"in a?a.__ismod__(b):"object"==typeof a&&"__mod__"in a?a.__mod__(b):"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):a%b};n.imod=function(a,b){return"object"==typeof a&&"__imod__"in a?a.__imod__(b):"object"==typeof a&&
+"__mod__"in a?a.__mod__(b):"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):(a%b+b)%b};n.__imul__=function(a,b){return"object"==typeof a&&"__imul__"in a?a.__imul__(b):"object"==typeof a&&"__mul__"in a?a.__mul__(b):"object"==typeof b&&"__rmul__"in b?b.__rmul__(a):"string"==typeof a?a.__mul__(b):"string"==typeof b?b.__rmul__(a):a*b};n.__idiv__=function(a,b){return"object"==typeof a&&"__idiv__"in a?a.__idiv__(b):"object"==typeof a&&"__div__"in a?a.__div__(b):"object"==typeof b&&"__rdiv__"in b?b.__rdiv__(a):
+a/b};n.__iadd__=function(a,b){return"object"==typeof a&&"__iadd__"in a?a.__iadd__(b):"object"==typeof a&&"__add__"in a?a.__add__(b):"object"==typeof b&&"__radd__"in b?b.__radd__(a):a+b};n.__isub__=function(a,b){return"object"==typeof a&&"__isub__"in a?a.__isub__(b):"object"==typeof a&&"__sub__"in a?a.__sub__(b):"object"==typeof b&&"__rsub__"in b?b.__rsub__(a):a-b};n.__ilshift__=function(a,b){return"object"==typeof a&&"__ilshift__"in a?a.__ilshift__(b):"object"==typeof a&&"__lshift__"in a?a.__lshift__(b):
+"object"==typeof b&&"__rlshift__"in b?b.__rlshift__(a):a<<b};n.__irshift__=function(a,b){return"object"==typeof a&&"__irshift__"in a?a.__irshift__(b):"object"==typeof a&&"__rshift__"in a?a.__rshift__(b):"object"==typeof b&&"__rrshift__"in b?b.__rrshift__(a):a>>b};n.__ior__=function(a,b){return"object"==typeof a&&"__ior__"in a?a.__ior__(b):"object"==typeof a&&"__or__"in a?a.__or__(b):"object"==typeof b&&"__ror__"in b?b.__ror__(a):a|b};n.__ixor__=function(a,b){return"object"==typeof a&&"__ixor__"in
+a?a.__ixor__(b):"object"==typeof a&&"__xor__"in a?a.__xor__(b):"object"==typeof b&&"__rxor__"in b?b.__rxor__(a):a^b};n.__iand__=function(a,b){return"object"==typeof a&&"__iand__"in a?a.__iand__(b):"object"==typeof a&&"__and__"in a?a.__and__(b):"object"==typeof b&&"__rand__"in b?b.__rand__(a):a&b};var ta=function(a,b){return"object"==typeof a&&"__getitem__"in a?a.__getitem__(b):a[b]};n.__getitem__=ta;var ua=function(a,b,m){"object"==typeof a&&"__setitem__"in a?a.__setitem__(b,m):a[b]=m};n.__setitem__=
+ua;var ea=function(a,b,m,p){return"object"==typeof a&&"__getitem__"in a?a.__getitem__([b,m,p]):a.__getslice__(b,m,p)};n.__getslice__=ea;n.__setslice__=function(a,b,m,p,q){"object"==typeof a&&"__setitem__"in a?a.__setitem__([b,m,p],q):a.__setslice__(b,m,p,q)};H(n,"basics",{__all__:{__inited__:!1,__init__:function(a){var b;I.executor_name==I.transpiler_name&&(b=F(n.numscrypt));a.__name__="basics";a.run=function(a){var p=b.zeros(r([4,3]),"int32");a.check("Zeros",p.tolist(),"<br>");p=b.ones(r([4,5]));
+a.check("Ones",p.astype("int32").tolist());p=b.identity(3,"int32");a.check("Identity",p.tolist(),"<br>");p=b.array(x([x([1,1,2,3]),x([4,5,6,7]),x([8,9,10,12])]));a.check("Matrix a",p.tolist(),"<br>");a.check("Transpose of a",p.transpose().tolist(),"<br>");var q=b.array(x([x([2,2,4,6]),x([8,10,12,14]),x([16,18,20,24])])),l=q.transpose();a.check("Matrix b",q.tolist(),"<br>");a.check("Permutation of b",l.tolist(),"<br>");var e=b.array(x([x([1,2,3,4]),x([5,6,7,8]),x([9,10,11,12])]),"int32");a.check("Shape c",
+r(e.shape),"<br>");a.check("Matrix c",e.tolist(),"<br>");var k=e.transpose();a.check("Shape ct",r(k.shape),"<br>");a.check("Transpose of c",k.tolist(),"<br>");var g=b.hsplit(e,2),c=g[0];g=g[1];a.check("Matrix cs0",c.tolist(),"<br>");a.check("Matrix cs1",g.tolist(),"<br>");g=b.hstack(r([g,c]));a.check("Matrix ci",g.tolist(),"<br>");g=b.hsplit(k,3);k=g[0];c=g[1];g=g[2];a.check("Matrix cts0",k.tolist(),"<br>");a.check("Matrix cts1",c.tolist(),"<br>");a.check("Matrix cts2",g.tolist(),"<br>");g=b.hstack(r([g,
+c,k]));a.check("Matrix ci",g.tolist(),"<br>");var d=b.array(x([x([13,14]),x([15,16]),x([17,18]),x([19,20])]),"int32");a.check("Matrix d",d.tolist(),"<br>");k=d.transpose();a.check("Permutation of d",k.tolist(),"<br>");g=b.vsplit(d,4);c=g[0];var w=g[1],y=g[2];g=g[3];a.check("Matrix ds0",c.tolist(),"<br>");a.check("Matrix ds1",w.tolist(),"<br>");a.check("Matrix ds2",y.tolist(),"<br>");a.check("Matrix ds3",g.tolist(),"<br>");g=b.vstack(r([g,y,w,c]));a.check("Matrix di",g.tolist(),"<br>");g=b.vsplit(k,
+2);k=g[0];g=g[1];a.check("Matrix dts0",k.tolist(),"<br>");a.check("Matrix dts1",g.tolist(),"<br>");g=b.vstack(r([g,k]));a.check("Matrix dti",g.tolist(),"<br>");g=b.array(z(10));k=b.array(r([1,2,3,1,2,3,1,2,3,1]));p.__setitem__([1,0],177);c=q.__getitem__([1,2]);w=q.__getitem__([1,r([1,3,1])]);y=q.__getitem__([r([1,2,1]),r([1,3,1])]);var M=q.__getitem__([r([1,2,1]),1]),C=q.__getitem__([1,r([1,3,1])]),m=q.__getitem__([r([0,null,1]),1]),h=q.__getitem__([1,r([1,3,1])]),n=q.__getitem__([1,r([1,3,1])]),
+u=q.__getitem__([1,r([2,3,1])]),v=l.__getitem__([1,r([1,3,1])]),B=l.__getitem__([r([1,2,1]),r([1,3,1])]),D=l.__getitem__([1,r([0,null,1])]),E=l.__getitem__([1,r([1,3,1])]),F=l.__getitem__([r([0,null,1]),1]),G=l.__getitem__([3,r([1,3,1])]),H=l.__getitem__([r([2,4,1]),r([1,3,1])]);l=l.__getitem__([r([2,4,1]),r([2,3,1])]);var I=A(p,q),J=S(p,q),K=Y(p,q);q=Z(p,q);e=e.__matmul__(d);d=A(g,k);var L=ta(d,6);ua(d,6,70);var N=Y(p,3),O=Y(3,p),P=Z(p,3.1234567),Q=Z(3.1234567,p),T=A(p,3),U=A(3,p),V=S(p,3),W=S(3,
+p),X=la(p);a.check("El a [1, 2, 3] alt",p.tolist(),"<br>");a.check("El b [1, 2, 3]",c,"<br>");a.check("Sl b0",w.tolist(),"<br>");a.check("Sl b1",y.tolist(),"<br>");a.check("Sl b2",M.tolist(),"<br>");a.check("Sl b3",C.tolist(),"<br>");a.check("Sl b4",m.tolist(),"<br>");a.check("Sl b5",h.tolist(),"<br>");a.check("Sl b6",n.tolist(),"<br>");a.check("Sl b7",u.tolist(),"<br>");a.check("Sl bp0",v.tolist(),"<br>");a.check("Sl bp1",B.tolist(),"<br>");a.check("Sl bp2",D.tolist(),"<br>");a.check("Sl bp3",E.tolist(),
+"<br>");a.check("Sl bp4",F.tolist(),"<br>");a.check("Sl bp5",G.tolist(),"<br>");a.check("Sl bp6",H.tolist(),"<br>");a.check("Sl bp7",l.tolist(),"<br>");a.check("Matrix sum",I.tolist(),"<br>");a.check("Matrix difference",J.tolist(),"<br>");a.check("Matrix product",K.tolist(),"<br>");a.check("Matrix quotient",q.tolist(),"<br>");a.check("Matrix dotproduct",e.tolist(),"<br>");a.check("Vector",g.tolist(),"<br>");a.check("Vector",k.tolist(),"<br>");a.check("El sum old",L,"<br>");a.check("Vector sum new",
+d.tolist(),"<br>");a.check("mul_a3",N.tolist(),"<br>");a.check("mul_3a",O.tolist(),"<br>");a.check("div_a3",b.round(P,2).tolist(),"<br>");a.check("div_3a",b.round(Q,2).tolist(),"<br>");a.check("add_a3",T.tolist(),"<br>");a.check("add_3a",U.tolist(),"<br>");a.check("sub_a3",V.tolist(),"<br>");a.check("sub_3a",W.tolist(),"<br>");a.check("neg_a",X.tolist(),"<br>");p=t(b.array,b,x([x([A(1,R(0,2)),S(2,R(0,1)),3]),x([4,A(5,R(0,3)),7])]),"complex128");e=t(b.array,b,x([x([6,S(8,R(0,1))]),x([A(9,R(0,3)),10]),
+x([11,S(12,R(0,6))])]),"complex128");q=p.__matmul__(e);a.check("comp_a",p.tolist(),"<br>");a.check("comp_b",e.tolist(),"<br>");a.check("comp_c",q.tolist(),"<br>");p=p.__getitem__([r([0,null,1]),r([0,2,1])]);e=e.__getitem__([r([1,null,1]),r([0,null,1])]);q=Y(p,e);l=Z(p,e);g=A(p,e);k=S(p,e);a.check("comp_a_square",p.tolist(),"<br>");a.check("comp_b_square",e.tolist(),"<br>");a.check("comp_c_square",q.tolist(),"<br>");a.check("comp_d_square",b.round(l,2).tolist(),"<br>");a.check("comp_e_square",g.tolist(),
+"<br>");a.check("comp_f_square",k.tolist(),"<br>");p=t(b.array,b,x([x([1,2,3,4]),x([5,6,7,8]),x([9,10,11,12]),x([13,14,15,16])]));t(a.check,a,"sliceable_a",t(p.tolist,p));p.__getitem__([r([1,null,1]),r([1,null,1])]);t(a.check,a,"slice_a");a=t(p.transpose,p);ea(a,1,null,1)}}}});H(n,"itertools",{__all__:{__inited__:!1,__init__:function(a){var b=function(){function a(a,M){for(;;)switch(b){case 0:w=[].slice.apply(y),d=$jscomp.makeIterator(w),c=d.next();case 1:if(c.done){b=3;break}g=c.value;k=$jscomp.makeIterator(g);
+e=k.next();case 4:if(e.done){b=6;break}l=e.value;b=7;return{value:l,done:!1};case 7:if(void 0===M){b=8;break}b=-1;throw M;case 8:case 5:e=k.next();b=4;break;case 6:case 2:c=d.next();b=1;break;case 3:b=-1;default:return{value:void 0,done:!0}}}var b=0,l,e,k,g,c,d,w,y=arguments,M={next:function(c){return a(c,void 0)},throw:function(c){return a(void 0,c)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();M[Symbol.iterator]=function(){return this};return M};b.from_iterable=
+function(a){function b(b,y){for(;;)switch(l){case 0:w=$jscomp.makeIterator(a),d=w.next();case 1:if(d.done){l=3;break}c=d.value;g=$jscomp.makeIterator(c);k=g.next();case 4:if(k.done){l=6;break}e=k.value;l=7;return{value:e,done:!1};case 7:if(void 0===y){l=8;break}l=-1;throw y;case 8:case 5:k=g.next();l=4;break;case 6:case 2:d=w.next();l=1;break;case 3:l=-1;default:return{value:void 0,done:!0}}}var l=0,e,k,g,c,d,w,y={next:function(a){return b(a,void 0)},throw:function(a){return b(void 0,a)},return:function(a){throw Error("Not yet implemented");
+}};$jscomp.initSymbolIterator();y[Symbol.iterator]=function(){return this};return y};var m=function(){var a=[].slice.apply(arguments);var b=a.length&&a[a.length-1].hasOwnProperty("__kwargtrans__")?a.pop().repeat:1;for(var l=[r([])],e=0;e<b;e++)for(var k=$jscomp.makeIterator(a),g=k.next();!g.done;g=k.next()){g=g.value;var c=[];l=$jscomp.makeIterator(l);for(var d=l.next();!d.done;d=l.next()){d=d.value;for(var w=$jscomp.makeIterator(g),y=w.next();!y.done;y=w.next())c.append(r(d.concat(y.value)))}l=c}return x(l)};
+a.count=function(a,b){function l(k,c){for(;;)switch(e){case 0:void 0==a&&(a=0),void 0==b&&(b=1);case 1:return e=3,{value:a,done:!1};case 3:if(void 0===c){e=4;break}e=-1;throw c;case 4:a+=b;e=1;break;case 2:e=-1;default:return{value:void 0,done:!0}}}var e=0,k={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();k[Symbol.iterator]=function(){return this};return k};a.cycle=function(a){function b(b,
+d){for(;;)switch(l){case 0:c=Array.from(a);case 1:g=$jscomp.makeIterator(c),k=g.next();case 3:if(k.done){l=5;break}e=k.value;l=6;return{value:e,done:!1};case 6:if(void 0===d){l=7;break}l=-1;throw d;case 7:case 4:k=g.next();l=3;break;case 5:l=1;break;case 2:l=-1;default:return{value:void 0,done:!0}}}var l=0,e,k,g,c,d={next:function(a){return b(a,void 0)},throw:function(a){return b(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();d[Symbol.iterator]=function(){return this};
+return d};a.repeat=function(a,b){function l(c,d){for(;;)switch(e){case 0:if("undefined"!=typeof b){e=1;break}case 3:return e=5,{value:a,done:!1};case 5:if(void 0===d){e=6;break}e=-1;throw d;case 6:e=3;break;case 4:e=2;break;case 1:k=0;case 7:if(!(k<b)){e=9;break}e=10;return{value:a,done:!1};case 10:if(void 0===d){e=11;break}e=-1;throw d;case 11:case 8:k++;e=7;break;case 9:case 2:e=-1;default:return{value:void 0,done:!0}}}var e=0,k,g={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,
+a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();g[Symbol.iterator]=function(){return this};return g};a.accumulate=function(a,b){function l(l,C){for(;;)switch(e){case 0:y=!0;if(!b){e=1;break}w=$jscomp.makeIterator(a);g=w.next();case 3:if(g.done){e=5;break}d=g.value;y?(M=d,y=!1):M=b(M,d);e=6;return{value:M,done:!1};case 6:if(void 0===C){e=7;break}e=-1;throw C;case 7:case 4:g=w.next();e=3;break;case 5:e=2;break;case 1:c=$jscomp.makeIterator(a),g=c.next();case 8:if(g.done){e=
+10;break}k=g.value;y?(M=k,y=!1):M+=k;e=11;return{value:M,done:!1};case 11:if(void 0===C){e=12;break}e=-1;throw C;case 12:case 9:g=c.next();e=8;break;case 10:case 2:e=-1;default:return{value:void 0,done:!0}}}var e=0,k,g,c,d,w,y,M,C={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();C[Symbol.iterator]=function(){return this};return C};a.chain=b;a.compress=function(a,b){function l(y,w){for(;;)switch(e){case 0:$jscomp.initSymbol(),
+$jscomp.initSymbolIterator(),d=a[Symbol.iterator].call(a),$jscomp.initSymbol(),$jscomp.initSymbolIterator(),c=b[Symbol.iterator]();case 1:g=d.next();k=c.next();if(!g.done&&!k.done){e=3;break}e=2;break;case 3:if(!k.value){e=5;break}e=6;return{value:g.value,done:!1};case 6:if(void 0===w){e=7;break}e=-1;throw w;case 7:case 5:case 4:e=1;break;case 2:e=-1;default:return{value:void 0,done:!0}}}var e=0,k,g,c,d,w={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,a)},return:function(a){throw Error("Not yet implemented");
+}};$jscomp.initSymbolIterator();w[Symbol.iterator]=function(){return this};return w};a.dropwhile=function(a,b){function l(w,l){for(;;)switch(e){case 0:d=!1,c=$jscomp.makeIterator(b),g=c.next();case 1:if(g.done){e=3;break}k=g.value;if(!d){e=4;break}e=6;return{value:k,done:!1};case 6:if(void 0===l){e=7;break}e=-1;throw l;case 7:e=5;break;case 4:if(a(k)){e=8;break}d=!0;e=9;return{value:k,done:!1};case 9:if(void 0===l){e=10;break}e=-1;throw l;case 10:case 8:case 5:case 2:g=c.next();e=1;break;case 3:e=
+-1;default:return{value:void 0,done:!0}}}var e=0,k,g,c,d,w={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();w[Symbol.iterator]=function(){return this};return w};a.filterfalse=function(a,b){function l(d,y){for(;;)switch(e){case 0:c=$jscomp.makeIterator(b),g=c.next();case 1:if(g.done){e=3;break}k=g.value;if(a(k)){e=4;break}e=5;return{value:k,done:!1};case 5:if(void 0===y){e=6;break}e=-1;
+throw y;case 6:case 4:case 2:g=c.next();e=1;break;case 3:e=-1;default:return{value:void 0,done:!0}}}var e=0,k,g,c,d={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();d[Symbol.iterator]=function(){return this};return d};a.groupby=function(a,b){function l(){function a(a,k){for(;;)switch(e){case 0:case 1:return e=3,{value:d.value,done:!1};case 3:if(void 0===k){e=4;break}e=-1;throw k;case 4:d=
+w.next();if(!d.done){e=5;break}g=!1;e=-1;return{value:void 0,done:!0};case 5:y=b(d.value);if(y==c){e=6;break}c=y;e=-1;return{value:void 0,done:!0};case 6:e=1;break;case 2:e=-1;default:return{value:void 0,done:!0}}}var e=0,y,k={next:function(c){return a(c,void 0)},throw:function(c){return a(void 0,c)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();k[Symbol.iterator]=function(){return this};return k}function e(e,y){for(;;)switch(k){case 0:$jscomp.initSymbol();
+$jscomp.initSymbolIterator();w=a[Symbol.iterator]();d=w.next();if(!d.done){k=1;break}k=-1;return{value:void 0,done:!0};case 1:c=b(d.value),g=!0;case 2:if(!g){k=3;break}k=4;return{value:r([c,l()]),done:!1};case 4:if(void 0===y){k=5;break}k=-1;throw y;case 5:k=2;break;case 3:k=-1;default:return{value:void 0,done:!0}}}var k=0,g,c,d,w,y={next:function(a){return e(a,void 0)},throw:function(a){return e(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();y[Symbol.iterator]=
+function(){return this};return y};a.islice=function(){function a(a,C){for(;;)switch(b){case 0:c=[].slice.apply(M),$jscomp.initSymbol(),$jscomp.initSymbolIterator(),g=c[0][Symbol.iterator](),2==c.length?(w=c[1],y=0,d=1):(y=c[1],w=c[2],d=4==c.length?c[3]:1),k=0;case 1:if(!(k<y)){b=3;break}if(!g.next().done){b=4;break}b=-1;return{value:void 0,done:!0};case 4:case 2:k++;b=1;break;case 3:e=0;case 5:if(!(e<w-y)){b=7;break}l=g.next();if(!l.done){b=8;break}b=-1;return{value:void 0,done:!0};case 8:if(0!=e%
+d){b=9;break}b=10;return{value:l.value,done:!1};case 10:if(void 0===C){b=11;break}b=-1;throw C;case 11:case 9:case 6:e++;b=5;break;case 7:b=-1;default:return{value:void 0,done:!0}}}var b=0,l,e,k,g,c,d,w,y,M=arguments,C={next:function(b){return a(b,void 0)},throw:function(b){return a(void 0,b)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();C[Symbol.iterator]=function(){return this};return C};a.starmap=function(a,b){function l(c,w){for(;;)switch(e){case 0:$jscomp.initSymbol(),
+$jscomp.initSymbolIterator(),g=b[Symbol.iterator]();case 1:k=g.next();if(!k.done){e=3;break}e=-1;return{value:void 0,done:!0};case 3:return e=5,{value:a.apply(null,[].concat($jscomp.arrayFromIterable(k.value))),done:!1};case 5:if(void 0===w){e=6;break}e=-1;throw w;case 6:case 4:e=1;break;case 2:e=-1;default:return{value:void 0,done:!0}}}var e=0,k,g,c={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();
+c[Symbol.iterator]=function(){return this};return c};a.takewhile=function(a,b){function l(d,y){for(;;)switch(e){case 0:c=$jscomp.makeIterator(b),g=c.next();case 1:if(g.done){e=3;break}k=g.value;if(!a(k)){e=4;break}e=6;return{value:k,done:!1};case 6:if(void 0===y){e=7;break}e=-1;throw y;case 7:e=5;break;case 4:return e=-1,{value:void 0,done:!0};case 5:case 2:g=c.next();e=1;break;case 3:e=-1;default:return{value:void 0,done:!0}}}var e=0,k,g,c,d={next:function(a){return l(a,void 0)},throw:function(a){return l(void 0,
+a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();d[Symbol.iterator]=function(){return this};return d};a.tee=function(a,b){void 0==b&&(b=2);var l=[];a=x(a);for(var e=0;e<b;e++)$jscomp.initSymbol(),$jscomp.initSymbolIterator(),l.append(a[Symbol.iterator]());return x(l)};a.product=m;a.permutations=function(a,b){if(void 0==b)try{b=N(a)}catch(k){b=N(x(a))}var l=m(a,Q({repeat:b}));a=[];l=$jscomp.makeIterator(l);for(var e=l.next();!e.done;e=l.next())e=e.value,N(T(e))==
+b&&a.append(e);return x(a)};a.combinations=function(a,b){function l(a,b,c){for(var d=0;d<N(a)-c;d++){var w=b.concat(a.slice(d,d+1));c?l(a.slice(d+1),w,c-1):e.append(r(w))}}a=x(a);var e=[];l(a,a.slice(0,0),b-1);return x(e)};a.combinations_with_replacement=function(a,b){function l(a,b,c){for(var d=0;d<N(a);d++){var w=b.concat(a.slice(d,d+1));c?l(a.slice(d),w,c-1):e.append(r(w))}}a=x(a);var e=[];l(a,a.slice(0,0),b-1);return x(e)}}}});H(n,"math",{__all__:{__inited__:!1,__init__:function(a){var b=Math.PI,
+m=Math.E,h=Math.exp,q=Math.pow,l=Math.sqrt,e=Math.sin,k=Math.cos,g=Math.tan,c=Math.asin,d=Math.acos,w=Math.atan,y=Math.atan2,M=Math.hypot,C=Math.sinh,n=Math.cosh,r=Math.tanh,t=Math.asinh,u=Math.acosh,v=Math.atanh,x=Math.floor,z=Math.ceil,A=Math.trunc,B=isNaN;a.__name__="math";a.acos=d;a.acosh=u;a.asin=c;a.asinh=t;a.atan=w;a.atan2=y;a.atanh=v;a.ceil=z;a.cos=k;a.cosh=n;a.degrees=function(a){return 180*a/Math.PI};a.e=m;a.exp=h;a.expm1=function(a){return Math.exp(a)-1};a.floor=x;a.hypot=M;a.inf=Infinity;
+a.isnan=B;a.log=function(a,b){return void 0===b?Math.log(a):Math.log(a)/Math.log(b)};a.log10=function(a){return Math.log(a)/Math.LN10};a.log1p=function(a){return Math.log(a+1)};a.log2=function(a){return Math.log(a)/Math.LN2};a.nan=NaN;a.pi=b;a.pow=q;a.radians=function(a){return a*Math.PI/180};a.sin=e;a.sinh=C;a.sqrt=l;a.tan=g;a.tanh=r;a.trunc=A}}});H(n,"module_fft",{__all__:{__inited__:!1,__init__:function(a){var b=F(n.math).sin,m=F(n.math).cos,h=F(n.math).pi,q=I.executor_name==I.transpiler_name;
+if(I.executor_name==I.transpiler_name){var l=F(n.numscrypt);var e=F(n.numscrypt.fft)}var k=function(){return new Date};a.__name__="module_fft";a.cos=m;a.fCos=50;a.fSample=4096;a.fSin=30;a.getNow=k;a.pi=h;a.run=function(a){var c,d,w,y,g=A(.001,R(0,.001));a.check("<br>------ 1D ------<br>");a.check("Samples computed: {}<br>".format(8192));a.check("Samples shown: {}<br>".format(102));var C=l.array(function(){for(var a=[],c=$jscomp.makeIterator(function(){for(var a=[],b=0;8192>b;b++)a.append(b/4096);
+return a}()),d=c.next();!d.done;d=c.next())d=d.value,a.append(R(.3+b(60*h*d)+.5*m(100*h*d),0));return a}(),"complex128");t(a.check,a,"Original samples",ea(t(t(l.round,l,A(C,g),3).tolist,t(l.round,l,A(C,g),3)),0,102,1),"<br>");q&&(y=t(k,null));C=t(e.fft,e,C);q&&(w=t(k,null));t(a.check,a,"Frequencies",ea(t(t(l.round,l,A(C,g),3).tolist,t(l.round,l,A(C,g),3)),0,102,1),"<br>");q&&(d=t(k,null));C=t(e.ifft,e,C);q&&(c=t(k,null));t(a.check,a,"Reconstructed samples",ea(t(t(l.round,l,A(C,g),3).tolist,t(l.round,
+l,A(C,g),3)),0,102,1),"<br>");q&&(ka("FFT for {} samples took {} ms".format(8192,w-y)),ka("IFFT for {} samples took {} ms".format(8192,c-d)));a.check("<br>------ 2D ------<br>");C=t(l.zeros,l,r([128,128]),"complex128");C.__setitem__([r([32,96,1]),r([32,96,1])],t(l.ones,l,r([64,64]),"complex128"));t(a.check,a,"Original samples",t(t(l.round,l,A(C,g),3).__getitem__([r([64,68,1]),r([16,112,1])]).tolist,t(l.round,l,A(C,g),3).__getitem__([r([64,68,1]),r([16,112,1])])),"<br>");q&&(y=t(k,null));var n=t(e.fft2,
+e,C);q&&(w=t(k,null));t(a.check,a,"Frequencies",t(t(l.round,l,A(n,g),3).__getitem__([r([64,68,1]),r([16,112,1])]).tolist,t(l.round,l,A(n,g),3).__getitem__([r([64,68,1]),r([16,112,1])])),"<br>");q&&(d=t(k,null));n=t(e.ifft2,e,n);q&&(c=t(k,null));q&&(t(ka,null,t("FFT2 for {} samples took {} ms".format,"FFT2 for {} samples took {} ms",C.size,S(w,y))),t(ka,null,t("IFFT2 for {} samples took {} ms".format,"IFFT2 for {} samples took {} ms",C.size,S(c,d))));t(a.check,a,"Reconstructed samples",t(t(l.round,
+l,A(n,g),3).__getitem__([r([64,68,1]),r([16,112,1])]).tolist,t(l.round,l,A(n,g),3).__getitem__([r([64,68,1]),r([16,112,1])])),"<br>")};a.sin=b;a.tCurrent=function(a){return a/4096};a.tTotal=2;a.transpiled=q}}});H(n,"module_linalg",{__all__:{__inited__:!1,__init__:function(a){if(I.executor_name==I.transpiler_name){var b=F(n.numscrypt);var m=F(n.numscrypt.linalg)}a.__name__="module_linalg";a.run=function(a){var h=b.array(x([x([2.12,-2.11,-1.23]),x([2.31,1.14,3.15]),x([1.13,1.98,2.81])]));a.check("Matrix r",
+b.round(h,2).tolist(),"<br>");var l=m.inv(h);a.check("Matrix ri",b.round(l,2).tolist(),"<br>");var e=h.__matmul__(l);a.check("r @ ri",function(){for(var a=[],b=$jscomp.makeIterator(e.tolist()),c=b.next();!c.done;c=b.next()){var d=c.value;a.append(function(){for(var a=[],b=$jscomp.makeIterator(d),c=b.next();!c.done;c=b.next())a.append(X(sa(c.value)));return a}())}return a}(),"<br>");l=.001;t(a.check,a,"r * r",t(t(b.round,b,A(Y(h,h),l),3).tolist,t(b.round,b,A(Y(h,h),l),3)),"<br>");t(a.check,a,"r / r",
+t(t(b.round,b,A(Z(h,h),l),3).tolist,t(b.round,b,A(Z(h,h),l),3)),"<br>");t(a.check,a,"r + r",t(t(b.round,b,A(A(h,h),l),3).tolist,t(b.round,b,A(A(h,h),l),3)),"<br>");t(a.check,a,"r - r",t(t(b.round,b,A(S(h,h),l),3).tolist,t(b.round,b,A(S(h,h),l),3)),"<br>");h=t(b.array,b,x([x([S(2.12,R(0,3.15)),la(2.11),la(1.23)]),x([2.31,1.14,A(3.15,R(0,2.75))]),x([1.13,S(1.98,R(0,4.33)),2.81])]),"complex128");a.check("Matrix c",b.round(h,2).tolist(),"<br>");l=m.inv(h);a.check("Matrix ci",b.round(l,2).tolist(),"<br>");
+h.__matmul__(l);l=A(.001,R(0,.001));t(a.check,a,"c * c",t(t(b.round,b,A(Y(h,h),l),3).tolist,t(b.round,b,A(Y(h,h),l),3)),"<br>");t(a.check,a,"c / c",t(t(b.round,b,A(Z(h,h),l),3).tolist,t(b.round,b,A(Z(h,h),l),3)),"<br>");t(a.check,a,"c + c",t(t(b.round,b,A(A(h,h),l),3).tolist,t(b.round,b,A(A(h,h),l),3)),"<br>");t(a.check,a,"c - c",t(t(b.round,b,A(S(h,h),l),3).tolist,t(b.round,b,A(S(h,h),l),3)),"<br>")}}}});H(n,"numscrypt",{__all__:{__inited__:!1,__init__:function(a){H({},"",F(n.itertools));var b=P({int32:Int32Array,
+float32:Float32Array,float64:Float64Array}),h=function(a){return ra(a,r(["complex64","complex128"]))},p=function(a){return"complex64"==a?"float32":"complex128"==a?"float64":a},q=function(a,d,e){return!a||h(d)?new (b[p(d)])(e):null},l=E("ndarray",[V],{__module__:"numscrypt",get __init__(){return u(this,function(a,b,e,y,k){if("undefined"==typeof y||null!=y&&y.hasOwnProperty("__kwargtrans__"))y=null;if("undefined"==typeof k||null!=k&&k.hasOwnProperty("__kwargtrans__"))k=null;a.dtype=e;a.ns_complex=h(e);
+a.realbuf=y;a.ns_complex&&(a.imagbuf=k);a.setshape(b)},"__init__")},get setshape(){return u(this,function(a,b){a.shape=b;a.ndim=b.length;a.ns_nrows=b[0];1==a.ndim?a.size=a.ns_nrows:(a.ns_ncols=b[1],a.size=a.ns_nrows*a.ns_ncols)},"setshape")},get astype(){return u(this,function(a,b){b=e(a.shape,b);b.realbuf.set(a.realbuf);a.ns_complex&&b.imagbuf.set(a.imagbuf);return b},"astype")},get tolist(){return u(this,function(a){var b=a.ns_complex?function(){for(var b=[],c=$jscomp.makeIterator(fa(x(a.realbuf),
+x(a.imagbuf))),d=c.next();!d.done;d=c.next()){var e=$jscomp.makeIterator(d.value);d=e.next().value;e=e.next().value;b.append(R(d,e))}return b}():a.realbuf;return 1==a.ndim?x(b):function(){for(var c=[],d=0;d<a.ns_nrows;d++)c.append(function(){for(var c=[],e=0;e<a.ns_ncols;e++)c.append(b[a.ns_ncols*d+e]);return c}());return c}()},"tolist")},get __repr__(){return u(this,function(a){return"array({})".format(U(a.tolist()))},"__repr__")},get __str__(){return u(this,function(a){return 1==a.ndim?G(a.tolist()):
+"[\n\t{}\n]\n".format("\n\t".join(function(){for(var b=[],c=$jscomp.makeIterator(a.tolist()),e=c.next();!e.done;e=c.next())b.append(G(e.value));return b}()))},"__str__")},get reshape(){return u(this,function(a,b){if(1==a.ndim)return r([k(a,a.dtype)]);b=k(a,a.dtype);b.setshape(a.ns_ncols,a.ns_nrows);return b},"reshape")},get transpose(){return u(this,function(a){if(1==a.ndim)var b=k(a,dtype);else{b=e(r([a.ns_ncols,a.ns_nrows]),a.dtype);var c=0;if(a.ns_complex)for(var y=0;y<a.ns_ncols;y++)for(var g=
+0;g<a.ns_nrows;g++){var l=a.ns_ncols*g+y;b.imagbuf[c]=a.imagbuf[l];b.realbuf[c++]=a.realbuf[l]}else for(y=0;y<a.ns_ncols;y++)for(l=y,g=0;g<a.ns_nrows;g++)b.realbuf[c++]=a.realbuf[l],l+=a.ns_ncols}return b},"transpose")},get __getitem__(){return u(this,function(a,b){var c;if(1==a.ndim){if(J(b)==r){null==b[1]?b[1]=a.size:0>b[1]&&(b[1]+=a.size);var d=e(x([(b[1]-b[0])/b[2]]),a.dtype);b=0;if(a.ns_complex){var k=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(a.shape))));for(c=k.next();!c.done;c=
+k.next()){var g=c.value;d.realbuf[b]=a.realbuf[g];d.imagbuf[b++]=a.imagbuf[g]}}else for(k=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(a.shape)))),c=k.next();!c.done;c=k.next())g=c.value,d.realbuf[b++]=a.realbuf[g];return d}return a.ns_complex?R(a.realbuf[b],a.imagbuf[b]):a.realbuf[b]}c=b[0];k=b[1];d=J(c)==r;g=J(k)==r;d&&(null==c[1]?c[1]=a.ns_nrows:0>c[1]&&(c[1]+=a.ns_nrows));g&&(null==k[1]?k[1]=a.ns_ncols:0>k[1]&&(k[1]+=a.ns_ncols));if(d||g){if(d)if(g)if(d=e(r([(b[0][1]-
+b[0][0])/b[0][2],(b[1][1]-b[1][0])/b[1][2]]),a.dtype),b=0,a.ns_complex){var l=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(c))));for(c=l.next();!c.done;c=l.next()){c=c.value;var h=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k))));for(g=h.next();!g.done;g=h.next())g=g.value,g=a.ns_ncols*c+g,d.realbuf[b]=a.realbuf[g],d.imagbuf[b++]=a.imagbuf[g]}}else for(l=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(c)))),c=l.next();!c.done;c=
+l.next())for(c=c.value,h=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k)))),g=h.next();!g.done;g=h.next())g=g.value,d.realbuf[b++]=a.realbuf[a.ns_ncols*c+g];else if(d=e(r([(c[1]-c[0])/c[2]]),a.dtype),b=0,a.ns_complex)for(l=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(c)))),c=l.next();!c.done;c=l.next())c=c.value,g=a.ns_ncols*c+k,d.realbuf[b]=a.realbuf[g],d.imagbuf[b++]=a.imagbuf[g];else for(g=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(c)))),
+c=g.next();!c.done;c=g.next())c=c.value,d.realbuf[b++]=a.realbuf[a.ns_ncols*c+k];else if(d=e(r([(k[1]-k[0])/k[2]]),a.dtype),b=0,a.ns_complex)for(k=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k)))),g=k.next();!g.done;g=k.next())g=g.value,g=a.ns_ncols*c+g,d.realbuf[b]=a.realbuf[g],d.imagbuf[b++]=a.imagbuf[g];else for(k=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k)))),g=k.next();!g.done;g=k.next())g=g.value,d.realbuf[b++]=a.realbuf[a.ns_ncols*c+g];
+return d}return a.ns_complex?(g=a.ns_ncols*b[0]+b[1],R(a.realbuf[g],a.imagbuf[g])):a.realbuf[a.ns_ncols*b[0]+b[1]]},"__getitem__")},get __setitem__(){return u(this,function(a,b,e){var c;if(1==a.ndim){if(J(b)==r){null==b[1]?b[1]=a.size:0>b[1]&&(b[1]+=a.size);b=0;if(a.ns_complex){var d=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(a.shape))));for(c=d.next();!c.done;c=d.next()){var g=c.value;a.realbuf[g]=e.realbuf[b];a.imagbuf[g]=e.imagbuf[b++]}}else for(d=$jscomp.makeIterator(z.apply(null,
+[].concat($jscomp.arrayFromIterable(a.shape)))),c=d.next();!c.done;c=d.next())g=c.value,a.realbuf[g]=e.realbuf[b++];return result}a.ns_complex?(a.realbuf[b]=e.real,a.imagbuf[b]=e.imag):a.realbuf[b]=e}else{var k=b[0];d=b[1];var w=J(k)==r,l=J(d)==r;w&&(null==k[1]?k[1]=a.ns_nrows:0>k[1]&&(k[1]+=a.ns_nrows));l&&(null==d[1]?d[1]=a.ns_ncols:0>d[1]&&(d[1]+=a.ns_ncols));if(w||l)if(w)if(l)if(b=0,a.ns_complex)for(k=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k)))),c=k.next();!c.done;c=
+k.next())for(c=c.value,w=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(d)))),g=w.next();!g.done;g=w.next())g=g.value,g=a.ns_ncols*c+g,a.realbuf[g]=e.realbuf[b],a.imagbuf[g]=e.imagbuf[b++];else for(k=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k)))),w=k.next();!w.done;w=k.next())for(w=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(d)))),l=w.next();!l.done;l=w.next())a.realbuf[a.ns_ncols*c+g]=e.realbuf[b++];else if(b=0,a.ns_complex)for(k=
+$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k)))),c=k.next();!c.done;c=k.next())c=c.value,g=a.ns_ncols*c+d,a.realbuf[g]=e.realbuf[b],a.imagbuf[g]=e.imagbuf[b++];else for(c=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(k)))),w=c.next();!w.done;w=c.next())g=w.value,a.realbuf[a.ns_ncols*g+d]=e[b++];else if(b=0,a.ns_complex)for(d=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(d)))),g=d.next();!g.done;g=d.next())g=g.value,g=a.ns_ncols*
+k+g,a.realbuf[g]=e.realbuf[b],a.imagbuf[g]=e.imagbuf[b++];else for(e=$jscomp.makeIterator(z.apply(null,[].concat($jscomp.arrayFromIterable(d)))),g=e.next();!g.done;g=e.next())g=g.value,result.realbuf[a.ns_ncols*k+g]=a.realbuf[b++];else a.ns_complex?(g=a.ns_ncols*b[0]+b[1],a.realbuf[g]=e.real,a.imagbuf[g]=e.imag):a.realbuf[a.ns_ncols*b[0]+b[1]]=e}},"__setitem__")},get real(){return u(this,function(a){return l(a.shape,p(a.dtype),a.realbuf)},"real")},get imag(){return u(this,function(a){return l(a.shape,
+p(a.dtype),a.imagbuf)},"imag")},get __neg__(){return u(this,function(a){var b=e(a.shape,a.dtype);if(a.ns_complex)for(var c=0;c<a.size;c++)b.realbuf[c]=-a.realbuf[c],b.imagbuf[c]=-a.imagbuf[c];else for(c=0;c<a.size;c++)b.realbuf[c]=-a.realbuf[c];return b},"__neg__")},get __ns_inv__(){return u(this,function(a){var b=e(a.shape,a.dtype);if(a.ns_complex)for(var c=0;c<a.size;c++){var g=a.realbuf[c],k=a.imagbuf[c],l=g*g+k*k;b.realbuf[c]=g/l;b.imagbuf[c]=-k/l}else for(c=0;c<a.size;c++)b.realbuf[c]=1/a.realbuf[c];
+return b},"__ns_inv__")},get __add__(){return u(this,function(a,b){var c=e(a.shape,a.dtype);if(J(b)==l)if(a.ns_complex)for(var d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]+b.realbuf[d],c.imagbuf[d]=a.imagbuf[d]+b.imagbuf[d];else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]+b.realbuf[d];else if(a.ns_complex)for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]+b.real,c.imagbuf[d]=a.imagbuf[d]+b.imag;else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]+b;return c},"__add__")},get __radd__(){return u(this,function(a,
+b){return a.__add__(b)},"__radd__")},get __sub__(){return u(this,function(a,b){var c=e(a.shape,a.dtype);if(J(b)==l)if(a.ns_complex)for(var d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]-b.realbuf[d],c.imagbuf[d]=a.imagbuf[d]-b.imagbuf[d];else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]-b.realbuf[d];else if(a.ns_complex)for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]-b.real,c.imagbuf[d]=a.imagbuf[d]-b.imag;else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]-b;return c},"__sub__")},get __rsub__(){return u(this,
+function(a,b){return a.__neg__().__add__(b)},"__rsub__")},get __mul__(){return u(this,function(a,b){var c=e(a.shape,a.dtype);if(J(b)==l)if(a.ns_complex)for(var d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]*b.realbuf[d]-a.imagbuf[d]*b.imagbuf[d],c.imagbuf[d]=a.realbuf[d]*b.imagbuf[d]+a.imagbuf[d]*b.realbuf[d];else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]*b.realbuf[d];else if(a.ns_complex)for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]*b.real-a.imagbuf[d]*b.imag,c.imagbuf[d]=a.realbuf[d]*b.imag+a.imagbuf[d]*
+b.real;else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]*b;return c},"__mul__")},get __rmul__(){return u(this,function(a,b){return a.__mul__(b)},"__rmul__")},get __div__(){return u(this,function(a,b){var c=e(a.shape,a.dtype);if(J(b)==l)if(a.ns_complex)for(var d=0;d<a.size;d++){var g=b.realbuf[d];var k=b.imagbuf[d];var h=g*g+k*k;c.realbuf[d]=(a.realbuf[d]*g+a.imagbuf[d]*k)/h;c.imagbuf[d]=(a.imagbuf[d]*g-a.realbuf[d]*k)/h}else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]/b.realbuf[d];else if(a.ns_complex)for(g=
+b.real,k=b.imag,h=g*g+k*k,d=0;d<a.size;d++)c.realbuf[d]=(a.realbuf[d]*g+a.imagbuf[d]*k)/h,c.imagbuf[d]=(a.imagbuf[d]*g-a.realbuf[d]*k)/h;else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d]/b;return c},"__div__")},get __rdiv__(){return u(this,function(a,b){return a.__ns_inv__().__mul__(b)},"__rdiv__")},get __matmul__(){return u(this,function(a,b){var c,d=e(r([a.ns_nrows,b.ns_ncols]),a.dtype);if(a.ns_complex)for(var g=c=0;g<a.ns_nrows;g++)for(var k=0;k<b.ns_ncols;k++){d.realbuf[c]=0;d.imagbuf[c]=0;
+var l=a.ns_ncols*g;var h=k;for(var m=0;m<a.ns_ncols;m++)d.realbuf[c]+=a.realbuf[l]*b.realbuf[h]-a.imagbuf[l]*b.imagbuf[h],d.imagbuf[c]+=a.realbuf[l]*b.imagbuf[h]+a.imagbuf[l++]*b.realbuf[h],h+=b.ns_ncols;c++}else for(g=c=0;g<a.ns_nrows;g++)for(k=0;k<b.ns_ncols;k++){d.realbuf[c]=0;l=a.ns_ncols*g;h=k;for(m=0;m<a.ns_ncols;m++)d.realbuf[c]+=a.realbuf[l++]*b.realbuf[h],h+=b.ns_ncols;c++}return d},"__matmul__")}}),e=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";
+a=l(a,b);a.realbuf=q(!1,b,a.size);a.imagbuf=q(!0,b,a.size);return a},k=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";if(Array.isArray(a))if(N(a))if(Array.isArray(a[0])){b=e(r([a.length,a[0].length]),b);var c=0;if(b.ns_complex)for(var d=0;d<b.ns_nrows;d++)for(var g=0;g<b.ns_ncols;g++){var k=R(a[d][g]);b.realbuf[c]=k.real;b.imagbuf[c++]=k.imag}else for(d=0;d<b.ns_nrows;d++)for(g=0;g<b.ns_ncols;g++)b.realbuf[c++]=a[d][g]}else if(b=e(r([a.length]),b),
+b.ns_complex)for(c=0;c<b.size;c++)k=R(a[c]),b.realbuf[c]=k.real,b.imagbuf[c]=k.imag;else for(c=0;c<b.size;c++)b.realbuf[c]=a[c];else b=e(r([0]),b);else b=e(a.shape,b),b.realbuf.set(a.realbuf),a.ns_complex&&b.imagbuf.set(a.imagbuf);return b},g=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";a=e(a,b);if(a.ns_complex)for(b=0;b<a.size;b++)a.realbuf[b]=0,a.imagbuf[b]=0;else for(b=0;b<a.size;b++)a.realbuf[b]=0;return a};a.__name__="numscrypt";a.array=k;a.copy=
+function(a){return k(a,a.dtype)};a.empty=e;a.hsplit=function(a,b){for(var c,d,g=[],k=0;k<b;k++)g.append(e(r([a.ns_nrows,a.ns_ncols/b]),a.dtype));b=0;if(a.ns_complex)for(k=0;k<a.ns_nrows;k++){var l=$jscomp.makeIterator(g);for(c=l.next();!c.done;c=l.next()){d=c.value;c=d.ns_ncols*k;for(var h=0;h<d.ns_ncols;h++)d.realbuf[c]=a.realbuf[b],d.imagbuf[c++]=a.imagbuf[b++]}}else for(k=0;k<a.ns_nrows;k++)for(l=$jscomp.makeIterator(g),c=l.next();!c.done;c=l.next())for(d=c.value,c=d.ns_ncols*k,h=0;h<d.ns_ncols;h++)d.realbuf[c++]=
+a.realbuf[b++];return g};a.hstack=function(a){var b,c=0,g=$jscomp.makeIterator(a);for(b=g.next();!b.done;b=g.next())b=b.value,c+=b.ns_ncols;c=e(r([a[0].ns_nrows,c]),a[0].dtype);g=0;if(c.ns_complex)for(var k=0;k<c.ns_nrows;k++){var l=$jscomp.makeIterator(a);for(b=l.next();!b.done;b=l.next()){b=b.value;var h=b.ns_ncols*k;for(var m=0;m<b.ns_ncols;m++)c.realbuf[g]=b.realbuf[h],c.imagbuf[g++]=b.imagbuf[h++]}}else for(k=0;k<c.ns_nrows;k++)for(l=$jscomp.makeIterator(a),b=l.next();!b.done;b=l.next())for(b=
+b.value,h=b.ns_ncols*k,m=0;m<b.ns_ncols;m++)c.realbuf[g++]=b.realbuf[h++];return c};a.identity=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";b=g(r([a,a]),b);for(var c=0,d=a+1,e=0;e<a;e++)b.realbuf[c]=1,c+=d;return b};a.ndarray=l;a.ns_buffertype=p;a.ns_complex=h;a.ns_complextype=function(a){return"float32"==a?"complex64":"float64"==a?"complex128":null};a.ns_createbuf=q;a.ns_ctors=b;a.ones=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=
+"float64";a=e(a,b);if(a.ns_complex)for(b=0;b<a.size;b++)a.realbuf[b]=1,a.imagbuf[b]=0;else for(b=0;b<a.size;b++)a.realbuf[b]=1;return a};a.round=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=0;var c=e(a.shape,a.dtype);if(a.ns_complex)for(var d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d].toFixed(b),c.imagbuf[d]=a.imagbuf[d].toFixed(b);else for(d=0;d<a.size;d++)c.realbuf[d]=a.realbuf[d].toFixed(b);return c};a.vsplit=function(a,b){var c,d=[];for(c=0;c<b;c++)d.append(e(r([a.ns_nrows/
+b,a.ns_ncols]),k.dtype));b=0;if(a.ns_complex){var g=$jscomp.makeIterator(d);for(c=g.next();!c.done;c=g.next()){c=c.value;for(var l=0;l<c.size;l++)c.realbuf[l]=a.realbuf[b],c.imagbuf[l]=a.imagbuf[b++]}}else for(g=$jscomp.makeIterator(d),c=g.next();!c.done;c=g.next())for(c=c.value,l=0;l<c.size;l++)c.realbuf[l]=a.realbuf[b++];return d};a.vstack=function(a){var b,c=0,g=$jscomp.makeIterator(a);for(b=g.next();!b.done;b=g.next())b=b.value,c+=b.ns_nrows;c=e(r([c,a[0].ns_ncols]),a[0].dtype);g=0;if(c.ns_complex)for(a=
+$jscomp.makeIterator(a),b=a.next();!b.done;b=a.next()){b=b.value;for(var k=0;k<b.size;k++)c.realbuf[g]=b.realbuf[k],c.imagbuf[g++]=b.imagbuf[k]}else for(a=$jscomp.makeIterator(a),b=a.next();!b.done;b=a.next())for(b=b.value,k=0;k<b.size;k++)c.realbuf[g++]=b.realbuf[k];return c};a.zeros=g}}});H(n,"numscrypt.fft",{__all__:{__inited__:!1,__init__:function(a){function b(a){this.n=a;this.levels=-1;for(var b=0;32>b;b++)1<<b==a&&(this.levels=b);if(-1==this.levels)throw"Length is not a power of 2";this.cosTable=
+Array(a/2);this.sinTable=Array(a/2);for(b=0;b<a/2;b++)this.cosTable[b]=Math.cos(2*Math.PI*b/a),this.sinTable[b]=Math.sin(2*Math.PI*b/a);this.forward=function(a,b){for(var c,d=this.n,e=0;e<d;e++){c=e;for(var g=0,k=0;k<this.levels;k++)g=g<<1|c&1,c>>>=1;c=g;c>e&&(g=a[e],a[e]=a[c],a[c]=g,g=b[e],b[e]=b[c],b[c]=g)}for(g=2;g<=d;g*=2){k=g/2;var l=d/g;for(e=0;e<d;e+=g){c=e;for(var h=0;c<e+k;c++,h+=l){var m=a[c+k]*this.cosTable[h]+b[c+k]*this.sinTable[h],n=-a[c+k]*this.sinTable[h]+b[c+k]*this.cosTable[h];a[c+
+k]=a[c]-m;b[c+k]=b[c]-n;a[c]+=m;b[c]+=n}}}};this.inverse=function(a,b){this.forward(b,a)}}var h=F(n.numscrypt),p=function(a,e){if("undefined"==typeof e||null!=e&&e.hasOwnProperty("__kwargtrans__"))e=null;e=e?e:new b(a.size);a=h.copy(a);e.forward(a.real().realbuf,a.imag().realbuf);return a},q=function(a,e){if("undefined"==typeof e||null!=e&&e.hasOwnProperty("__kwargtrans__"))e=null;e=e?e:new b(a.size);var k=a.real().__div__(a.size),g=a.imag().__div__(a.size);e.inverse(k.realbuf,g.realbuf);return h.ndarray(k.shape,
+a.dtype,k.realbuf,g.realbuf)};a.__name__="numscrypt.fft";a.fft=p;a.fft2=function(a,e){if("undefined"==typeof e||null!=e&&e.hasOwnProperty("__kwargtrans__"))e=null;if(a.ns_nrows!=a.ns_ncols)throw"Matrix isn't square";e=e?e:new b(a.ns_nrows);for(var k=h.empty(a.shape,a.dtype),g=0;g<a.ns_nrows;g++)k.__setitem__([g,r([0,null,1])],t(p,null,a.__getitem__([g,r([0,null,1])]),e));for(g=0;g<a.ns_ncols;g++)k.__setitem__([r([0,null,1]),g],t(p,null,k.__getitem__([r([0,null,1]),g]),e));return k};a.ifft=q;a.ifft2=
+function(a,e){if("undefined"==typeof e||null!=e&&e.hasOwnProperty("__kwargtrans__"))e=null;if(a.ns_nrows!=a.ns_ncols)throw"Matrix isn't square";e=e?e:new b(a.ns_nrows);for(var k=h.empty(a.shape,a.dtype),g=0;g<a.ns_nrows;g++)k.__setitem__([g,r([0,null,1])],t(q,null,a.__getitem__([g,r([0,null,1])]),e));for(g=0;g<a.ns_ncols;g++)k.__setitem__([r([0,null,1]),g],t(q,null,k.__getitem__([r([0,null,1]),g]),e));return k}}}});H(n,"numscrypt.linalg",{__all__:{__inited__:!1,__init__:function(a){var b=F(n.numscrypt),
+h=function(a){a=b.hstack(r([a,b.identity(a.shape[0],a.dtype)]));var h=a.realbuf,e=a.shape,k=e[0];e=e[1];for(var g=0;g<k;g++){if(!h[g*e+g])for(var c=g+1;c<k;c++)if(h[c*e+g]){for(var d=0;d<e;d++){var m=h[c*e+d];h[c*e+d]=a[g*e+d];h[g*e+d]=m}break}c=h[g*e+g];for(d=g;d<e;d++)h[g*e+d]/=c;for(c=0;c<k;c++)if(c!=g)for(m=h[c*e+g],d=0;d<e;d++)h[c*e+d]-=m*h[g*e+d]}return b.hsplit(a,2)[1]},p=function(a){a=b.hstack(r([a,b.identity(a.shape[0],a.dtype)]));var h=a.realbuf,e=a.imagbuf,k=a.shape,g=k[0];k=k[1];for(var c=
+0;c<g;c++){var d=c*k+c;if(!h[d]&&!e[d])for(var m=c+1;m<g;m++){var n=m*k+c;if(h[n]||e[n]){for(n=0;n<k;n++){var p=m*k+n;var q=c*k+n;var t=h[p];h[p]=h[q];h[q]=t;t=e[isource_flat];e[p]=e[q];e[q]=t}break}}m=h[d];q=e[d];t=m*m+q*q;for(n=c;n<k;n++){var u=c*k+n;d=h[u];p=e[u];h[u]=(d*m+p*q)/t;e[u]=(p*m-d*q)/t}for(m=0;m<g;m++)if(m!=c)for(n=m*k+c,t=h[n],u=e[n],n=0;n<k;n++)q=m*k+n,p=c*k+n,d=h[p],p=e[p],h[q]-=t*d-u*p,e[q]-=t*p+u*d}return b.hsplit(a,2)[1]};a.__name__="numscrypt.linalg";a.cinv=p;a.inv=function(a){return a.ns_complex?
+p(a):h(a)};a.rinv=h}}});H(n,"org.transcrypt.autotester",{__all__:{__inited__:!1,__init__:function(a){var b=F(n.org.transcrypt.autotester.html).HTMLGenerator,h=F(n.org.transcrypt.autotester.html).DataConverter,p=F(n.org.transcrypt.autotester.html).JSTesterUI;H({},"",F(n.itertools));var q=function(a){if(I.executor_name==I.transpiler_name){var b=null,e=Error();e.stack?b=e.stack:console.log("MAJOR ISSUE: Browser Error lacks Stack");b=b.toString().split(/\n\r|\n/g);if(null===b||2>N(b))return console.log("Failed to Split Stack"),
+"UNKNOWN:???";if(a=/([^(]*)\(?([^:]*:)\/{2,3}([^:/]*:?)([^:]*):(\d+):(\d+)/.exec(b[2*a+1]))return b=a[4].py_split("/"),b=b[N(b)-1],"{}:{}".format(b,a[5]);console.log("Failed to Match Frame");return"UNKNOWN:???"}},l=E("AutoTester",[V],{__module__:"org.transcrypt.autotester",get __init__(){return u(this,function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=x([]);a.symbols=b;a._currTestlet="UNKNOWN";a.testDict=P({});a.refDict=P({});a.ui=I.executor_name==I.transpiler_name?
+p():null},"__init__")},get sortedRepr(){return u(this,function(a,b){var e=function(a){if(J(a)==G)try{return X(a)}catch(d){try{return da(a)}catch(w){return a}}else return a};return J(b)==P?"{"+", ".join(function(){for(var a=[],d=$jscomp.makeIterator(K(na(function(){for(var a=[],c=$jscomp.makeIterator(b.py_keys()),d=c.next();!d.done;d=c.next())a.append(e(d.value));return a}(),Q({key:function(a){return G(a)}})))),g=d.next();!g.done;g=d.next())g=$jscomp.makeIterator(g.value),g.next(),g=g.next().value,
+a.append("{}: {}".format(U(g),U(b[g])));return a}())+"}":J(b)==T?N(b)?"{"+", ".join(na(function(){for(var a=[],d=$jscomp.makeIterator(x(b)),e=d.next();!e.done;e=d.next())a.append(G(e.value));return a}()))+"}":U(b):J(b)==z?U(x(b)):U(b)},"sortedRepr")},get check(){return u(this,function(a){var b=2;if(arguments.length){var e=arguments.length-1;if(arguments[e]&&arguments[e].hasOwnProperty("__kwargtrans__")){var c=arguments[e--],d;for(d in c)switch(d){case "self":a=c[d];break;case "ancestor":b=c[d]}}var h=
+r([].slice.apply(arguments).slice(1,e+1))}else h=r();b=q(b);e=" ".join(function(){for(var b=[],c=$jscomp.makeIterator(h),d=c.next();!d.done;d=c.next())b.append(a.sortedRepr(d.value));return b}());I.executor_name==I.transpiler_name?a.testDict[a._currTestlet].append(r([b,e])):a.refDict[a._currTestlet].append(r([b,e]))},"check")},get expectException(){return u(this,function(a,b){try{return b(),"no exception"}catch(g){if(W(g,ja))return"exception";throw g;}},"expectException")},get throwToError(){return u(this,
+function(a,b){try{return b()}catch(g){if(W(g,ja))return r([null,"!!!{}".format(G(g))]);throw g;}},"throwToError")},get checkEval(){return u(this,function(a,b){b=a.throwToError(b);a.check(b,Q({ancestor:3}))},"checkEval")},get checkPad(){return u(this,function(a,b,g){for(var c=0;c<g;c++)a.check(b)},"checkPad")},get _getTotalErrorCnt(){return u(this,function(a,b,g){a=0;g=$jscomp.makeIterator(K(g));for(var c=g.next();!c.done;c=g.next()){var d=$jscomp.makeIterator(c.value);c=d.next().value;d=$jscomp.makeIterator(d.next().value);
+d.next();d=d.next().value;try{b[c][1]!=d&&a++}catch(w){a++}}return a},"_getTotalErrorCnt")},get compare(){return u(this,function(a){var b=h();a.refDict=b.getPythonResults();b=0;var e=na(a.refDict.py_keys());e=$jscomp.makeIterator(e);for(var c=e.next();!c.done;c=e.next()){c=c.value;var d=a.refDict[c];try{var l=a.testDict[c];if(null===l){var m=ha("No Test Data Module: {}".format(c));m.__cause__=null;throw m;}}catch(ma){if(W(ma,ha)){a.ui.appendSeqRowName(c,N(d));for(var n=$jscomp.makeIterator(K(d)),
+p=n.next();!p.done;p=n.next()){p=$jscomp.makeIterator(p.value);p.next();p=$jscomp.makeIterator(p.next().value);d=p.next().value;var q=p.next().value;a.ui.appendTableResult(c,null,null,d,q,!1)}continue}else throw ma;}n=a._getTotalErrorCnt(l,d);p=0==n;a.ui.appendSeqRowName(c,n);var r=$jscomp.makeIterator(K(d));for(d=r.next();!d.done;d=r.next()){d=$jscomp.makeIterator(d.value);var t=d.next().value;q=$jscomp.makeIterator(d.next().value);d=q.next().value;q=q.next().value;try{var u=l[t];var v=u[0];var x=
+u[1]}catch(ma){x=v=null}a.ui.appendTableResult(c,v,x,d,q,p)}b+=n}a.ui.setOutputStatus(0==b)},"compare")},get _cleanName(){return u(this,function(a,b){a=b;b=x("~!@$%^&*()+=,./';:\"?><[]\\{}|`# ".split(""));b=$jscomp.makeIterator(b);for(var e=b.next();!e.done;e=b.next())a=a.py_replace(e.value,"_");return a},"_cleanName")},get run(){return u(this,function(a,b,g){g=a._cleanName(g);a._currTestlet=g;I.executor_name==I.transpiler_name?a.testDict[a._currTestlet]=x([]):a.refDict[a._currTestlet]=x([]);try{b.run(a)}catch(c){if(W(c,
+ja))if(b=c,null!==a.ui)a.ui.setOutputStatus(!1),a.ui.showException(g,b);else throw c.__cause__=null,c;else throw c;}},"run")},get done(){return u(this,function(a){if(I.executor_name==I.transpiler_name)a.compare();else{var e=qa.__file__.__getslice__(0,-3,1).py_replace("\\","/").rsplit("/",1)[-1];e=b(e);for(var g=$jscomp.makeIterator(r([!1,!0])),c=g.next();!c.done;c=g.next())e.generate_html(a.refDict,c.value)}},"done")}});a.AutoTester=l;a.DataConverter=h;a.HTMLGenerator=b;a.JSTesterUI=p;a.__name__=
+"org.transcrypt.autotester";a.getFileLocation=q}}});H(n,"org.transcrypt.autotester.html",{__all__:{__inited__:!1,__init__:function(a){var b=E("HTMLGenerator",[V],{__module__:"org.transcrypt.autotester.html",get __init__(){return u(this,function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=null;a._fnameBase=b},"__init__")},get generate_html(){return u(this,function(a,b,g){if("undefined"==typeof g||null!=g&&g.hasOwnProperty("__kwargtrans__"))g=!1;if(null===a._fnameBase)throw a=
+ca("Filename Base must be defined to generate"),a.__cause__=null,a;var c=g?".min":"";g=c.join(x([a._fnameBase,".html"]));c=c.join(x([a._fnameBase,".js"]));c="{}/{}".format(I.target_subdir,c);f=open(g,"w");f.write("<html><head>");a._writeCSS(f);f.write("</head><body>");a._writeStatusHeaderTemplate(f);h().writeHiddenResults(f,b);a._writeTableArea(f);f.write('<script src="{}">\x3c/script>\n\n'.format(c));f.write("</body></html>");f.close()},"generate_html")},get _writeCSS(){return u(this,function(a,
+b){b.write("\n\t\t<style>\n\t\t  body {\n\t\t    max-width: 100%;\n\t\t  }\n\t\t  .faultrow > td {\n\t\t     background-color: LightCoral;\n\t\t  }\n\t\t  #resulttable {\n\t\t    border-collapse: collapse;\n\t\t    width: 100%;\n\t\t    table-layout: fixed;\n\t\t  }\n\t\t  #resulttable th, #resulttable td {\n\t\t    border: 1px solid grey;\n\t\t  }\n\t\t  .testletheader > td {\n\t\t    background-color: LightSkyBlue;\n\t\t  }\n\t\t  .header-pos {\n\t\t    width: 20%;\n\t\t  }\n\t\t  .header-val {\n\t\t    width: 30%;\n\t\t  }\n\t\t  .py-pos,.trans-pos {\n\t\t    width: 20%;\n\t\t    overflow: hidden;\n\t\t  }\n\t\t  .py-val, .trans-val {\n\t\t    width: 30%;\n\t\t    overflow-x: auto;\n\t\t  }\n\t\t  .exc-header {\n\t      color: red;\n\t\t  }\n\t\t  .collapsed {\n\t\t    display: None;\n\t\t  }\n\t\t</style>\n\t\t")},
+"_writeCSS")},get _writeStatusHeaderTemplate(){return u(this,function(a,b){b.write("<b>Status:</b>\n");b.write('<div id="{}"></div><br><br>\n\n'.format("message"))},"_writeStatusHeaderTemplate")},get _writeTableArea(){return u(this,function(a,b){b.write('<div id="{}"></div>'.format("exc-area"));b.write('<div id="{}">'.format("results"));b.write('<div> <a id="{}" href="#"> Collapse All</a> <a id="{}" href="#">Expand All</a></div>'.format("force-collapse","force-expand"));b.write('<table id="{}"><thead><tr> <th colspan="2"> CPython </th> <th colspan="2"> Transcrypt </th> </tr>'.format("resulttable"));
+b.write('<tr> <th class="header-pos"> Location </th> <th class="header-val"> Value </th> <th class="header-val"> Value </th> <th class="header-pos"> Location </th> </tr></thead><tbody></tbody>');b.write("</table>");b.write("</div>")},"_writeTableArea")}}),h=E("DataConverter",[V],{__module__:"org.transcrypt.autotester.html",get writeHiddenResults(){return u(this,function(a,b,g){b.write('<div id="{}" style="display: None">'.format("python"));a=$jscomp.makeIterator(g.py_keys());for(var c=a.next();!c.done;c=
+a.next()){var d=c.value;c=" | ".join(function(){for(var a=[],b=$jscomp.makeIterator(g[d]),c=b.next();!c.done;c=b.next())a.append(c.value[1]);return a}());var e=" | ".join(function(){for(var a=[],b=$jscomp.makeIterator(g[d]),c=b.next();!c.done;c=b.next())a.append(c.value[0]);return a}());b.write('<div id="{}">\n'.format(d));b.write('<div id="{}">{}</div>\n\n'.format("pyresults",c));b.write('<div id="{}">{}</div>\n'.format("pypos",e));b.write("</div>\n")}b.write("</div></div>\n")},"writeHiddenResults")},
+get getPythonResults(){return u(this,function(a){var b=document.getElementById("python"),e=P({});b=$jscomp.makeIterator(b.children);for(var c=b.next();!c.done;c=b.next()){var d=c.value;c=d.getAttribute("id");d=a._extractPosResult(d);e[c]=fa(d[0],d[1])}return e},"getPythonResults")},get _extractPosResult(){return u(this,function(a,b){var e;a=e=null;b=$jscomp.makeIterator(b.children);for(var c=b.next();!c.done;c=b.next()){c=c.value;var d=c.getAttribute("id");"pyresults"==d?e=c.innerHTML.py_split(" | "):
+"pypos"==d&&(a=c.innerHTML.py_split(" | "))}return r([a,e])},"_extractPosResult")}}),n=function(a){return"mod-"+a},q=E("JSTesterUI",[V],{__module__:"org.transcrypt.autotester.html",get __init__(){return u(this,function(a){a.expander=l()},"__init__")},get setOutputStatus(){return u(this,function(a,b){b?document.getElementById("message").innerHTML='<div style="color: {}">Test succeeded</div>'.format("green"):document.getElementById("message").innerHTML='<div style="color: {}"><b>Test failed</b></div>'.format("red")},
+"setOutputStatus")},get appendSeqRowName(){return u(this,function(a,b,g){var c=document.getElementById("resulttable").insertRow(-1);c.id=b;c.classList.add("testletheader");a.expander.setupCollapseableHeader(c,0==g);a=c.insertCell(0);a.innerHTML=b+" | Errors = "+G(g);a.colSpan=4;a.style.textAlign="center"},"appendSeqRowName")},get appendTableResult(){return u(this,function(a,b,g,c,d,h,l){if("undefined"==typeof l||null!=l&&l.hasOwnProperty("__kwargtrans__"))l=!1;var e=n(b);b=document.getElementById("resulttable").insertRow(-1);
+b.classList.add(e);c!=h?(b.classList.add("faultrow"),d="!!!"+d):a.expander.setCollapsed(b,l);a=b.insertCell(0);a.innerHTML=d;a.classList.add("py-pos");d=b.insertCell(1);d.innerHTML=h;d.classList.add("py-val");h=b.insertCell(2);null!==c&&(h.innerHTML=c);h.classList.add("trans-val");c=b.insertCell(3);null!==g&&(c.innerHTML=g);c.classList.add("trans-pos")},"appendTableResult")},get showException(){return u(this,function(a,b,g){a=document.getElementById("exc-area");var c=document.createElement("H2");
+c.classList.add("exc-header");c.innerHTML="Exception Thrown in JS Runtime";a.appendChild(c);c=document.createElement("p");c.innerHTML="Exception in {}: {}".format(b,G(g));a.appendChild(c);document.createElement("p").innerHTML=null!==g.stack?G(g.stack):"No Stack Trace Available!"},"showException")}}),l=E("TestModuleExpander",[V],{__module__:"org.transcrypt.autotester.html",get __init__(){return u(this,function(a){a.collapsedClass="collapsed";a.modCollapseClass="mod-collapsed";a._expandCollapseAllFuncs()},
+"__init__")},get setCollapsed(){return u(this,function(a,b,g){g?b.classList.add(a.collapsedClass):b.classList.remove(a.collapsedClass)},"setCollapsed")},get setupCollapseableHeader(){return u(this,function(a,b,g){if("undefined"==typeof g||null!=g&&g.hasOwnProperty("__kwargtrans__"))g=!1;g&&b.classList.add(a.modCollapseClass);b.onclick=function(b){b=b.target.parentElement;var c=!b.classList.contains(a.modCollapseClass);a.collapseModule(b,c)}},"setupCollapseableHeader")},get collapseModule(){return u(this,
+function(a,b,g){var c=b.id,d=document.getElementById("resulttable"),e=n(c);c=pa(function(a){return a.classList.contains(e)},d.tHead.children);c=$jscomp.makeIterator(c);for(d=c.next();!d.done;d=c.next())a.setCollapsed(d.value,g);g?b.classList.add(a.modCollapseClass):b.classList.remove(a.modCollapseClass)},"collapseModule")},get _expandCollapseAllFuncs(){return u(this,function(a){var b=function(b,c){b=document.getElementById("resulttable");b=pa(function(a){return a.classList.contains("testletheader")},
+b.tHead.children);b=$jscomp.makeIterator(b);for(var d=b.next();!d.done;d=b.next())a.collapseModule(d.value,c)};document.getElementById("force-collapse").onclick=function(a){a.preventDefault();b(a,!0);return!1};document.getElementById("force-expand").onclick=function(a){a.preventDefault();b(a,!1);return!1}},"_expandCollapseAllFuncs")}});a.DataConverter=h;a.HTMLGenerator=b;a.JSTesterUI=q;a.TestModuleExpander=l;a.__name__="org.transcrypt.autotester.html";a.errorColor="red";a.excAreaId="exc-area";a.excHeaderClass=
+"exc-header";a.faultRowClass="faultrow";a.forceCollapseId="force-collapse";a.forceExpandId="force-expand";a.getRowClsName=n;a.highlightColor="yellow";a.messageDivId="message";a.okColor="green";a.pyPosClass="py-pos";a.pyValClass="py-val";a.refPosDivId="pypos";a.refResultDivId="pyresults";a.referenceDivId="python";a.resultsDivId="results";a.tableId="resulttable";a.testDivId="transcrypt";a.testletHeaderClass="testletheader";a.testletNameColor="blue";a.transPosClass="trans-pos";a.transValClass="trans-val"}}});
+(function(){var a={},b={},h={},p={};H(p,"transcrypt.autotester",F(n.org.transcrypt.autotester));H(a,"",F(n.basics));H(h,"",F(n.module_linalg));H(b,"",F(n.module_fft));p=p.transcrypt.autotester.AutoTester();p.run(a,"basics");p.run(h,"module_linalg");p.run(b,"module_fft");p.done();n.__name__="__main__";n.autoTester=p})();return n}window.autotest=autotest();
diff --git a/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.mod.js b/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.mod.js
new file mode 100644
index 0000000..c9d01f7
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/__javascript__/autotest.mod.js
@@ -0,0 +1,26 @@
+	(function () {
+		var basics = {};
+		var module_fft = {};
+		var module_linalg = {};
+		var org = {};
+		var __name__ = '__main__';
+		__nest__ (org, 'transcrypt.autotester', __init__ (__world__.org.transcrypt.autotester));
+		__nest__ (basics, '', __init__ (__world__.basics));
+		__nest__ (module_linalg, '', __init__ (__world__.module_linalg));
+		__nest__ (module_fft, '', __init__ (__world__.module_fft));
+		var autoTester = org.transcrypt.autotester.AutoTester ();
+		autoTester.run (basics, 'basics');
+		autoTester.run (module_linalg, 'module_linalg');
+		autoTester.run (module_fft, 'module_fft');
+		autoTester.done ();
+		__pragma__ ('<use>' +
+			'basics' +
+			'module_fft' +
+			'module_linalg' +
+			'org.transcrypt.autotester' +
+		'</use>')
+		__pragma__ ('<all>')
+			__all__.__name__ = __name__;
+			__all__.autoTester = autoTester;
+		__pragma__ ('</all>')
+	}) ();
diff --git a/numscrypt/development/automated_tests/ndarray/autotest.html b/numscrypt/development/automated_tests/ndarray/autotest.html
new file mode 100644
index 0000000..11e8f27
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/autotest.html
@@ -0,0 +1,62 @@
+<html><head>
+		<style>
+		  body {
+		    max-width: 100%;
+		  }
+		  .faultrow > td {
+		     background-color: LightCoral;
+		  }
+		  #resulttable {
+		    border-collapse: collapse;
+		    width: 100%;
+		    table-layout: fixed;
+		  }
+		  #resulttable th, #resulttable td {
+		    border: 1px solid grey;
+		  }
+		  .testletheader > td {
+		    background-color: LightSkyBlue;
+		  }
+		  .header-pos {
+		    width: 20%;
+		  }
+		  .header-val {
+		    width: 30%;
+		  }
+		  .py-pos,.trans-pos {
+		    width: 20%;
+		    overflow: hidden;
+		  }
+		  .py-val, .trans-val {
+		    width: 30%;
+		    overflow-x: auto;
+		  }
+		  .exc-header {
+	      color: red;
+		  }
+		  .collapsed {
+		    display: None;
+		  }
+		</style>
+		</head><body><b>Status:</b>
+<div id="message"></div><br><br>
+
+<div id="python" style="display: None"><div id="basics">
+<div id="pyresults">'Zeros' [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] '<br>' | 'Ones' [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]] | 'Identity' [[1, 0, 0], [0, 1, 0], [0, 0, 1]] '<br>' | 'Matrix a' [[1, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 12]] '<br>' | 'Transpose of a' [[1, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 12]] '<br>' | 'Matrix b' [[2, 2, 4, 6], [8, 10, 12, 14], [16, 18, 20, 24]] '<br>' | 'Permutation of b' [[2, 8, 16], [2, 10, 18], [4, 12, 20], [6, 14, 24]] '<br>' | 'Shape c' (3, 4) '<br>' | 'Matrix c' [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] '<br>' | 'Shape ct' (4, 3) '<br>' | 'Transpose of c' [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]] '<br>' | 'Matrix cs0' [[1, 2], [5, 6], [9, 10]] '<br>' | 'Matrix cs1' [[3, 4], [7, 8], [11, 12]] '<br>' | 'Matrix ci' [[3, 4, 1, 2], [7, 8, 5, 6], [11, 12, 9, 10]] '<br>' | 'Matrix cts0' [[1], [2], [3], [4]] '<br>' | 'Matrix cts1' [[5], [6], [7], [8]] '<br>' | 'Matrix cts2' [[9], [10], [11], [12]] '<br>' | 'Matrix ci' [[9, 5, 1], [10, 6, 2], [11, 7, 3], [12, 8, 4]] '<br>' | 'Matrix d' [[13, 14], [15, 16], [17, 18], [19, 20]] '<br>' | 'Permutation of d' [[13, 15, 17, 19], [14, 16, 18, 20]] '<br>' | 'Matrix ds0' [[13, 14]] '<br>' | 'Matrix ds1' [[15, 16]] '<br>' | 'Matrix ds2' [[17, 18]] '<br>' | 'Matrix ds3' [[19, 20]] '<br>' | 'Matrix di' [[19, 20], [17, 18], [15, 16], [13, 14]] '<br>' | 'Matrix dts0' [[13, 15, 17, 19]] '<br>' | 'Matrix dts1' [[14, 16, 18, 20]] '<br>' | 'Matrix dti' [[14, 16, 18, 20], [13, 15, 17, 19]] '<br>' | 'El a [1, 2, 3] alt' [[1, 1, 2, 3], [177, 5, 6, 7], [8, 9, 10, 12]] '<br>' | 'El b [1, 2, 3]' 12 '<br>' | 'Sl b0' [10, 12] '<br>' | 'Sl b1' [[10, 12]] '<br>' | 'Sl b2' [10] '<br>' | 'Sl b3' [10, 12] '<br>' | 'Sl b4' [2, 10, 18] '<br>' | 'Sl b5' [10, 12] '<br>' | 'Sl b6' [10, 12] '<br>' | 'Sl b7' [12] '<br>' | 'Sl bp0' [10, 18] '<br>' | 'Sl bp1' [[10, 18]] '<br>' | 'Sl bp2' [2, 10, 18] '<br>' | 'Sl bp3' [10, 18] '<br>' | 'Sl bp4' [8, 10, 12, 14] '<br>' | 'Sl bp5' [14, 24] '<br>' | 'Sl bp6' [[12, 20], [14, 24]] '<br>' | 'Sl bp7' [[20], [24]] '<br>' | 'Matrix sum' [[3, 3, 6, 9], [185, 15, 18, 21], [24, 27, 30, 36]] '<br>' | 'Matrix difference' [[-1, -1, -2, -3], [169, -5, -6, -7], [-8, -9, -10, -12]] '<br>' | 'Matrix product' [[2, 2, 8, 18], [1416, 50, 72, 98], [128, 162, 200, 288]] '<br>' | 'Matrix quotient' [[0.5, 0.5, 0.5, 0.5], [22.125, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5]] '<br>' | 'Matrix dotproduct' [[170, 180], [426, 452], [682, 724]] '<br>' | 'Vector' [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] '<br>' | 'Vector' [1, 2, 3, 1, 2, 3, 1, 2, 3, 1] '<br>' | 'El sum old' 7 '<br>' | 'Vector sum new' [1, 3, 5, 4, 6, 8, 70, 9, 11, 10] '<br>' | 'mul_a3' [[3, 3, 6, 9], [531, 15, 18, 21], [24, 27, 30, 36]] '<br>' | 'mul_3a' [[3, 3, 6, 9], [531, 15, 18, 21], [24, 27, 30, 36]] '<br>' | 'div_a3' [[0.32, 0.32, 0.64, 0.96], [56.67, 1.6, 1.92, 2.24], [2.56, 2.88, 3.2, 3.84]] '<br>' | 'div_3a' [[3.12, 3.12, 1.56, 1.04], [0.02, 0.62, 0.52, 0.45], [0.39, 0.35, 0.31, 0.26]] '<br>' | 'add_a3' [[4, 4, 5, 6], [180, 8, 9, 10], [11, 12, 13, 15]] '<br>' | 'add_3a' [[4, 4, 5, 6], [180, 8, 9, 10], [11, 12, 13, 15]] '<br>' | 'sub_a3' [[-2, -2, -1, 0], [174, 2, 3, 4], [5, 6, 7, 9]] '<br>' | 'sub_3a' [[2, 2, 1, 0], [-174, -2, -3, -4], [-5, -6, -7, -9]] '<br>' | 'neg_a' [[-1, -1, -2, -3], [-177, -5, -6, -7], [-8, -9, -10, -12]] '<br>' | 'comp_a' [[(1+2j), (2-1j), (3+0j)], [(4+0j), (5+3j), (7+0j)]] '<br>' | 'comp_b' [[(6+0j), (8-1j)], [(9+3j), (10+0j)], [(11+0j), (12-6j)]] '<br>' | 'comp_c' [[(60+9j), (66-13j)], [(137+42j), (166-16j)]] '<br>' | 'comp_a_square' [[(1+2j), (2-1j)], [(4+0j), (5+3j)]] '<br>' | 'comp_b_square' [[(9+3j), (10+0j)], [(11+0j), (12-6j)]] '<br>' | 'comp_c_square' [[(3+21j), (20-10j)], [(44+0j), (78+6j)]] '<br>' | 'comp_d_square' [[(0.17+0.17j), (0.2-0.1j)], [(0.36+0j), (0.23+0.37j)]] '<br>' | 'comp_e_square' [[(10+5j), (12-1j)], [(15+0j), (17-3j)]] '<br>' | 'comp_f_square' [[(-8-1j), (-8-1j)], [(-7+0j), (-7+9j)]] '<br>' | 'sliceable_a' [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] | 'slice_a'</div>
+
+<div id="pypos">automated_tests/ndarray\basics\__init__.py:15 | automated_tests/ndarray\basics\__init__.py:18 | automated_tests/ndarray\basics\__init__.py:21 | automated_tests/ndarray\basics\__init__.py:29 | automated_tests/ndarray\basics\__init__.py:31 | automated_tests/ndarray\basics\__init__.py:41 | automated_tests/ndarray\basics\__init__.py:42 | automated_tests/ndarray\basics\__init__.py:50 | automated_tests/ndarray\basics\__init__.py:51 | automated_tests/ndarray\basics\__init__.py:54 | automated_tests/ndarray\basics\__init__.py:55 | automated_tests/ndarray\basics\__init__.py:58 | automated_tests/ndarray\basics\__init__.py:59 | automated_tests/ndarray\basics\__init__.py:62 | automated_tests/ndarray\basics\__init__.py:65 | automated_tests/ndarray\basics\__init__.py:66 | automated_tests/ndarray\basics\__init__.py:67 | automated_tests/ndarray\basics\__init__.py:70 | automated_tests/ndarray\basics\__init__.py:79 | automated_tests/ndarray\basics\__init__.py:81 | automated_tests/ndarray\basics\__init__.py:84 | automated_tests/ndarray\basics\__init__.py:85 | automated_tests/ndarray\basics\__init__.py:86 | automated_tests/ndarray\basics\__init__.py:87 | automated_tests/ndarray\basics\__init__.py:90 | automated_tests/ndarray\basics\__init__.py:93 | automated_tests/ndarray\basics\__init__.py:94 | automated_tests/ndarray\basics\__init__.py:97 | automated_tests/ndarray\basics\__init__.py:146 | automated_tests/ndarray\basics\__init__.py:147 | automated_tests/ndarray\basics\__init__.py:149 | automated_tests/ndarray\basics\__init__.py:150 | automated_tests/ndarray\basics\__init__.py:151 | automated_tests/ndarray\basics\__init__.py:152 | automated_tests/ndarray\basics\__init__.py:153 | automated_tests/ndarray\basics\__init__.py:154 | automated_tests/ndarray\basics\__init__.py:155 | automated_tests/ndarray\basics\__init__.py:156 | automated_tests/ndarray\basics\__init__.py:158 | automated_tests/ndarray\basics\__init__.py:159 | automated_tests/ndarray\basics\__init__.py:160 | automated_tests/ndarray\basics\__init__.py:161 | automated_tests/ndarray\basics\__init__.py:162 | automated_tests/ndarray\basics\__init__.py:163 | automated_tests/ndarray\basics\__init__.py:164 | automated_tests/ndarray\basics\__init__.py:165 | automated_tests/ndarray\basics\__init__.py:167 | automated_tests/ndarray\basics\__init__.py:168 | automated_tests/ndarray\basics\__init__.py:169 | automated_tests/ndarray\basics\__init__.py:170 | automated_tests/ndarray\basics\__init__.py:171 | automated_tests/ndarray\basics\__init__.py:173 | automated_tests/ndarray\basics\__init__.py:174 | automated_tests/ndarray\basics\__init__.py:175 | automated_tests/ndarray\basics\__init__.py:176 | automated_tests/ndarray\basics\__init__.py:178 | automated_tests/ndarray\basics\__init__.py:179 | automated_tests/ndarray\basics\__init__.py:180 | automated_tests/ndarray\basics\__init__.py:181 | automated_tests/ndarray\basics\__init__.py:182 | automated_tests/ndarray\basics\__init__.py:183 | automated_tests/ndarray\basics\__init__.py:184 | automated_tests/ndarray\basics\__init__.py:185 | automated_tests/ndarray\basics\__init__.py:186 | automated_tests/ndarray\basics\__init__.py:201 | automated_tests/ndarray\basics\__init__.py:202 | automated_tests/ndarray\basics\__init__.py:203 | automated_tests/ndarray\basics\__init__.py:217 | automated_tests/ndarray\basics\__init__.py:218 | automated_tests/ndarray\basics\__init__.py:219 | automated_tests/ndarray\basics\__init__.py:220 | automated_tests/ndarray\basics\__init__.py:221 | automated_tests/ndarray\basics\__init__.py:222 | automated_tests/ndarray\basics\__init__.py:231 | automated_tests/ndarray\basics\__init__.py:234</div>
+</div>
+<div id="module_linalg">
+<div id="pyresults">'Matrix r' [[2.12, -2.11, -1.23], [2.31, 1.14, 3.15], [1.13, 1.98, 2.81]] '<br>' | 'Matrix ri' [[0.71, -0.81, 1.22], [0.68, -1.71, 2.22], [-0.77, 1.54, -1.7]] '<br>' | 'r @ ri' [[1, 0, 0], [0, 1, 0], [0, 0, 1]] '<br>' | 'r * r' [[4.495, 4.453, 1.514], [5.337, 1.301, 9.923], [1.278, 3.921, 7.897]] '<br>' | 'r / r' [[1.001, 1.001, 1.001], [1.001, 1.001, 1.001], [1.001, 1.001, 1.001]] '<br>' | 'r + r' [[4.241, -4.219, -2.459], [4.621, 2.281, 6.301], [2.261, 3.961, 5.621]] '<br>' | 'r - r' [[0.001, 0.001, 0.001], [0.001, 0.001, 0.001], [0.001, 0.001, 0.001]] '<br>' | 'Matrix c' [[(2.12-3.15j), (-2.11+0j), (-1.23+0j)], [(2.31+0j), (1.14+0j), (3.15+2.75j)], [(1.13+0j), (1.98-4.33j), (2.81+0j)]] '<br>' | 'Matrix ci' [[(0.13+0.21j), (0.07-0.05j), (-0.08+0.08j)], [(0.05+0.04j), (-0.13-0.1j), (0.07+0.26j)], [(-0.14-0.04j), (0.21-0.11j), (-0.06-0.1j)]] '<br>' | 'c * c' [[(-5.427-13.355j), (4.453+0.001j), (1.514+0.001j)], [(5.337+0.001j), (1.301+0.001j), (2.361+17.326j)], [(1.278+0.001j), (-14.827-17.146j), (7.897+0.001j)]] '<br>' | 'c / c' [[(1.001+0.001j), (1.001+0.001j), (1.001+0.001j)], [(1.001+0.001j), (1.001+0.001j), (1.001+0.001j)], [(1.001+0.001j), (1.001+0.001j), (1.001+0.001j)]] '<br>' | 'c + c' [[(4.241-6.299j), (-4.219+0.001j), (-2.459+0.001j)], [(4.621+0.001j), (2.281+0.001j), (6.301+5.501j)], [(2.261+0.001j), (3.961-8.659j), (5.621+0.001j)]] '<br>' | 'c - c' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j)]] '<br>'</div>
+
+<div id="pypos">automated_tests/ndarray\module_linalg\__init__.py:25 | automated_tests/ndarray\module_linalg\__init__.py:29 | automated_tests/ndarray\module_linalg\__init__.py:35 | automated_tests/ndarray\module_linalg\__init__.py:39 | automated_tests/ndarray\module_linalg\__init__.py:40 | automated_tests/ndarray\module_linalg\__init__.py:41 | automated_tests/ndarray\module_linalg\__init__.py:42 | automated_tests/ndarray\module_linalg\__init__.py:55 | automated_tests/ndarray\module_linalg\__init__.py:59 | automated_tests/ndarray\module_linalg\__init__.py:69 | automated_tests/ndarray\module_linalg\__init__.py:70 | automated_tests/ndarray\module_linalg\__init__.py:71 | automated_tests/ndarray\module_linalg\__init__.py:72</div>
+</div>
+<div id="module_fft">
+<div id="pyresults">'<br>------ 1D ------<br>' | 'Samples computed: 8192<br>' | 'Samples shown: 102<br>' | 'Original samples' [(0.801+0.001j), (0.846+0.001j), (0.887+0.001j), (0.925+0.001j), (0.961+0.001j), (0.993+0.001j), (1.022+0.001j), (1.047+0.001j), (1.07+0.001j), (1.089+0.001j), (1.105+0.001j), (1.118+0.001j), (1.128+0.001j), (1.136+0.001j), (1.14+0.001j), (1.142+0.001j), (1.141+0.001j), (1.138+0.001j), (1.132+0.001j), (1.125+0.001j), (1.115+0.001j), (1.104+0.001j), (1.091+0.001j), (1.077+0.001j), (1.061+0.001j), (1.044+0.001j), (1.026+0.001j), (1.008+0.001j), (0.989+0.001j), (0.969+0.001j), (0.949+0.001j), (0.93+0.001j), (0.91+0.001j), (0.89+0.001j), (0.871+0.001j), (0.852+0.001j), (0.833+0.001j), (0.815+0.001j), (0.798+0.001j), (0.782+0.001j), (0.766+0.001j), (0.751+0.001j), (0.738+0.001j), (0.725+0.001j), (0.713+0.001j), (0.702+0.001j), (0.692+0.001j), (0.683+0.001j), (0.675+0.001j), (0.668+0.001j), (0.662+0.001j), (0.656+0.001j), (0.65+0.001j), (0.646+0.001j), (0.641+0.001j), (0.637+0.001j), (0.633+0.001j), (0.63+0.001j), (0.626+0.001j), (0.622+0.001j), (0.617+0.001j), (0.612+0.001j), (0.607+0.001j), (0.601+0.001j), (0.594+0.001j), (0.586+0.001j), (0.576+0.001j), (0.566+0.001j), (0.554+0.001j), (0.541+0.001j), (0.527+0.001j), (0.51+0.001j), (0.492+0.001j), (0.472+0.001j), (0.451+0.001j), (0.427+0.001j), (0.402+0.001j), (0.375+0.001j), (0.345+0.001j), (0.314+0.001j), (0.281+0.001j), (0.247+0.001j), (0.21+0.001j), (0.172+0.001j), (0.132+0.001j), (0.091+0.001j), (0.048+0.001j), (0.004+0.001j), (-0.041+0.001j), (-0.087+0.001j), (-0.134+0.001j), (-0.181+0.001j), (-0.229+0.001j), (-0.277+0.001j), (-0.325+0.001j), (-0.373+0.001j), (-0.42+0.001j), (-0.467+0.001j), (-0.513+0.001j), (-0.558+0.001j), (-0.601+0.001j), (-0.643+0.001j)] '<br>' | 'Frequencies' [(2457.601+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001-4095.999j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (2048.001+0.001j), (0.001+0.001j)] '<br>' | 'Reconstructed samples' [(0.801+0.001j), (0.846+0.001j), (0.887+0.001j), (0.925+0.001j), (0.961+0.001j), (0.993+0.001j), (1.022+0.001j), (1.047+0.001j), (1.07+0.001j), (1.089+0.001j), (1.105+0.001j), (1.118+0.001j), (1.128+0.001j), (1.136+0.001j), (1.14+0.001j), (1.142+0.001j), (1.141+0.001j), (1.138+0.001j), (1.132+0.001j), (1.125+0.001j), (1.115+0.001j), (1.104+0.001j), (1.091+0.001j), (1.077+0.001j), (1.061+0.001j), (1.044+0.001j), (1.026+0.001j), (1.008+0.001j), (0.989+0.001j), (0.969+0.001j), (0.949+0.001j), (0.93+0.001j), (0.91+0.001j), (0.89+0.001j), (0.871+0.001j), (0.852+0.001j), (0.833+0.001j), (0.815+0.001j), (0.798+0.001j), (0.782+0.001j), (0.766+0.001j), (0.751+0.001j), (0.738+0.001j), (0.725+0.001j), (0.713+0.001j), (0.702+0.001j), (0.692+0.001j), (0.683+0.001j), (0.675+0.001j), (0.668+0.001j), (0.662+0.001j), (0.656+0.001j), (0.65+0.001j), (0.646+0.001j), (0.641+0.001j), (0.637+0.001j), (0.633+0.001j), (0.63+0.001j), (0.626+0.001j), (0.622+0.001j), (0.617+0.001j), (0.612+0.001j), (0.607+0.001j), (0.601+0.001j), (0.594+0.001j), (0.586+0.001j), (0.576+0.001j), (0.566+0.001j), (0.554+0.001j), (0.541+0.001j), (0.527+0.001j), (0.51+0.001j), (0.492+0.001j), (0.472+0.001j), (0.451+0.001j), (0.427+0.001j), (0.402+0.001j), (0.375+0.001j), (0.345+0.001j), (0.314+0.001j), (0.281+0.001j), (0.247+0.001j), (0.21+0.001j), (0.172+0.001j), (0.132+0.001j), (0.091+0.001j), (0.048+0.001j), (0.004+0.001j), (-0.041+0.001j), (-0.087+0.001j), (-0.134+0.001j), (-0.181+0.001j), (-0.229+0.001j), (-0.277+0.001j), (-0.325+0.001j), (-0.373+0.001j), (-0.42+0.001j), (-0.467+0.001j), (-0.513+0.001j), (-0.558+0.001j), (-0.601+0.001j), (-0.643+0.001j)] '<br>' | '<br>------ 2D ------<br>' | 'Original samples' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)]] '<br>' | 'Frequencies' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (-1.054+2.232j), (0.001+0.001j), (1.05-1.961j), (0.001+0.001j), (-1.042+1.742j), (0.001+0.001j), (1.04-1.554j), (0.001+0.001j), (-1.034+1.396j), (0.001+0.001j), (1.032-1.256j), (0.001+0.001j), (-1.027+1.136j), (0.001+0.001j), (1.027-1.025j), (0.001+0.001j), (-1.022+0.929j), (0.001+0.001j), (1.022-0.837j), (0.001+0.001j), (-1.018+0.757j), (0.001+0.001j), (1.018-0.679j), (0.001+0.001j), (-1.015+0.61j), (0.001+0.001j), (1.015-0.541j), (0.001+0.001j), (-1.011+0.48j), (0.001+0.001j), (1.012-0.418j), (0.001+0.001j), (-1.008+0.362j), (0.001+0.001j), (1.009-0.305j), (0.001+0.001j), (-1.006+0.253j), (0.001+0.001j), (1.007-0.199j), (0.001+0.001j), (-1.003+0.15j), (0.001+0.001j), (1.004-0.098j), (0.001+0.001j), (-1.001+0.05j), (0.001+0.001j), (1.002+0.001j), (0.001+0.001j), (-0.998-0.048j), (0.001+0.001j), (0.999+0.099j), (0.001+0.001j), (-0.996-0.147j), (0.001+0.001j), (0.997+0.199j), (0.001+0.001j), (-0.993-0.248j), (0.001+0.001j), (0.994+0.302j), (0.001+0.001j), (-0.991-0.354j), (0.001+0.001j), (0.992+0.411j), (0.001+0.001j), (-0.988-0.467j), (0.001+0.001j), (0.989+0.529j), (0.001+0.001j), (-0.985-0.59j), (0.001+0.001j), (0.985+0.659j), (0.001+0.001j), (-0.982-0.728j), (0.001+0.001j), (0.982+0.806j), (0.001+0.001j), (-0.978-0.886j), (0.001+0.001j), (0.978+0.978j), (0.001+0.001j), (-0.973-1.074j), (0.001+0.001j), (0.973+1.185j), (0.001+0.001j), (-0.968-1.305j), (0.001+0.001j), (0.966+1.445j), (0.001+0.001j), (-0.96-1.603j), (0.001+0.001j), (0.958+1.791j), (0.001+0.001j), (-0.95-2.01j), (0.001+0.001j), (0.946+2.282j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (1.167-2.181j), (0.001+0.001j), (-1.146+1.914j), (0.001+0.001j), (1.131-1.69j), (0.001+0.001j), (-1.115+1.506j), (0.001+0.001j), (1.106-1.345j), (0.001+0.001j), (-1.094+1.209j), (0.001+0.001j), (1.087-1.085j), (0.001+0.001j), (-1.076+0.978j), (0.001+0.001j), (1.071-0.877j), (0.001+0.001j), (-1.063+0.79j), (0.001+0.001j), (1.059-0.706j), (0.001+0.001j), (-1.051+0.632j), (0.001+0.001j), (1.048-0.558j), (0.001+0.001j), (-1.041+0.494j), (0.001+0.001j), (1.038-0.429j), (0.001+0.001j), (-1.032+0.371j), (0.001+0.001j), (1.029-0.311j), (0.001+0.001j), (-1.023+0.258j), (0.001+0.001j), (1.021-0.202j), (0.001+0.001j), (-1.016+0.152j), (0.001+0.001j), (1.014-0.099j), (0.001+0.001j), (-1.008+0.051j), (0.001+0.001j), (1.006+0.001j), (0.001+0.001j), (-1.001-0.048j), (0.001+0.001j), (0.999+0.099j), (0.001+0.001j), (-0.994-0.147j), (0.001+0.001j), (0.992+0.198j), (0.001+0.001j), (-0.986-0.246j), (0.001+0.001j), (0.984+0.299j), (0.001+0.001j), (-0.979-0.35j), (0.001+0.001j), (0.977+0.405j), (0.001+0.001j), (-0.971-0.459j), (0.001+0.001j), (0.968+0.518j), (0.001+0.001j), (-0.962-0.576j), (0.001+0.001j), (0.959+0.641j), (0.001+0.001j), (-0.952-0.706j), (0.001+0.001j), (0.949+0.779j), (0.001+0.001j), (-0.941-0.853j), (0.001+0.001j), (0.937+0.937j), (0.001+0.001j), (-0.929-1.025j), (0.001+0.001j), (0.924+1.125j), (0.001+0.001j), (-0.913-1.232j), (0.001+0.001j), (0.906+1.356j), (0.001+0.001j), (-0.894-1.493j), (0.001+0.001j), (0.885+1.654j), (0.001+0.001j), (-0.869-1.838j), (0.001+0.001j), (0.854+2.061j), (0.001+0.001j), (-0.833-2.329j)]] '<br>' | 'Reconstructed samples' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)]] '<br>'</div>
+
+<div id="pypos">automated_tests/ndarray\module_fft\__init__.py:35 | automated_tests/ndarray\module_fft\__init__.py:39 | automated_tests/ndarray\module_fft\__init__.py:40 | automated_tests/ndarray\module_fft\__init__.py:52 | automated_tests/ndarray\module_fft\__init__.py:60 | automated_tests/ndarray\module_fft\__init__.py:68 | automated_tests/ndarray\module_fft\__init__.py:76 | automated_tests/ndarray\module_fft\__init__.py:83 | automated_tests/ndarray\module_fft\__init__.py:92 | automated_tests/ndarray\module_fft\__init__.py:104</div>
+</div>
+</div></div>
+<div id="exc-area"></div><div id="results"><div> <a id="force-collapse" href="#"> Collapse All</a> <a id="force-expand" href="#">Expand All</a></div><table id="resulttable"><thead><tr> <th colspan="2"> CPython </th> <th colspan="2"> Transcrypt </th> </tr><tr> <th class="header-pos"> Location </th> <th class="header-val"> Value </th> <th class="header-val"> Value </th> <th class="header-pos"> Location </th> </tr></thead><tbody></tbody></table></div><script src="__javascript__/autotest.js"></script>
+
+</body></html>
\ No newline at end of file
diff --git a/numscrypt/development/automated_tests/ndarray/autotest.min.html b/numscrypt/development/automated_tests/ndarray/autotest.min.html
new file mode 100644
index 0000000..d9c5147
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/autotest.min.html
@@ -0,0 +1,62 @@
+<html><head>
+		<style>
+		  body {
+		    max-width: 100%;
+		  }
+		  .faultrow > td {
+		     background-color: LightCoral;
+		  }
+		  #resulttable {
+		    border-collapse: collapse;
+		    width: 100%;
+		    table-layout: fixed;
+		  }
+		  #resulttable th, #resulttable td {
+		    border: 1px solid grey;
+		  }
+		  .testletheader > td {
+		    background-color: LightSkyBlue;
+		  }
+		  .header-pos {
+		    width: 20%;
+		  }
+		  .header-val {
+		    width: 30%;
+		  }
+		  .py-pos,.trans-pos {
+		    width: 20%;
+		    overflow: hidden;
+		  }
+		  .py-val, .trans-val {
+		    width: 30%;
+		    overflow-x: auto;
+		  }
+		  .exc-header {
+	      color: red;
+		  }
+		  .collapsed {
+		    display: None;
+		  }
+		</style>
+		</head><body><b>Status:</b>
+<div id="message"></div><br><br>
+
+<div id="python" style="display: None"><div id="basics">
+<div id="pyresults">'Zeros' [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] '<br>' | 'Ones' [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]] | 'Identity' [[1, 0, 0], [0, 1, 0], [0, 0, 1]] '<br>' | 'Matrix a' [[1, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 12]] '<br>' | 'Transpose of a' [[1, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 12]] '<br>' | 'Matrix b' [[2, 2, 4, 6], [8, 10, 12, 14], [16, 18, 20, 24]] '<br>' | 'Permutation of b' [[2, 8, 16], [2, 10, 18], [4, 12, 20], [6, 14, 24]] '<br>' | 'Shape c' (3, 4) '<br>' | 'Matrix c' [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] '<br>' | 'Shape ct' (4, 3) '<br>' | 'Transpose of c' [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]] '<br>' | 'Matrix cs0' [[1, 2], [5, 6], [9, 10]] '<br>' | 'Matrix cs1' [[3, 4], [7, 8], [11, 12]] '<br>' | 'Matrix ci' [[3, 4, 1, 2], [7, 8, 5, 6], [11, 12, 9, 10]] '<br>' | 'Matrix cts0' [[1], [2], [3], [4]] '<br>' | 'Matrix cts1' [[5], [6], [7], [8]] '<br>' | 'Matrix cts2' [[9], [10], [11], [12]] '<br>' | 'Matrix ci' [[9, 5, 1], [10, 6, 2], [11, 7, 3], [12, 8, 4]] '<br>' | 'Matrix d' [[13, 14], [15, 16], [17, 18], [19, 20]] '<br>' | 'Permutation of d' [[13, 15, 17, 19], [14, 16, 18, 20]] '<br>' | 'Matrix ds0' [[13, 14]] '<br>' | 'Matrix ds1' [[15, 16]] '<br>' | 'Matrix ds2' [[17, 18]] '<br>' | 'Matrix ds3' [[19, 20]] '<br>' | 'Matrix di' [[19, 20], [17, 18], [15, 16], [13, 14]] '<br>' | 'Matrix dts0' [[13, 15, 17, 19]] '<br>' | 'Matrix dts1' [[14, 16, 18, 20]] '<br>' | 'Matrix dti' [[14, 16, 18, 20], [13, 15, 17, 19]] '<br>' | 'El a [1, 2, 3] alt' [[1, 1, 2, 3], [177, 5, 6, 7], [8, 9, 10, 12]] '<br>' | 'El b [1, 2, 3]' 12 '<br>' | 'Sl b0' [10, 12] '<br>' | 'Sl b1' [[10, 12]] '<br>' | 'Sl b2' [10] '<br>' | 'Sl b3' [10, 12] '<br>' | 'Sl b4' [2, 10, 18] '<br>' | 'Sl b5' [10, 12] '<br>' | 'Sl b6' [10, 12] '<br>' | 'Sl b7' [12] '<br>' | 'Sl bp0' [10, 18] '<br>' | 'Sl bp1' [[10, 18]] '<br>' | 'Sl bp2' [2, 10, 18] '<br>' | 'Sl bp3' [10, 18] '<br>' | 'Sl bp4' [8, 10, 12, 14] '<br>' | 'Sl bp5' [14, 24] '<br>' | 'Sl bp6' [[12, 20], [14, 24]] '<br>' | 'Sl bp7' [[20], [24]] '<br>' | 'Matrix sum' [[3, 3, 6, 9], [185, 15, 18, 21], [24, 27, 30, 36]] '<br>' | 'Matrix difference' [[-1, -1, -2, -3], [169, -5, -6, -7], [-8, -9, -10, -12]] '<br>' | 'Matrix product' [[2, 2, 8, 18], [1416, 50, 72, 98], [128, 162, 200, 288]] '<br>' | 'Matrix quotient' [[0.5, 0.5, 0.5, 0.5], [22.125, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5]] '<br>' | 'Matrix dotproduct' [[170, 180], [426, 452], [682, 724]] '<br>' | 'Vector' [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] '<br>' | 'Vector' [1, 2, 3, 1, 2, 3, 1, 2, 3, 1] '<br>' | 'El sum old' 7 '<br>' | 'Vector sum new' [1, 3, 5, 4, 6, 8, 70, 9, 11, 10] '<br>' | 'mul_a3' [[3, 3, 6, 9], [531, 15, 18, 21], [24, 27, 30, 36]] '<br>' | 'mul_3a' [[3, 3, 6, 9], [531, 15, 18, 21], [24, 27, 30, 36]] '<br>' | 'div_a3' [[0.32, 0.32, 0.64, 0.96], [56.67, 1.6, 1.92, 2.24], [2.56, 2.88, 3.2, 3.84]] '<br>' | 'div_3a' [[3.12, 3.12, 1.56, 1.04], [0.02, 0.62, 0.52, 0.45], [0.39, 0.35, 0.31, 0.26]] '<br>' | 'add_a3' [[4, 4, 5, 6], [180, 8, 9, 10], [11, 12, 13, 15]] '<br>' | 'add_3a' [[4, 4, 5, 6], [180, 8, 9, 10], [11, 12, 13, 15]] '<br>' | 'sub_a3' [[-2, -2, -1, 0], [174, 2, 3, 4], [5, 6, 7, 9]] '<br>' | 'sub_3a' [[2, 2, 1, 0], [-174, -2, -3, -4], [-5, -6, -7, -9]] '<br>' | 'neg_a' [[-1, -1, -2, -3], [-177, -5, -6, -7], [-8, -9, -10, -12]] '<br>' | 'comp_a' [[(1+2j), (2-1j), (3+0j)], [(4+0j), (5+3j), (7+0j)]] '<br>' | 'comp_b' [[(6+0j), (8-1j)], [(9+3j), (10+0j)], [(11+0j), (12-6j)]] '<br>' | 'comp_c' [[(60+9j), (66-13j)], [(137+42j), (166-16j)]] '<br>' | 'comp_a_square' [[(1+2j), (2-1j)], [(4+0j), (5+3j)]] '<br>' | 'comp_b_square' [[(9+3j), (10+0j)], [(11+0j), (12-6j)]] '<br>' | 'comp_c_square' [[(3+21j), (20-10j)], [(44+0j), (78+6j)]] '<br>' | 'comp_d_square' [[(0.17+0.17j), (0.2-0.1j)], [(0.36+0j), (0.23+0.37j)]] '<br>' | 'comp_e_square' [[(10+5j), (12-1j)], [(15+0j), (17-3j)]] '<br>' | 'comp_f_square' [[(-8-1j), (-8-1j)], [(-7+0j), (-7+9j)]] '<br>' | 'sliceable_a' [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] | 'slice_a'</div>
+
+<div id="pypos">automated_tests/ndarray\basics\__init__.py:15 | automated_tests/ndarray\basics\__init__.py:18 | automated_tests/ndarray\basics\__init__.py:21 | automated_tests/ndarray\basics\__init__.py:29 | automated_tests/ndarray\basics\__init__.py:31 | automated_tests/ndarray\basics\__init__.py:41 | automated_tests/ndarray\basics\__init__.py:42 | automated_tests/ndarray\basics\__init__.py:50 | automated_tests/ndarray\basics\__init__.py:51 | automated_tests/ndarray\basics\__init__.py:54 | automated_tests/ndarray\basics\__init__.py:55 | automated_tests/ndarray\basics\__init__.py:58 | automated_tests/ndarray\basics\__init__.py:59 | automated_tests/ndarray\basics\__init__.py:62 | automated_tests/ndarray\basics\__init__.py:65 | automated_tests/ndarray\basics\__init__.py:66 | automated_tests/ndarray\basics\__init__.py:67 | automated_tests/ndarray\basics\__init__.py:70 | automated_tests/ndarray\basics\__init__.py:79 | automated_tests/ndarray\basics\__init__.py:81 | automated_tests/ndarray\basics\__init__.py:84 | automated_tests/ndarray\basics\__init__.py:85 | automated_tests/ndarray\basics\__init__.py:86 | automated_tests/ndarray\basics\__init__.py:87 | automated_tests/ndarray\basics\__init__.py:90 | automated_tests/ndarray\basics\__init__.py:93 | automated_tests/ndarray\basics\__init__.py:94 | automated_tests/ndarray\basics\__init__.py:97 | automated_tests/ndarray\basics\__init__.py:146 | automated_tests/ndarray\basics\__init__.py:147 | automated_tests/ndarray\basics\__init__.py:149 | automated_tests/ndarray\basics\__init__.py:150 | automated_tests/ndarray\basics\__init__.py:151 | automated_tests/ndarray\basics\__init__.py:152 | automated_tests/ndarray\basics\__init__.py:153 | automated_tests/ndarray\basics\__init__.py:154 | automated_tests/ndarray\basics\__init__.py:155 | automated_tests/ndarray\basics\__init__.py:156 | automated_tests/ndarray\basics\__init__.py:158 | automated_tests/ndarray\basics\__init__.py:159 | automated_tests/ndarray\basics\__init__.py:160 | automated_tests/ndarray\basics\__init__.py:161 | automated_tests/ndarray\basics\__init__.py:162 | automated_tests/ndarray\basics\__init__.py:163 | automated_tests/ndarray\basics\__init__.py:164 | automated_tests/ndarray\basics\__init__.py:165 | automated_tests/ndarray\basics\__init__.py:167 | automated_tests/ndarray\basics\__init__.py:168 | automated_tests/ndarray\basics\__init__.py:169 | automated_tests/ndarray\basics\__init__.py:170 | automated_tests/ndarray\basics\__init__.py:171 | automated_tests/ndarray\basics\__init__.py:173 | automated_tests/ndarray\basics\__init__.py:174 | automated_tests/ndarray\basics\__init__.py:175 | automated_tests/ndarray\basics\__init__.py:176 | automated_tests/ndarray\basics\__init__.py:178 | automated_tests/ndarray\basics\__init__.py:179 | automated_tests/ndarray\basics\__init__.py:180 | automated_tests/ndarray\basics\__init__.py:181 | automated_tests/ndarray\basics\__init__.py:182 | automated_tests/ndarray\basics\__init__.py:183 | automated_tests/ndarray\basics\__init__.py:184 | automated_tests/ndarray\basics\__init__.py:185 | automated_tests/ndarray\basics\__init__.py:186 | automated_tests/ndarray\basics\__init__.py:201 | automated_tests/ndarray\basics\__init__.py:202 | automated_tests/ndarray\basics\__init__.py:203 | automated_tests/ndarray\basics\__init__.py:217 | automated_tests/ndarray\basics\__init__.py:218 | automated_tests/ndarray\basics\__init__.py:219 | automated_tests/ndarray\basics\__init__.py:220 | automated_tests/ndarray\basics\__init__.py:221 | automated_tests/ndarray\basics\__init__.py:222 | automated_tests/ndarray\basics\__init__.py:231 | automated_tests/ndarray\basics\__init__.py:234</div>
+</div>
+<div id="module_linalg">
+<div id="pyresults">'Matrix r' [[2.12, -2.11, -1.23], [2.31, 1.14, 3.15], [1.13, 1.98, 2.81]] '<br>' | 'Matrix ri' [[0.71, -0.81, 1.22], [0.68, -1.71, 2.22], [-0.77, 1.54, -1.7]] '<br>' | 'r @ ri' [[1, 0, 0], [0, 1, 0], [0, 0, 1]] '<br>' | 'r * r' [[4.495, 4.453, 1.514], [5.337, 1.301, 9.923], [1.278, 3.921, 7.897]] '<br>' | 'r / r' [[1.001, 1.001, 1.001], [1.001, 1.001, 1.001], [1.001, 1.001, 1.001]] '<br>' | 'r + r' [[4.241, -4.219, -2.459], [4.621, 2.281, 6.301], [2.261, 3.961, 5.621]] '<br>' | 'r - r' [[0.001, 0.001, 0.001], [0.001, 0.001, 0.001], [0.001, 0.001, 0.001]] '<br>' | 'Matrix c' [[(2.12-3.15j), (-2.11+0j), (-1.23+0j)], [(2.31+0j), (1.14+0j), (3.15+2.75j)], [(1.13+0j), (1.98-4.33j), (2.81+0j)]] '<br>' | 'Matrix ci' [[(0.13+0.21j), (0.07-0.05j), (-0.08+0.08j)], [(0.05+0.04j), (-0.13-0.1j), (0.07+0.26j)], [(-0.14-0.04j), (0.21-0.11j), (-0.06-0.1j)]] '<br>' | 'c * c' [[(-5.427-13.355j), (4.453+0.001j), (1.514+0.001j)], [(5.337+0.001j), (1.301+0.001j), (2.361+17.326j)], [(1.278+0.001j), (-14.827-17.146j), (7.897+0.001j)]] '<br>' | 'c / c' [[(1.001+0.001j), (1.001+0.001j), (1.001+0.001j)], [(1.001+0.001j), (1.001+0.001j), (1.001+0.001j)], [(1.001+0.001j), (1.001+0.001j), (1.001+0.001j)]] '<br>' | 'c + c' [[(4.241-6.299j), (-4.219+0.001j), (-2.459+0.001j)], [(4.621+0.001j), (2.281+0.001j), (6.301+5.501j)], [(2.261+0.001j), (3.961-8.659j), (5.621+0.001j)]] '<br>' | 'c - c' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j)]] '<br>'</div>
+
+<div id="pypos">automated_tests/ndarray\module_linalg\__init__.py:25 | automated_tests/ndarray\module_linalg\__init__.py:29 | automated_tests/ndarray\module_linalg\__init__.py:35 | automated_tests/ndarray\module_linalg\__init__.py:39 | automated_tests/ndarray\module_linalg\__init__.py:40 | automated_tests/ndarray\module_linalg\__init__.py:41 | automated_tests/ndarray\module_linalg\__init__.py:42 | automated_tests/ndarray\module_linalg\__init__.py:55 | automated_tests/ndarray\module_linalg\__init__.py:59 | automated_tests/ndarray\module_linalg\__init__.py:69 | automated_tests/ndarray\module_linalg\__init__.py:70 | automated_tests/ndarray\module_linalg\__init__.py:71 | automated_tests/ndarray\module_linalg\__init__.py:72</div>
+</div>
+<div id="module_fft">
+<div id="pyresults">'<br>------ 1D ------<br>' | 'Samples computed: 8192<br>' | 'Samples shown: 102<br>' | 'Original samples' [(0.801+0.001j), (0.846+0.001j), (0.887+0.001j), (0.925+0.001j), (0.961+0.001j), (0.993+0.001j), (1.022+0.001j), (1.047+0.001j), (1.07+0.001j), (1.089+0.001j), (1.105+0.001j), (1.118+0.001j), (1.128+0.001j), (1.136+0.001j), (1.14+0.001j), (1.142+0.001j), (1.141+0.001j), (1.138+0.001j), (1.132+0.001j), (1.125+0.001j), (1.115+0.001j), (1.104+0.001j), (1.091+0.001j), (1.077+0.001j), (1.061+0.001j), (1.044+0.001j), (1.026+0.001j), (1.008+0.001j), (0.989+0.001j), (0.969+0.001j), (0.949+0.001j), (0.93+0.001j), (0.91+0.001j), (0.89+0.001j), (0.871+0.001j), (0.852+0.001j), (0.833+0.001j), (0.815+0.001j), (0.798+0.001j), (0.782+0.001j), (0.766+0.001j), (0.751+0.001j), (0.738+0.001j), (0.725+0.001j), (0.713+0.001j), (0.702+0.001j), (0.692+0.001j), (0.683+0.001j), (0.675+0.001j), (0.668+0.001j), (0.662+0.001j), (0.656+0.001j), (0.65+0.001j), (0.646+0.001j), (0.641+0.001j), (0.637+0.001j), (0.633+0.001j), (0.63+0.001j), (0.626+0.001j), (0.622+0.001j), (0.617+0.001j), (0.612+0.001j), (0.607+0.001j), (0.601+0.001j), (0.594+0.001j), (0.586+0.001j), (0.576+0.001j), (0.566+0.001j), (0.554+0.001j), (0.541+0.001j), (0.527+0.001j), (0.51+0.001j), (0.492+0.001j), (0.472+0.001j), (0.451+0.001j), (0.427+0.001j), (0.402+0.001j), (0.375+0.001j), (0.345+0.001j), (0.314+0.001j), (0.281+0.001j), (0.247+0.001j), (0.21+0.001j), (0.172+0.001j), (0.132+0.001j), (0.091+0.001j), (0.048+0.001j), (0.004+0.001j), (-0.041+0.001j), (-0.087+0.001j), (-0.134+0.001j), (-0.181+0.001j), (-0.229+0.001j), (-0.277+0.001j), (-0.325+0.001j), (-0.373+0.001j), (-0.42+0.001j), (-0.467+0.001j), (-0.513+0.001j), (-0.558+0.001j), (-0.601+0.001j), (-0.643+0.001j)] '<br>' | 'Frequencies' [(2457.601+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001-4095.999j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (2048.001+0.001j), (0.001+0.001j)] '<br>' | 'Reconstructed samples' [(0.801+0.001j), (0.846+0.001j), (0.887+0.001j), (0.925+0.001j), (0.961+0.001j), (0.993+0.001j), (1.022+0.001j), (1.047+0.001j), (1.07+0.001j), (1.089+0.001j), (1.105+0.001j), (1.118+0.001j), (1.128+0.001j), (1.136+0.001j), (1.14+0.001j), (1.142+0.001j), (1.141+0.001j), (1.138+0.001j), (1.132+0.001j), (1.125+0.001j), (1.115+0.001j), (1.104+0.001j), (1.091+0.001j), (1.077+0.001j), (1.061+0.001j), (1.044+0.001j), (1.026+0.001j), (1.008+0.001j), (0.989+0.001j), (0.969+0.001j), (0.949+0.001j), (0.93+0.001j), (0.91+0.001j), (0.89+0.001j), (0.871+0.001j), (0.852+0.001j), (0.833+0.001j), (0.815+0.001j), (0.798+0.001j), (0.782+0.001j), (0.766+0.001j), (0.751+0.001j), (0.738+0.001j), (0.725+0.001j), (0.713+0.001j), (0.702+0.001j), (0.692+0.001j), (0.683+0.001j), (0.675+0.001j), (0.668+0.001j), (0.662+0.001j), (0.656+0.001j), (0.65+0.001j), (0.646+0.001j), (0.641+0.001j), (0.637+0.001j), (0.633+0.001j), (0.63+0.001j), (0.626+0.001j), (0.622+0.001j), (0.617+0.001j), (0.612+0.001j), (0.607+0.001j), (0.601+0.001j), (0.594+0.001j), (0.586+0.001j), (0.576+0.001j), (0.566+0.001j), (0.554+0.001j), (0.541+0.001j), (0.527+0.001j), (0.51+0.001j), (0.492+0.001j), (0.472+0.001j), (0.451+0.001j), (0.427+0.001j), (0.402+0.001j), (0.375+0.001j), (0.345+0.001j), (0.314+0.001j), (0.281+0.001j), (0.247+0.001j), (0.21+0.001j), (0.172+0.001j), (0.132+0.001j), (0.091+0.001j), (0.048+0.001j), (0.004+0.001j), (-0.041+0.001j), (-0.087+0.001j), (-0.134+0.001j), (-0.181+0.001j), (-0.229+0.001j), (-0.277+0.001j), (-0.325+0.001j), (-0.373+0.001j), (-0.42+0.001j), (-0.467+0.001j), (-0.513+0.001j), (-0.558+0.001j), (-0.601+0.001j), (-0.643+0.001j)] '<br>' | '<br>------ 2D ------<br>' | 'Original samples' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)]] '<br>' | 'Frequencies' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (-1.054+2.232j), (0.001+0.001j), (1.05-1.961j), (0.001+0.001j), (-1.042+1.742j), (0.001+0.001j), (1.04-1.554j), (0.001+0.001j), (-1.034+1.396j), (0.001+0.001j), (1.032-1.256j), (0.001+0.001j), (-1.027+1.136j), (0.001+0.001j), (1.027-1.025j), (0.001+0.001j), (-1.022+0.929j), (0.001+0.001j), (1.022-0.837j), (0.001+0.001j), (-1.018+0.757j), (0.001+0.001j), (1.018-0.679j), (0.001+0.001j), (-1.015+0.61j), (0.001+0.001j), (1.015-0.541j), (0.001+0.001j), (-1.011+0.48j), (0.001+0.001j), (1.012-0.418j), (0.001+0.001j), (-1.008+0.362j), (0.001+0.001j), (1.009-0.305j), (0.001+0.001j), (-1.006+0.253j), (0.001+0.001j), (1.007-0.199j), (0.001+0.001j), (-1.003+0.15j), (0.001+0.001j), (1.004-0.098j), (0.001+0.001j), (-1.001+0.05j), (0.001+0.001j), (1.002+0.001j), (0.001+0.001j), (-0.998-0.048j), (0.001+0.001j), (0.999+0.099j), (0.001+0.001j), (-0.996-0.147j), (0.001+0.001j), (0.997+0.199j), (0.001+0.001j), (-0.993-0.248j), (0.001+0.001j), (0.994+0.302j), (0.001+0.001j), (-0.991-0.354j), (0.001+0.001j), (0.992+0.411j), (0.001+0.001j), (-0.988-0.467j), (0.001+0.001j), (0.989+0.529j), (0.001+0.001j), (-0.985-0.59j), (0.001+0.001j), (0.985+0.659j), (0.001+0.001j), (-0.982-0.728j), (0.001+0.001j), (0.982+0.806j), (0.001+0.001j), (-0.978-0.886j), (0.001+0.001j), (0.978+0.978j), (0.001+0.001j), (-0.973-1.074j), (0.001+0.001j), (0.973+1.185j), (0.001+0.001j), (-0.968-1.305j), (0.001+0.001j), (0.966+1.445j), (0.001+0.001j), (-0.96-1.603j), (0.001+0.001j), (0.958+1.791j), (0.001+0.001j), (-0.95-2.01j), (0.001+0.001j), (0.946+2.282j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (1.167-2.181j), (0.001+0.001j), (-1.146+1.914j), (0.001+0.001j), (1.131-1.69j), (0.001+0.001j), (-1.115+1.506j), (0.001+0.001j), (1.106-1.345j), (0.001+0.001j), (-1.094+1.209j), (0.001+0.001j), (1.087-1.085j), (0.001+0.001j), (-1.076+0.978j), (0.001+0.001j), (1.071-0.877j), (0.001+0.001j), (-1.063+0.79j), (0.001+0.001j), (1.059-0.706j), (0.001+0.001j), (-1.051+0.632j), (0.001+0.001j), (1.048-0.558j), (0.001+0.001j), (-1.041+0.494j), (0.001+0.001j), (1.038-0.429j), (0.001+0.001j), (-1.032+0.371j), (0.001+0.001j), (1.029-0.311j), (0.001+0.001j), (-1.023+0.258j), (0.001+0.001j), (1.021-0.202j), (0.001+0.001j), (-1.016+0.152j), (0.001+0.001j), (1.014-0.099j), (0.001+0.001j), (-1.008+0.051j), (0.001+0.001j), (1.006+0.001j), (0.001+0.001j), (-1.001-0.048j), (0.001+0.001j), (0.999+0.099j), (0.001+0.001j), (-0.994-0.147j), (0.001+0.001j), (0.992+0.198j), (0.001+0.001j), (-0.986-0.246j), (0.001+0.001j), (0.984+0.299j), (0.001+0.001j), (-0.979-0.35j), (0.001+0.001j), (0.977+0.405j), (0.001+0.001j), (-0.971-0.459j), (0.001+0.001j), (0.968+0.518j), (0.001+0.001j), (-0.962-0.576j), (0.001+0.001j), (0.959+0.641j), (0.001+0.001j), (-0.952-0.706j), (0.001+0.001j), (0.949+0.779j), (0.001+0.001j), (-0.941-0.853j), (0.001+0.001j), (0.937+0.937j), (0.001+0.001j), (-0.929-1.025j), (0.001+0.001j), (0.924+1.125j), (0.001+0.001j), (-0.913-1.232j), (0.001+0.001j), (0.906+1.356j), (0.001+0.001j), (-0.894-1.493j), (0.001+0.001j), (0.885+1.654j), (0.001+0.001j), (-0.869-1.838j), (0.001+0.001j), (0.854+2.061j), (0.001+0.001j), (-0.833-2.329j)]] '<br>' | 'Reconstructed samples' [[(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)], [(0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (1.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j), (0.001+0.001j)]] '<br>'</div>
+
+<div id="pypos">automated_tests/ndarray\module_fft\__init__.py:35 | automated_tests/ndarray\module_fft\__init__.py:39 | automated_tests/ndarray\module_fft\__init__.py:40 | automated_tests/ndarray\module_fft\__init__.py:52 | automated_tests/ndarray\module_fft\__init__.py:60 | automated_tests/ndarray\module_fft\__init__.py:68 | automated_tests/ndarray\module_fft\__init__.py:76 | automated_tests/ndarray\module_fft\__init__.py:83 | automated_tests/ndarray\module_fft\__init__.py:92 | automated_tests/ndarray\module_fft\__init__.py:104</div>
+</div>
+</div></div>
+<div id="exc-area"></div><div id="results"><div> <a id="force-collapse" href="#"> Collapse All</a> <a id="force-expand" href="#">Expand All</a></div><table id="resulttable"><thead><tr> <th colspan="2"> CPython </th> <th colspan="2"> Transcrypt </th> </tr><tr> <th class="header-pos"> Location </th> <th class="header-val"> Value </th> <th class="header-val"> Value </th> <th class="header-pos"> Location </th> </tr></thead><tbody></tbody></table></div><script src="__javascript__/autotest.min.js"></script>
+
+</body></html>
\ No newline at end of file
diff --git a/numscrypt/development/automated_tests/ndarray/basics/__javascript__/__init__.mod.js b/numscrypt/development/automated_tests/ndarray/basics/__javascript__/__init__.mod.js
new file mode 100644
index 0000000..f101b38
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/basics/__javascript__/__init__.mod.js
@@ -0,0 +1,177 @@
+	__nest__ (
+		__all__,
+		'basics', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'basics';
+					if (__envir__.executor_name == __envir__.transpiler_name) {
+						var num =  __init__ (__world__.numscrypt);
+					}
+					var run = function (autoTester) {
+						var z = num.zeros (tuple ([4, 3]), 'int32');
+						autoTester.check ('Zeros', z.tolist (), '<br>');
+						var o = num.ones (tuple ([4, 5]));
+						autoTester.check ('Ones', o.astype ('int32').tolist ());
+						var i = num.identity (3, 'int32');
+						autoTester.check ('Identity', i.tolist (), '<br>');
+						var a = num.array (list ([list ([1, 1, 2, 3]), list ([4, 5, 6, 7]), list ([8, 9, 10, 12])]));
+						autoTester.check ('Matrix a', a.tolist (), '<br>');
+						autoTester.check ('Transpose of a', a.transpose ().tolist (), '<br>');
+						var b = num.array (list ([list ([2, 2, 4, 6]), list ([8, 10, 12, 14]), list ([16, 18, 20, 24])]));
+						var bp = b.transpose ();
+						autoTester.check ('Matrix b', b.tolist (), '<br>');
+						autoTester.check ('Permutation of b', bp.tolist (), '<br>');
+						var c = num.array (list ([list ([1, 2, 3, 4]), list ([5, 6, 7, 8]), list ([9, 10, 11, 12])]), 'int32');
+						autoTester.check ('Shape c', tuple (c.shape), '<br>');
+						autoTester.check ('Matrix c', c.tolist (), '<br>');
+						var ct = c.transpose ();
+						autoTester.check ('Shape ct', tuple (ct.shape), '<br>');
+						autoTester.check ('Transpose of c', ct.tolist (), '<br>');
+						var __left0__ = num.hsplit (c, 2);
+						var cs0 = __left0__ [0];
+						var cs1 = __left0__ [1];
+						autoTester.check ('Matrix cs0', cs0.tolist (), '<br>');
+						autoTester.check ('Matrix cs1', cs1.tolist (), '<br>');
+						var ci = num.hstack (tuple ([cs1, cs0]));
+						autoTester.check ('Matrix ci', ci.tolist (), '<br>');
+						var __left0__ = num.hsplit (ct, 3);
+						var cts0 = __left0__ [0];
+						var cts1 = __left0__ [1];
+						var cts2 = __left0__ [2];
+						autoTester.check ('Matrix cts0', cts0.tolist (), '<br>');
+						autoTester.check ('Matrix cts1', cts1.tolist (), '<br>');
+						autoTester.check ('Matrix cts2', cts2.tolist (), '<br>');
+						var cti = num.hstack (tuple ([cts2, cts1, cts0]));
+						autoTester.check ('Matrix ci', cti.tolist (), '<br>');
+						var d = num.array (list ([list ([13, 14]), list ([15, 16]), list ([17, 18]), list ([19, 20])]), 'int32');
+						autoTester.check ('Matrix d', d.tolist (), '<br>');
+						var dt = d.transpose ();
+						autoTester.check ('Permutation of d', dt.tolist (), '<br>');
+						var __left0__ = num.vsplit (d, 4);
+						var ds0 = __left0__ [0];
+						var ds1 = __left0__ [1];
+						var ds2 = __left0__ [2];
+						var ds3 = __left0__ [3];
+						autoTester.check ('Matrix ds0', ds0.tolist (), '<br>');
+						autoTester.check ('Matrix ds1', ds1.tolist (), '<br>');
+						autoTester.check ('Matrix ds2', ds2.tolist (), '<br>');
+						autoTester.check ('Matrix ds3', ds3.tolist (), '<br>');
+						var di = num.vstack (tuple ([ds3, ds2, ds1, ds0]));
+						autoTester.check ('Matrix di', di.tolist (), '<br>');
+						var __left0__ = num.vsplit (dt, 2);
+						var dts0 = __left0__ [0];
+						var dts1 = __left0__ [1];
+						autoTester.check ('Matrix dts0', dts0.tolist (), '<br>');
+						autoTester.check ('Matrix dts1', dts1.tolist (), '<br>');
+						var dti = num.vstack (tuple ([dts1, dts0]));
+						autoTester.check ('Matrix dti', dti.tolist (), '<br>');
+						var v0 = num.array (range (10));
+						var v1 = num.array (tuple ([1, 2, 3, 1, 2, 3, 1, 2, 3, 1]));
+						a.__setitem__ ([1, 0], 177);
+						var el = b.__getitem__ ([1, 2]);
+						var bsl0 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl1 = b.__getitem__ ([tuple ([1, 2, 1]), tuple ([1, 3, 1])]);
+						var bsl2 = b.__getitem__ ([tuple ([1, 2, 1]), 1]);
+						var bsl3 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl4 = b.__getitem__ ([tuple ([0, null, 1]), 1]);
+						var bsl5 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl6 = b.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bsl7 = b.__getitem__ ([1, tuple ([2, 3, 1])]);
+						var bpsl0 = bp.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bpsl1 = bp.__getitem__ ([tuple ([1, 2, 1]), tuple ([1, 3, 1])]);
+						var bpsl2 = bp.__getitem__ ([1, tuple ([0, null, 1])]);
+						var bpsl3 = bp.__getitem__ ([1, tuple ([1, 3, 1])]);
+						var bpsl4 = bp.__getitem__ ([tuple ([0, null, 1]), 1]);
+						var bpsl5 = bp.__getitem__ ([3, tuple ([1, 3, 1])]);
+						var bpsl6 = bp.__getitem__ ([tuple ([2, 4, 1]), tuple ([1, 3, 1])]);
+						var bpsl7 = bp.__getitem__ ([tuple ([2, 4, 1]), tuple ([2, 3, 1])]);
+						var sum = __add__ (a, b);
+						var dif = __sub__ (a, b);
+						var prod = __mul__ (a, b);
+						var quot = __truediv__ (a, b);
+						var dot = __matmul__ (c, d);
+						var vsum = __add__ (v0, v1);
+						var vel = __getitem__ (vsum, 6);
+						__setitem__ (vsum, 6, 70);
+						var mul_a3 = __mul__ (a, 3);
+						var mul_3a = __mul__ (3, a);
+						var div_a3 = __truediv__ (a, 3.1234567);
+						var div_3a = __truediv__ (3.1234567, a);
+						var add_a3 = __add__ (a, 3);
+						var add_3a = __add__ (3, a);
+						var sub_a3 = __sub__ (a, 3);
+						var sub_3a = __sub__ (3, a);
+						var neg_a = __neg__ (a);
+						autoTester.check ('El a [1, 2, 3] alt', a.tolist (), '<br>');
+						autoTester.check ('El b [1, 2, 3]', el, '<br>');
+						autoTester.check ('Sl b0', bsl0.tolist (), '<br>');
+						autoTester.check ('Sl b1', bsl1.tolist (), '<br>');
+						autoTester.check ('Sl b2', bsl2.tolist (), '<br>');
+						autoTester.check ('Sl b3', bsl3.tolist (), '<br>');
+						autoTester.check ('Sl b4', bsl4.tolist (), '<br>');
+						autoTester.check ('Sl b5', bsl5.tolist (), '<br>');
+						autoTester.check ('Sl b6', bsl6.tolist (), '<br>');
+						autoTester.check ('Sl b7', bsl7.tolist (), '<br>');
+						autoTester.check ('Sl bp0', bpsl0.tolist (), '<br>');
+						autoTester.check ('Sl bp1', bpsl1.tolist (), '<br>');
+						autoTester.check ('Sl bp2', bpsl2.tolist (), '<br>');
+						autoTester.check ('Sl bp3', bpsl3.tolist (), '<br>');
+						autoTester.check ('Sl bp4', bpsl4.tolist (), '<br>');
+						autoTester.check ('Sl bp5', bpsl5.tolist (), '<br>');
+						autoTester.check ('Sl bp6', bpsl6.tolist (), '<br>');
+						autoTester.check ('Sl bp7', bpsl7.tolist (), '<br>');
+						autoTester.check ('Matrix sum', sum.tolist (), '<br>');
+						autoTester.check ('Matrix difference', dif.tolist (), '<br>');
+						autoTester.check ('Matrix product', prod.tolist (), '<br>');
+						autoTester.check ('Matrix quotient', quot.tolist (), '<br>');
+						autoTester.check ('Matrix dotproduct', dot.tolist (), '<br>');
+						autoTester.check ('Vector', v0.tolist (), '<br>');
+						autoTester.check ('Vector', v1.tolist (), '<br>');
+						autoTester.check ('El sum old', vel, '<br>');
+						autoTester.check ('Vector sum new', vsum.tolist (), '<br>');
+						autoTester.check ('mul_a3', mul_a3.tolist (), '<br>');
+						autoTester.check ('mul_3a', mul_3a.tolist (), '<br>');
+						autoTester.check ('div_a3', num.round (div_a3, 2).tolist (), '<br>');
+						autoTester.check ('div_3a', num.round (div_3a, 2).tolist (), '<br>');
+						autoTester.check ('add_a3', add_a3.tolist (), '<br>');
+						autoTester.check ('add_3a', add_3a.tolist (), '<br>');
+						autoTester.check ('sub_a3', sub_a3.tolist (), '<br>');
+						autoTester.check ('sub_3a', sub_3a.tolist (), '<br>');
+						autoTester.check ('neg_a', neg_a.tolist (), '<br>');
+						var comp_a = __call__ (num.array, num, list ([list ([__add__ (1, complex (0, 2.0)), __sub__ (2, complex (0, 1.0)), 3]), list ([4, __add__ (5, complex (0, 3.0)), 7])]), 'complex128');
+						var comp_b = __call__ (num.array, num, list ([list ([6, __sub__ (8, complex (0, 1.0))]), list ([__add__ (9, complex (0, 3.0)), 10]), list ([11, __sub__ (12, complex (0, 6.0))])]), 'complex128');
+						var comp_c = __matmul__ (comp_a, comp_b);
+						autoTester.check ('comp_a', comp_a.tolist (), '<br>');
+						autoTester.check ('comp_b', comp_b.tolist (), '<br>');
+						autoTester.check ('comp_c', comp_c.tolist (), '<br>');
+						var comp_a_square = comp_a.__getitem__ ([tuple ([0, null, 1]), tuple ([0, 2, 1])]);
+						var comp_b_square = comp_b.__getitem__ ([tuple ([1, null, 1]), tuple ([0, null, 1])]);
+						var comp_c_square = __mul__ (comp_a_square, comp_b_square);
+						var comp_d_square = __truediv__ (comp_a_square, comp_b_square);
+						var comp_e_square = __add__ (comp_a_square, comp_b_square);
+						var comp_f_square = __sub__ (comp_a_square, comp_b_square);
+						autoTester.check ('comp_a_square', comp_a_square.tolist (), '<br>');
+						autoTester.check ('comp_b_square', comp_b_square.tolist (), '<br>');
+						autoTester.check ('comp_c_square', comp_c_square.tolist (), '<br>');
+						autoTester.check ('comp_d_square', num.round (comp_d_square, 2).tolist (), '<br>');
+						autoTester.check ('comp_e_square', comp_e_square.tolist (), '<br>');
+						autoTester.check ('comp_f_square', comp_f_square.tolist (), '<br>');
+						var sliceable_a = __call__ (num.array, num, list ([list ([1, 2, 3, 4]), list ([5, 6, 7, 8]), list ([9, 10, 11, 12]), list ([13, 14, 15, 16])]));
+						__call__ (autoTester.check, autoTester, 'sliceable_a', __call__ (sliceable_a.tolist, sliceable_a));
+						var slice_a = sliceable_a.__getitem__ ([tuple ([1, null, 1]), tuple ([1, null, 1])]);
+						__call__ (autoTester.check, autoTester, 'slice_a');
+						var sliceable_at = __call__ (sliceable_a.transpose, sliceable_a);
+						var slice_at = __getslice__ (sliceable_at, 1, null, 1);
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.run = run;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
diff --git a/numscrypt/development/automated_tests/ndarray/module_fft/__javascript__/__init__.mod.js b/numscrypt/development/automated_tests/ndarray/module_fft/__javascript__/__init__.mod.js
new file mode 100644
index 0000000..6e3edf8
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/module_fft/__javascript__/__init__.mod.js
@@ -0,0 +1,113 @@
+	__nest__ (
+		__all__,
+		'module_fft', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'module_fft';
+					var sin = __init__ (__world__.math).sin;
+					var cos = __init__ (__world__.math).cos;
+					var pi = __init__ (__world__.math).pi;
+					var transpiled = __envir__.executor_name == __envir__.transpiler_name;
+					if (__envir__.executor_name == __envir__.transpiler_name) {
+						var num =  __init__ (__world__.numscrypt);
+						var fft =  __init__ (__world__.numscrypt.fft);
+					}
+					var fSample = 4096;
+					var tTotal = 2;
+					var fSin = 30;
+					var fCos = 50;
+					var getNow = function () {
+						return new Date ();
+					};
+					var tCurrent = function (iCurrent) {
+						return iCurrent / fSample;
+					};
+					var run = function (autoTester) {
+						var delta = __add__ (0.001, complex (0, 0.001));
+						autoTester.check ('<br>------ 1D ------<br>');
+						var cut = 102;
+						autoTester.check ('Samples computed: {}<br>'.format (tTotal * fSample));
+						autoTester.check ('Samples shown: {}<br>'.format (cut));
+						var orig = num.array ((function () {
+							var __accu0__ = [];
+							for (var t of (function () {
+								var __accu1__ = [];
+								for (var iSample = 0; iSample < tTotal * fSample; iSample++) {
+									__accu1__.append (iSample / fSample);
+								}
+								return __accu1__;
+							}) ()) {
+								__accu0__.append (complex ((0.3 + sin (((2 * pi) * fSin) * t)) + 0.5 * cos (((2 * pi) * fCos) * t), 0));
+							}
+							return __accu0__;
+						}) (), 'complex128');
+						__call__ (autoTester.check, autoTester, 'Original samples', __getslice__ (__call__ (__call__ (num.round, num, __add__ (orig, delta), 3).tolist, __call__ (num.round, num, __add__ (orig, delta), 3)), 0, cut, 1), '<br>');
+						if (transpiled) {
+							var timeStartFft = __call__ (getNow, null);
+						}
+						var freqs = __call__ (fft.fft, fft, orig);
+						if (transpiled) {
+							var timeStopFft = __call__ (getNow, null);
+						}
+						__call__ (autoTester.check, autoTester, 'Frequencies', __getslice__ (__call__ (__call__ (num.round, num, __add__ (freqs, delta), 3).tolist, __call__ (num.round, num, __add__ (freqs, delta), 3)), 0, cut, 1), '<br>');
+						if (transpiled) {
+							var timeStartIfft = __call__ (getNow, null);
+						}
+						var reconstr = __call__ (fft.ifft, fft, freqs);
+						if (transpiled) {
+							var timeStopIfft = __call__ (getNow, null);
+						}
+						__call__ (autoTester.check, autoTester, 'Reconstructed samples', __getslice__ (__call__ (__call__ (num.round, num, __add__ (reconstr, delta), 3).tolist, __call__ (num.round, num, __add__ (reconstr, delta), 3)), 0, cut, 1), '<br>');
+						if (transpiled) {
+							print ('FFT for {} samples took {} ms'.format (tTotal * fSample, timeStopFft - timeStartFft));
+							print ('IFFT for {} samples took {} ms'.format (tTotal * fSample, timeStopIfft - timeStartIfft));
+						}
+						autoTester.check ('<br>------ 2D ------<br>');
+						var orig2 = __call__ (num.zeros, num, tuple ([128, 128]), 'complex128');
+						orig2.__setitem__ ([tuple ([32, 96, 1]), tuple ([32, 96, 1])], __call__ (num.ones, num, tuple ([64, 64]), 'complex128'));
+						__call__ (autoTester.check, autoTester, 'Original samples', __call__ (__call__ (num.round, num, __add__ (orig2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])]).tolist, __call__ (num.round, num, __add__ (orig2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])])), '<br>');
+						if (transpiled) {
+							var timeStartFft = __call__ (getNow, null);
+						}
+						var freqs2 = __call__ (fft.fft2, fft, orig2);
+						if (transpiled) {
+							var timeStopFft = __call__ (getNow, null);
+						}
+						__call__ (autoTester.check, autoTester, 'Frequencies', __call__ (__call__ (num.round, num, __add__ (freqs2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])]).tolist, __call__ (num.round, num, __add__ (freqs2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])])), '<br>');
+						if (transpiled) {
+							var timeStartIfft = __call__ (getNow, null);
+						}
+						var reconstr2 = __call__ (fft.ifft2, fft, freqs2);
+						if (transpiled) {
+							var timeStopIfft = __call__ (getNow, null);
+						}
+						if (transpiled) {
+							__call__ (print, null, __call__ ('FFT2 for {} samples took {} ms'.format, 'FFT2 for {} samples took {} ms', orig2.size, __sub__ (timeStopFft, timeStartFft)));
+							__call__ (print, null, __call__ ('IFFT2 for {} samples took {} ms'.format, 'IFFT2 for {} samples took {} ms', orig2.size, __sub__ (timeStopIfft, timeStartIfft)));
+						}
+						__call__ (autoTester.check, autoTester, 'Reconstructed samples', __call__ (__call__ (num.round, num, __add__ (reconstr2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])]).tolist, __call__ (num.round, num, __add__ (reconstr2, delta), 3).__getitem__ ([tuple ([64, 68, 1]), tuple ([16, 112, 1])])), '<br>');
+					};
+					__pragma__ ('<use>' +
+						'math' +
+						'numscrypt' +
+						'numscrypt.fft' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.cos = cos;
+						__all__.fCos = fCos;
+						__all__.fSample = fSample;
+						__all__.fSin = fSin;
+						__all__.getNow = getNow;
+						__all__.pi = pi;
+						__all__.run = run;
+						__all__.sin = sin;
+						__all__.tCurrent = tCurrent;
+						__all__.tTotal = tTotal;
+						__all__.transpiled = transpiled;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
diff --git a/numscrypt/development/automated_tests/ndarray/module_linalg/__javascript__/__init__.mod.js b/numscrypt/development/automated_tests/ndarray/module_linalg/__javascript__/__init__.mod.js
new file mode 100644
index 0000000..5314054
--- /dev/null
+++ b/numscrypt/development/automated_tests/ndarray/module_linalg/__javascript__/__init__.mod.js
@@ -0,0 +1,58 @@
+	__nest__ (
+		__all__,
+		'module_linalg', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'module_linalg';
+					if (__envir__.executor_name == __envir__.transpiler_name) {
+						var num =  __init__ (__world__.numscrypt);
+						var linalg =  __init__ (__world__.numscrypt.linalg);
+					}
+					var run = function (autoTester) {
+						var r = num.array (list ([list ([2.12, -(2.11), -(1.23)]), list ([2.31, 1.14, 3.15]), list ([1.13, 1.98, 2.81])]));
+						autoTester.check ('Matrix r', num.round (r, 2).tolist (), '<br>');
+						var ri = linalg.inv (r);
+						autoTester.check ('Matrix ri', num.round (ri, 2).tolist (), '<br>');
+						var rid = __matmul__ (r, ri);
+						autoTester.check ('r @ ri', (function () {
+							var __accu0__ = [];
+							for (var row of rid.tolist ()) {
+								__accu0__.append ((function () {
+									var __accu1__ = [];
+									for (var elem of row) {
+										__accu1__.append (int (round (elem)));
+									}
+									return __accu1__;
+								}) ());
+							}
+							return __accu0__;
+						}) (), '<br>');
+						var delta = 0.001;
+						__call__ (autoTester.check, autoTester, 'r * r', __call__ (__call__ (num.round, num, __add__ (__mul__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__mul__ (r, r), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'r / r', __call__ (__call__ (num.round, num, __add__ (__truediv__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__truediv__ (r, r), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'r + r', __call__ (__call__ (num.round, num, __add__ (__add__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__add__ (r, r), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'r - r', __call__ (__call__ (num.round, num, __add__ (__sub__ (r, r), delta), 3).tolist, __call__ (num.round, num, __add__ (__sub__ (r, r), delta), 3)), '<br>');
+						var c = __call__ (num.array, num, list ([list ([__sub__ (2.12, complex (0, 3.15)), __neg__ (2.11), __neg__ (1.23)]), list ([2.31, 1.14, __add__ (3.15, complex (0, 2.75))]), list ([1.13, __sub__ (1.98, complex (0, 4.33)), 2.81])]), 'complex128');
+						autoTester.check ('Matrix c', num.round (c, 2).tolist (), '<br>');
+						var ci = linalg.inv (c);
+						autoTester.check ('Matrix ci', num.round (ci, 2).tolist (), '<br>');
+						var cid = __matmul__ (c, ci);
+						var delta = __add__ (0.001, complex (0, 0.001));
+						__call__ (autoTester.check, autoTester, 'c * c', __call__ (__call__ (num.round, num, __add__ (__mul__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__mul__ (c, c), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'c / c', __call__ (__call__ (num.round, num, __add__ (__truediv__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__truediv__ (c, c), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'c + c', __call__ (__call__ (num.round, num, __add__ (__add__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__add__ (c, c), delta), 3)), '<br>');
+						__call__ (autoTester.check, autoTester, 'c - c', __call__ (__call__ (num.round, num, __add__ (__sub__ (c, c), delta), 3).tolist, __call__ (num.round, num, __add__ (__sub__ (c, c), delta), 3)), '<br>');
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+						'numscrypt.linalg' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.run = run;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
diff --git a/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.js b/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.js
new file mode 100644
index 0000000..0510897
--- /dev/null
+++ b/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.js
@@ -0,0 +1,4324 @@
+"use strict";
+// Transcrypt'ed from Python, 2017-12-30 21:58:07
+function test () {
+   var __symbols__ = ['__complex__', '__py3.6__', '__esv6__'];
+    var __all__ = {};
+    var __world__ = __all__;
+    
+    /* Nested module-object creator, part of the nesting may already exist and have attributes
+    
+    A Transcrypt applicaton consists of a main module and additional modules.
+    Transcrypt modules constitute a unique, unambigous tree by their dotted names, no matter which of the alternative module root paths they come from.
+    The main module is represented by a main function by the name of the application.
+    The locals of this function constitute the outer namespace of the Transcrypt application.
+    References to all local variables of this function are also assigned to attributes of local variable __all__, using the variable names as an attribute names.
+    The main function returns this local variable __all__ (that inside the function is also known by the name __world__)
+    Normally this function result is assigned to window.<application name>.
+    The function may than be exited (unless its main line starts an ongoing activity), but the application namespace stays alive tby the reference that window has to it.
+    In case of the ongoing activity including the script is enough to start it, in other cases it has to be started explicitly by calling window.<application name>.<a function>.
+    There may be multiple such entrypoint functions.
+    
+    Additional modules are represented by objects rather than functions, nested into __world__ (so into __all__ of the main function).
+    This nesting can be directly or indirectly, according to the dotted paths of the additional modules.
+    One of the methods of the module object is the __init__ function, that's executed once at module initialisation time.
+    
+    The additional modues also have an __all__ variable, an attribute rather than a local variable.
+    However this __all__ object is passed to the __init__ function, so becomes a local variable there.
+    Variables in additional modules first become locals to the __init__ function but references to all of them are assigend to __all__ under their same names.
+    This resembles the cause of affairs in the main function.
+    However __world__ only referes to the __all__ of the main module, not of any additional modules.
+    Importing a module boils down to adding all members of its __all__ to the local namespace, directly or via dotted access, depending on the way of import.
+    
+    In each local namespace of the module function (main function for main module, __init__ for additional modules) there's a variable __name__ holding the name of the module.
+    Classes are created inside the static scope of a particular module, and at that (class creation) time their variable __module__ gets assigned a reference to __name__.
+    This assignement is generated explicitly by the compiler, as the class creation function __new__ of the metaclass isn't in the static scope containing __name__.
+    
+    In case of
+        import a
+        import a.b
+    a will have been created at the moment that a.b is imported,
+    so all a.b. is allowed to do is an extra attribute in a, namely a reference to b,
+    not recreate a, since that would destroy attributes previously present in a
+    
+    In case of
+        import a.b
+        import a
+    a will have to be created at the moment that a.b is imported
+    
+    In general in a chain
+        import a.b.c.d.e
+    a, a.b, a.b.c and a.b.c.d have to exist before e is created, since a.b.c.d should hold a reference to e.
+    Since this applies recursively, if e.g. c is already created, we can be sure a and a.b. will also be already created.
+    
+    So to be able to create e, we'll have to walk the chain a.b.c.d, starting with a.
+    As soon as we encounter a module in the chain that isn't already there, we'll have to create the remainder (tail) of the chain.
+    
+    e.g.
+        import a.b.c.d.e
+        import a.b.c
+    
+    will generate
+        var modules = {};
+        __nest__ (a, 'b.c.d.e', __init__ (__world__.a.b.c.d.e));
+        __nest__ (a, 'b.c', __init__ (__world__.a.b.c));
+        
+    The task of the __nest__ function is to start at the head object and then walk to the chain of objects behind it (tail),
+    creating the ones that do not exist already, and insert the necessary module reference attributes into them.   
+    */
+    
+    var __nest__ = function (headObject, tailNames, value) {    
+        var current = headObject;
+        // In some cases this will be <main function>.__all__,
+        // which is the main module and is also known under the synonym <main function.__world__.
+        // N.B. <main function> is the entry point of a Transcrypt application,
+        // Carrying the same name as the application except the file name extension.
+        
+        if (tailNames != '') {  // Split on empty string doesn't give empty list
+            // Find the last already created object in tailNames
+            var tailChain = tailNames.split ('.');
+            var firstNewIndex = tailChain.length;
+            for (var index = 0; index < tailChain.length; index++) {
+                if (!current.hasOwnProperty (tailChain [index])) {
+                    firstNewIndex = index;
+                    break;
+                }
+                current = current [tailChain [index]];
+            }
+            
+            // Create the rest of the objects, if any
+            for (var index = firstNewIndex; index < tailChain.length; index++) {
+                current [tailChain [index]] = {};
+                current = current [tailChain [index]];
+            }
+        }
+        
+        // Insert it new attributes, it may have been created earlier and have other attributes
+        for (var attrib in value) {
+            current [attrib] = value [attrib];          
+        }       
+    };
+    __all__.__nest__ = __nest__;
+    
+    // Initialize module if not yet done and return its globals
+    var __init__ = function (module) {
+        if (!module.__inited__) {
+            module.__all__.__init__ (module.__all__);
+            module.__inited__ = true;
+        }
+        return module.__all__;
+    };
+    __all__.__init__ = __init__;
+    
+    
+    // Proxy switch, controlled by __pragma__ ('proxy') and __pragma ('noproxy')
+    var __proxy__ = false;  // No use assigning it to __all__, only its transient state is important
+    
+    
+    // Since we want to assign functions, a = b.f should make b.f produce a bound function
+    // So __get__ should be called by a property rather then a function
+    // Factory __get__ creates one of three curried functions for func
+    // Which one is produced depends on what's to the left of the dot of the corresponding JavaScript property
+    var __get__ = function (self, func, quotedFuncName) {
+        if (self) {
+            if (self.hasOwnProperty ('__class__') || typeof self == 'string' || self instanceof String) {           // Object before the dot
+                if (quotedFuncName) {                                   // Memoize call since fcall is on, by installing bound function in instance
+                    Object.defineProperty (self, quotedFuncName, {      // Will override the non-own property, next time it will be called directly
+                        value: function () {                            // So next time just call curry function that calls function
+                            var args = [] .slice.apply (arguments);
+                            return func.apply (null, [self] .concat (args));
+                        },              
+                        writable: true,
+                        enumerable: true,
+                        configurable: true
+                    });
+                }
+                return function () {                                    // Return bound function, code dupplication for efficiency if no memoizing
+                    var args = [] .slice.apply (arguments);             // So multilayer search prototype, apply __get__, call curry func that calls func
+                    return func.apply (null, [self] .concat (args));
+                };
+            }
+            else {                                                      // Class before the dot
+                return func;                                            // Return static method
+            }
+        }
+        else {                                                          // Nothing before the dot
+            return func;                                                // Return free function
+        }
+    }
+    __all__.__get__ = __get__;
+
+    var __getcm__ = function (self, func, quotedFuncName) {
+        if (self.hasOwnProperty ('__class__')) {
+            return function () {
+                var args = [] .slice.apply (arguments);
+                return func.apply (null, [self.__class__] .concat (args));
+            };
+        }
+        else {
+            return function () {
+                var args = [] .slice.apply (arguments);
+                return func.apply (null, [self] .concat (args));
+            };
+        }
+    }
+    __all__.__getcm__ = __getcm__;
+    
+    var __getsm__ = function (self, func, quotedFuncName) {
+        return func;
+    }
+    __all__.__getsm__ = __getsm__;
+        
+    // Mother of all metaclasses        
+    var py_metatype = {
+        __name__: 'type',
+        __bases__: [],
+        
+        // Overridable class creation worker
+        __new__: function (meta, name, bases, attribs) {
+            // Create the class cls, a functor, which the class creator function will return
+            var cls = function () {                     // If cls is called with arg0, arg1, etc, it calls its __new__ method with [arg0, arg1, etc]
+                var args = [] .slice.apply (arguments); // It has a __new__ method, not yet but at call time, since it is copied from the parent in the loop below
+                return cls.__new__ (args);              // Each Python class directly or indirectly derives from object, which has the __new__ method
+            };                                          // If there are no bases in the Python source, the compiler generates [object] for this parameter
+            
+            // Copy all methods, including __new__, properties and static attributes from base classes to new cls object
+            // The new class object will simply be the prototype of its instances
+            // JavaScript prototypical single inheritance will do here, since any object has only one class
+            // This has nothing to do with Python multiple inheritance, that is implemented explictly in the copy loop below
+            for (var index = bases.length - 1; index >= 0; index--) {   // Reversed order, since class vars of first base should win
+                var base = bases [index];
+                for (var attrib in base) {
+                    var descrip = Object.getOwnPropertyDescriptor (base, attrib);
+                    Object.defineProperty (cls, attrib, descrip);
+                }           
+
+                for (var symbol of Object.getOwnPropertySymbols (base)) {
+                    var descrip = Object.getOwnPropertyDescriptor (base, symbol);
+                    Object.defineProperty (cls, symbol, descrip);
+                }
+                
+            }
+            
+            // Add class specific attributes to the created cls object
+            cls.__metaclass__ = meta;
+            cls.__name__ = name.startsWith ('py_') ? name.slice (3) : name;
+            cls.__bases__ = bases;
+            
+            // Add own methods, properties and own static attributes to the created cls object
+            for (var attrib in attribs) {
+                var descrip = Object.getOwnPropertyDescriptor (attribs, attrib);
+                Object.defineProperty (cls, attrib, descrip);
+            }
+
+            for (var symbol of Object.getOwnPropertySymbols (attribs)) {
+                var descrip = Object.getOwnPropertyDescriptor (attribs, symbol);
+                Object.defineProperty (cls, symbol, descrip);
+            }
+            
+            // Return created cls object
+            return cls;
+        }
+    };
+    py_metatype.__metaclass__ = py_metatype;
+    __all__.py_metatype = py_metatype;
+    
+    // Mother of all classes
+    var object = {
+        __init__: function (self) {},
+        
+        __metaclass__: py_metatype, // By default, all classes have metaclass type, since they derive from object
+        __name__: 'object',
+        __bases__: [],
+            
+        // Object creator function, is inherited by all classes (so could be global)
+        __new__: function (args) {  // Args are just the constructor args       
+            // In JavaScript the Python class is the prototype of the Python object
+            // In this way methods and static attributes will be available both with a class and an object before the dot
+            // The descriptor produced by __get__ will return the right method flavor
+            var instance = Object.create (this, {__class__: {value: this, enumerable: true}});
+            
+            if ('__getattr__' in this || '__setattr__' in this) {
+                instance = new Proxy (instance, {
+                    get: function (target, name) {
+                        var result = target [name];
+                        if (result == undefined) {  // Target doesn't have attribute named name
+                            return target.__getattr__ (name);
+                        }
+                        else {
+                            return result;
+                        }
+                    },
+                    set: function (target, name, value) {
+                        try {
+                            target.__setattr__ (name, value);
+                        }
+                        catch (exception) {         // Target doesn't have a __setattr__ method
+                            target [name] = value;
+                        }
+                        return true;
+                    }
+                })
+            }
+
+            // Call constructor
+            this.__init__.apply (null, [instance] .concat (args));
+
+            // Return constructed instance
+            return instance;
+        }   
+    };
+    __all__.object = object;
+    
+    // Class creator facade function, calls class creation worker
+    var __class__ = function (name, bases, attribs, meta) {         // Parameter meta is optional
+        if (meta == undefined) {
+            meta = bases [0] .__metaclass__;
+        }
+                
+        return meta.__new__ (meta, name, bases, attribs);
+    }
+    __all__.__class__ = __class__;
+    
+    // Define __pragma__ to preserve '<all>' and '</all>', since it's never generated as a function, must be done early, so here
+    var __pragma__ = function () {};
+    __all__.__pragma__ = __pragma__;
+    
+    	__nest__ (
+		__all__,
+		'org.transcrypt.__base__', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'org.transcrypt.__base__';
+					var __Envir__ = __class__ ('__Envir__', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							self.interpreter_name = 'python';
+							self.transpiler_name = 'transcrypt';
+							self.transpiler_version = '3.6.66';
+							self.target_subdir = '__javascript__';
+						}, '__init__');}
+					});
+					var __envir__ = __Envir__ ();
+					__pragma__ ('<all>')
+						__all__.__Envir__ = __Envir__;
+						__all__.__envir__ = __envir__;
+						__all__.__name__ = __name__;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'org.transcrypt.__standard__', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'org.transcrypt.__standard__';
+					var Exception = __class__ ('Exception', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							var kwargs = dict ();
+							if (arguments.length) {
+								var __ilastarg0__ = arguments.length - 1;
+								if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+									var __allkwargs0__ = arguments [__ilastarg0__--];
+									for (var __attrib0__ in __allkwargs0__) {
+										switch (__attrib0__) {
+											case 'self': var self = __allkwargs0__ [__attrib0__]; break;
+											default: kwargs [__attrib0__] = __allkwargs0__ [__attrib0__];
+										}
+									}
+									delete kwargs.__kwargtrans__;
+								}
+								var args = tuple ([].slice.apply (arguments).slice (1, __ilastarg0__ + 1));
+							}
+							else {
+								var args = tuple ();
+							}
+							self.__args__ = args;
+							try {
+								self.stack = kwargs.error.stack;
+							}
+							catch (__except0__) {
+								self.stack = 'No stack trace available';
+							}
+						}, '__init__');},
+						get __repr__ () {return __get__ (this, function (self) {
+							if (len (self.__args__)) {
+								return '{}{}'.format (self.__class__.__name__, repr (tuple (self.__args__)));
+							}
+							else {
+								return '{}()'.format (self.__class__.__name__);
+							}
+						}, '__repr__');},
+						get __str__ () {return __get__ (this, function (self) {
+							if (len (self.__args__) > 1) {
+								return str (tuple (self.__args__));
+							}
+							else if (len (self.__args__)) {
+								return str (self.__args__ [0]);
+							}
+							else {
+								return '';
+							}
+						}, '__str__');}
+					});
+					var IterableError = __class__ ('IterableError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, error) {
+							Exception.__init__ (self, "Can't iterate over non-iterable", __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var StopIteration = __class__ ('StopIteration', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, error) {
+							Exception.__init__ (self, 'Iterator exhausted', __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var ValueError = __class__ ('ValueError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var KeyError = __class__ ('KeyError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var AssertionError = __class__ ('AssertionError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							if (message) {
+								Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+							}
+							else {
+								Exception.__init__ (self, __kwargtrans__ ({error: error}));
+							}
+						}, '__init__');}
+					});
+					var NotImplementedError = __class__ ('NotImplementedError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var IndexError = __class__ ('IndexError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var AttributeError = __class__ ('AttributeError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var py_TypeError = __class__ ('py_TypeError', [Exception], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, message, error) {
+							Exception.__init__ (self, message, __kwargtrans__ ({error: error}));
+						}, '__init__');}
+					});
+					var Warning = __class__ ('Warning', [Exception], {
+						__module__: __name__,
+					});
+					var UserWarning = __class__ ('UserWarning', [Warning], {
+						__module__: __name__,
+					});
+					var DeprecationWarning = __class__ ('DeprecationWarning', [Warning], {
+						__module__: __name__,
+					});
+					var RuntimeWarning = __class__ ('RuntimeWarning', [Warning], {
+						__module__: __name__,
+					});
+					var __sort__ = function (iterable, key, reverse) {
+						if (typeof key == 'undefined' || (key != null && key .hasOwnProperty ("__kwargtrans__"))) {;
+							var key = null;
+						};
+						if (typeof reverse == 'undefined' || (reverse != null && reverse .hasOwnProperty ("__kwargtrans__"))) {;
+							var reverse = false;
+						};
+						if (arguments.length) {
+							var __ilastarg0__ = arguments.length - 1;
+							if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+								var __allkwargs0__ = arguments [__ilastarg0__--];
+								for (var __attrib0__ in __allkwargs0__) {
+									switch (__attrib0__) {
+										case 'iterable': var iterable = __allkwargs0__ [__attrib0__]; break;
+										case 'key': var key = __allkwargs0__ [__attrib0__]; break;
+										case 'reverse': var reverse = __allkwargs0__ [__attrib0__]; break;
+									}
+								}
+							}
+						}
+						else {
+						}
+						if (key) {
+							iterable.sort ((function __lambda__ (a, b) {
+								if (arguments.length) {
+									var __ilastarg0__ = arguments.length - 1;
+									if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+										var __allkwargs0__ = arguments [__ilastarg0__--];
+										for (var __attrib0__ in __allkwargs0__) {
+											switch (__attrib0__) {
+												case 'a': var a = __allkwargs0__ [__attrib0__]; break;
+												case 'b': var b = __allkwargs0__ [__attrib0__]; break;
+											}
+										}
+									}
+								}
+								else {
+								}
+								return (key (a) > key (b) ? 1 : -(1));
+							}));
+						}
+						else {
+							iterable.sort ();
+						}
+						if (reverse) {
+							iterable.reverse ();
+						}
+					};
+					var sorted = function (iterable, key, reverse) {
+						if (typeof key == 'undefined' || (key != null && key .hasOwnProperty ("__kwargtrans__"))) {;
+							var key = null;
+						};
+						if (typeof reverse == 'undefined' || (reverse != null && reverse .hasOwnProperty ("__kwargtrans__"))) {;
+							var reverse = false;
+						};
+						if (arguments.length) {
+							var __ilastarg0__ = arguments.length - 1;
+							if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+								var __allkwargs0__ = arguments [__ilastarg0__--];
+								for (var __attrib0__ in __allkwargs0__) {
+									switch (__attrib0__) {
+										case 'iterable': var iterable = __allkwargs0__ [__attrib0__]; break;
+										case 'key': var key = __allkwargs0__ [__attrib0__]; break;
+										case 'reverse': var reverse = __allkwargs0__ [__attrib0__]; break;
+									}
+								}
+							}
+						}
+						else {
+						}
+						if (py_typeof (iterable) == dict) {
+							var result = copy (iterable.py_keys ());
+						}
+						else {
+							var result = copy (iterable);
+						}
+						__sort__ (result, key, reverse);
+						return result;
+					};
+					var map = function (func, iterable) {
+						return (function () {
+							var __accu0__ = [];
+							for (var item of iterable) {
+								__accu0__.append (func (item));
+							}
+							return __accu0__;
+						}) ();
+					};
+					var filter = function (func, iterable) {
+						if (func == null) {
+							var func = bool;
+						}
+						return (function () {
+							var __accu0__ = [];
+							for (var item of iterable) {
+								if (func (item)) {
+									__accu0__.append (item);
+								}
+							}
+							return __accu0__;
+						}) ();
+					};
+					var complex = __class__ ('complex', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, real, imag) {
+							if (typeof imag == 'undefined' || (imag != null && imag .hasOwnProperty ("__kwargtrans__"))) {;
+								var imag = null;
+							};
+							if (imag == null) {
+								if (py_typeof (real) == complex) {
+									self.real = real.real;
+									self.imag = real.imag;
+								}
+								else {
+									self.real = real;
+									self.imag = 0;
+								}
+							}
+							else {
+								self.real = real;
+								self.imag = imag;
+							}
+						}, '__init__');},
+						get __neg__ () {return __get__ (this, function (self) {
+							return complex (-(self.real), -(self.imag));
+						}, '__neg__');},
+						get __exp__ () {return __get__ (this, function (self) {
+							var modulus = Math.exp (self.real);
+							return complex (modulus * Math.cos (self.imag), modulus * Math.sin (self.imag));
+						}, '__exp__');},
+						get __log__ () {return __get__ (this, function (self) {
+							return complex (Math.log (Math.sqrt (self.real * self.real + self.imag * self.imag)), Math.atan2 (self.imag, self.real));
+						}, '__log__');},
+						get __pow__ () {return __get__ (this, function (self, other) {
+							return self.__log__ ().__mul__ (other).__exp__ ();
+						}, '__pow__');},
+						get __rpow__ () {return __get__ (this, function (self, real) {
+							return self.__mul__ (Math.log (real)).__exp__ ();
+						}, '__rpow__');},
+						get __mul__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real * other, self.imag * other);
+							}
+							else {
+								return complex (self.real * other.real - self.imag * other.imag, self.real * other.imag + self.imag * other.real);
+							}
+						}, '__mul__');},
+						get __rmul__ () {return __get__ (this, function (self, real) {
+							return complex (self.real * real, self.imag * real);
+						}, '__rmul__');},
+						get __div__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real / other, self.imag / other);
+							}
+							else {
+								var denom = other.real * other.real + other.imag * other.imag;
+								return complex ((self.real * other.real + self.imag * other.imag) / denom, (self.imag * other.real - self.real * other.imag) / denom);
+							}
+						}, '__div__');},
+						get __rdiv__ () {return __get__ (this, function (self, real) {
+							var denom = self.real * self.real;
+							return complex ((real * self.real) / denom, (real * self.imag) / denom);
+						}, '__rdiv__');},
+						get __add__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real + other, self.imag);
+							}
+							else {
+								return complex (self.real + other.real, self.imag + other.imag);
+							}
+						}, '__add__');},
+						get __radd__ () {return __get__ (this, function (self, real) {
+							return complex (self.real + real, self.imag);
+						}, '__radd__');},
+						get __sub__ () {return __get__ (this, function (self, other) {
+							if (typeof other === 'number') {
+								return complex (self.real - other, self.imag);
+							}
+							else {
+								return complex (self.real - other.real, self.imag - other.imag);
+							}
+						}, '__sub__');},
+						get __rsub__ () {return __get__ (this, function (self, real) {
+							return complex (real - self.real, -(self.imag));
+						}, '__rsub__');},
+						get __repr__ () {return __get__ (this, function (self) {
+							return '({}{}{}j)'.format (self.real, (self.imag >= 0 ? '+' : ''), self.imag);
+						}, '__repr__');},
+						get __str__ () {return __get__ (this, function (self) {
+							return __repr__ (self).__getslice__ (1, -(1), 1);
+						}, '__str__');}
+					});
+					var __Terminal__ = __class__ ('__Terminal__', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self) {
+							self.buffer = '';
+							try {
+								self.element = document.getElementById ('__terminal__');
+							}
+							catch (__except0__) {
+								self.element = null;
+							}
+							if (self.element) {
+								self.element.style.overflowX = 'auto';
+								self.element.style.boxSizing = 'border-box';
+								self.element.style.padding = '5px';
+								self.element.innerHTML = '_';
+							}
+						}, '__init__');},
+						get print () {return __get__ (this, function (self) {
+							var sep = ' ';
+							var end = '\n';
+							if (arguments.length) {
+								var __ilastarg0__ = arguments.length - 1;
+								if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+									var __allkwargs0__ = arguments [__ilastarg0__--];
+									for (var __attrib0__ in __allkwargs0__) {
+										switch (__attrib0__) {
+											case 'self': var self = __allkwargs0__ [__attrib0__]; break;
+											case 'sep': var sep = __allkwargs0__ [__attrib0__]; break;
+											case 'end': var end = __allkwargs0__ [__attrib0__]; break;
+										}
+									}
+								}
+								var args = tuple ([].slice.apply (arguments).slice (1, __ilastarg0__ + 1));
+							}
+							else {
+								var args = tuple ();
+							}
+							self.buffer = '{}{}{}'.format (self.buffer, sep.join ((function () {
+								var __accu0__ = [];
+								for (var arg of args) {
+									__accu0__.append (str (arg));
+								}
+								return __accu0__;
+							}) ()), end).__getslice__ (-(4096), null, 1);
+							if (self.element) {
+								self.element.innerHTML = self.buffer.py_replace ('\n', '<br>').py_replace (' ', '&nbsp');
+								self.element.scrollTop = self.element.scrollHeight;
+							}
+							else {
+								console.log (sep.join ((function () {
+									var __accu0__ = [];
+									for (var arg of args) {
+										__accu0__.append (str (arg));
+									}
+									return __accu0__;
+								}) ()));
+							}
+						}, 'print');},
+						get input () {return __get__ (this, function (self, question) {
+							if (arguments.length) {
+								var __ilastarg0__ = arguments.length - 1;
+								if (arguments [__ilastarg0__] && arguments [__ilastarg0__].hasOwnProperty ("__kwargtrans__")) {
+									var __allkwargs0__ = arguments [__ilastarg0__--];
+									for (var __attrib0__ in __allkwargs0__) {
+										switch (__attrib0__) {
+											case 'self': var self = __allkwargs0__ [__attrib0__]; break;
+											case 'question': var question = __allkwargs0__ [__attrib0__]; break;
+										}
+									}
+								}
+							}
+							else {
+							}
+							self.print ('{}'.format (question), __kwargtrans__ ({end: ''}));
+							var answer = window.prompt ('\n'.join (self.buffer.py_split ('\n').__getslice__ (-(16), null, 1)));
+							self.print (answer);
+							return answer;
+						}, 'input');}
+					});
+					var __terminal__ = __Terminal__ ();
+					__pragma__ ('<all>')
+						__all__.AssertionError = AssertionError;
+						__all__.AttributeError = AttributeError;
+						__all__.DeprecationWarning = DeprecationWarning;
+						__all__.Exception = Exception;
+						__all__.IndexError = IndexError;
+						__all__.IterableError = IterableError;
+						__all__.KeyError = KeyError;
+						__all__.NotImplementedError = NotImplementedError;
+						__all__.RuntimeWarning = RuntimeWarning;
+						__all__.StopIteration = StopIteration;
+						__all__.py_TypeError = py_TypeError;
+						__all__.UserWarning = UserWarning;
+						__all__.ValueError = ValueError;
+						__all__.Warning = Warning;
+						__all__.__Terminal__ = __Terminal__;
+						__all__.__name__ = __name__;
+						__all__.__sort__ = __sort__;
+						__all__.__terminal__ = __terminal__;
+						__all__.complex = complex;
+						__all__.filter = filter;
+						__all__.map = map;
+						__all__.sorted = sorted;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+    var __call__ = function (/* <callee>, <this>, <params>* */) {   // Needed for __base__ and __standard__ if global 'opov' switch is on
+        var args = [] .slice.apply (arguments);
+        if (typeof args [0] == 'object' && '__call__' in args [0]) {        // Overloaded
+            return args [0] .__call__ .apply (args [1], args.slice (2));
+        }
+        else {                                                              // Native
+            return args [0] .apply (args [1], args.slice (2));
+        }
+    };
+    __all__.__call__ = __call__;
+
+    // Initialize non-nested modules __base__ and __standard__ and make its names available directly and via __all__
+    // They can't do that itself, because they're regular Python modules
+    // The compiler recognizes their names and generates them inline rather than nesting them
+    // In this way it isn't needed to import them everywhere
+
+    // __base__
+
+    __nest__ (__all__, '', __init__ (__all__.org.transcrypt.__base__));
+    var __envir__ = __all__.__envir__;
+
+    // __standard__
+
+    __nest__ (__all__, '', __init__ (__all__.org.transcrypt.__standard__));
+
+    var Exception = __all__.Exception;
+    var IterableError = __all__.IterableError;
+    var StopIteration = __all__.StopIteration;
+    var ValueError = __all__.ValueError;
+    var KeyError = __all__.KeyError;
+    var AssertionError = __all__.AssertionError;
+    var NotImplementedError = __all__.NotImplementedError;
+    var IndexError = __all__.IndexError;
+    var AttributeError = __all__.AttributeError;
+    var py_TypeError = __all__.py_TypeError;
+
+    // Warnings Exceptions
+    var Warning = __all__.Warning;
+    var UserWarning = __all__.UserWarning;
+    var DeprecationWarning = __all__.DeprecationWarning;
+    var RuntimeWarning = __all__.RuntimeWarning;
+
+    var __sort__ = __all__.__sort__;
+    var sorted = __all__.sorted;
+
+    var map = __all__.map;
+    var filter = __all__.filter;
+
+    var complex = __all__.complex;
+    __all__.print = __all__.__terminal__.print;
+    __all__.input = __all__.__terminal__.input;
+
+    var __terminal__ = __all__.__terminal__;
+    var print = __all__.print;
+    var input = __all__.input;
+
+    // Complete __envir__, that was created in __base__, for non-stub mode
+    __envir__.executor_name = __envir__.transpiler_name;
+
+    // Make make __main__ available in browser
+    var __main__ = {__file__: ''};
+    __all__.main = __main__;
+
+    // Define current exception, there's at most one exception in the air at any time
+    var __except__ = null;
+    __all__.__except__ = __except__;
+    
+     // Creator of a marked dictionary, used to pass **kwargs parameter
+    var __kwargtrans__ = function (anObject) {
+        anObject.__kwargtrans__ = null; // Removable marker
+        anObject.constructor = Object;
+        return anObject;
+    }
+    __all__.__kwargtrans__ = __kwargtrans__;
+
+    // 'Oneshot' dict promotor, used to enrich __all__ and help globals () return a true dict
+    var __globals__ = function (anObject) {
+        if (isinstance (anObject, dict)) {  // Don't attempt to promote (enrich) again, since it will make a copy
+            return anObject;
+        }
+        else {
+            return dict (anObject)
+        }
+    }
+    __all__.__globals__ = __globals__
+    
+    // Partial implementation of super () .<methodName> (<params>)
+    var __super__ = function (aClass, methodName) {
+        // Lean and fast, no C3 linearization, only call first implementation encountered
+        // Will allow __super__ ('<methodName>') (self, <params>) rather than only <className>.<methodName> (self, <params>)
+        
+        for (let base of aClass.__bases__) {
+            if (methodName in base) {
+               return base [methodName];
+            }
+        }
+
+        throw new Exception ('Superclass method not found');    // !!! Improve!
+    }
+    __all__.__super__ = __super__
+        
+    // Python property installer function, no member since that would bloat classes
+    var property = function (getter, setter) {  // Returns a property descriptor rather than a property
+        if (!setter) {  // ??? Make setter optional instead of dummy?
+            setter = function () {};
+        }
+        return {get: function () {return getter (this)}, set: function (value) {setter (this, value)}, enumerable: true};
+    }
+    __all__.property = property;
+    
+    // Conditional JavaScript property installer function, prevents redefinition of properties if multiple Transcrypt apps are on one page
+    var __setProperty__ = function (anObject, name, descriptor) {
+        if (!anObject.hasOwnProperty (name)) {
+            Object.defineProperty (anObject, name, descriptor);
+        }
+    }
+    __all__.__setProperty__ = __setProperty__
+    
+    // Assert function, call to it only generated when compiling with --dassert option
+    function assert (condition, message) {  // Message may be undefined
+        if (!condition) {
+            throw AssertionError (message, new Error ());
+        }
+    }
+
+    __all__.assert = assert;
+
+    var __merge__ = function (object0, object1) {
+        var result = {};
+        for (var attrib in object0) {
+            result [attrib] = object0 [attrib];
+        }
+        for (var attrib in object1) {
+            result [attrib] = object1 [attrib];
+        }
+        return result;
+    };
+    __all__.__merge__ = __merge__;
+
+    // Manipulating attributes by name
+    
+    var dir = function (obj) {
+        var aList = [];
+        for (var aKey in obj) {
+            aList.push (aKey);
+        }
+        aList.sort ();
+        return aList;
+    };
+    __all__.dir = dir;
+
+    var setattr = function (obj, name, value) {
+        obj [name] = value;
+    };
+    __all__.setattr = setattr;
+
+    var getattr = function (obj, name) {
+        return obj [name];
+    };
+    __all__.getattr= getattr;
+
+    var hasattr = function (obj, name) {
+        try {
+            return name in obj;
+        }
+        catch (exception) {
+            return false;
+        }
+    };
+    __all__.hasattr = hasattr;
+
+    var delattr = function (obj, name) {
+        delete obj [name];
+    };
+    __all__.delattr = (delattr);
+
+    // The __in__ function, used to mimic Python's 'in' operator
+    // In addition to CPython's semantics, the 'in' operator is also allowed to work on objects, avoiding a counterintuitive separation between Python dicts and JavaScript objects
+    // In general many Transcrypt compound types feature a deliberate blend of Python and JavaScript facilities, facilitating efficient integration with JavaScript libraries
+    // If only Python objects and Python dicts are dealt with in a certain context, the more pythonic 'hasattr' is preferred for the objects as opposed to 'in' for the dicts
+    var __in__ = function (element, container) {
+        if (py_typeof (container) == dict) {        // Currently only implemented as an augmented JavaScript object
+            return container.hasOwnProperty (element);
+        }
+        else {                                      // Parameter 'element' itself is an array, string or a plain, non-dict JavaScript object
+            return (
+                container.indexOf ?                 // If it has an indexOf
+                container.indexOf (element) > -1 :  // it's an array or a string,
+                container.hasOwnProperty (element)  // else it's a plain, non-dict JavaScript object
+            );
+        }
+    };
+    __all__.__in__ = __in__;
+
+    // Find out if an attribute is special
+    var __specialattrib__ = function (attrib) {
+        return (attrib.startswith ('__') && attrib.endswith ('__')) || attrib == 'constructor' || attrib.startswith ('py_');
+    };
+    __all__.__specialattrib__ = __specialattrib__;
+
+    // Compute length of any object
+    var len = function (anObject) {
+        if (anObject === undefined || anObject === null) {
+            return 0;
+        }
+
+        if (anObject.__len__ instanceof Function) {
+            return anObject.__len__ ();
+        }
+
+        if (anObject.length !== undefined) {
+            return anObject.length;
+        }
+
+        var length = 0;
+        for (var attr in anObject) {
+            if (!__specialattrib__ (attr)) {
+                length++;
+            }
+        }
+
+        return length;
+    };
+    __all__.len = len;
+
+    // General conversions and checks
+
+    function __i__ (any) {  //  Convert to iterable
+        return py_typeof (any) == dict ? any.py_keys () : any;
+    }
+
+    function __k__ (keyed, key) {  //  Check existence of dict key via retrieved element
+        var result = keyed [key];
+        if (typeof result == 'undefined') {
+             throw KeyError (key, new Error());
+        }
+        return result;
+    }
+
+    // If the target object is somewhat true, return it. Otherwise return false.
+    // Try to follow Python conventions of truthyness
+    function __t__ (target) { 
+        return (
+            // Avoid invalid checks
+            target === undefined || target === null ? false :
+            
+            // Take a quick shortcut if target is a simple type
+            ['boolean', 'number'] .indexOf (typeof target) >= 0 ? target :
+            
+            // Use __bool__ (if present) to decide if target is true
+            target.__bool__ instanceof Function ? (target.__bool__ () ? target : false) :
+            
+            // There is no __bool__, use __len__ (if present) instead
+            target.__len__ instanceof Function ?  (target.__len__ () !== 0 ? target : false) :
+            
+            // There is no __bool__ and no __len__, declare Functions true.
+            // Python objects are transpiled into instances of Function and if
+            // there is no __bool__ or __len__, the object in Python is true.
+            target instanceof Function ? target :
+            
+            // Target is something else, compute its len to decide
+            len (target) !== 0 ? target :
+            
+            // When all else fails, declare target as false
+            false
+        );
+    }
+    __all__.__t__ = __t__;
+
+    var bool = function (any) {     // Always truly returns a bool, rather than something truthy or falsy
+        return !!__t__ (any);
+    };
+    bool.__name__ = 'bool';         // So it can be used as a type with a name
+    __all__.bool = bool;
+
+    var float = function (any) {
+        if (any == 'inf') {
+            return Infinity;
+        }
+        else if (any == '-inf') {
+            return -Infinity;
+        }
+        else if (isNaN (parseFloat (any))) {    // Call to parseFloat needed to exclude '', ' ' etc.
+            if (any === false) {
+                return 0;
+            }
+            else if (any === true) {
+                return 1;
+            }
+            else {  // Needed e.g. in autoTester.check, so "return any ? true : false" won't do
+                throw ValueError ("could not convert string to float: '" + str(any) + "'", new Error ());
+            }
+        }
+        else {
+            return +any;
+        }
+    };
+    float.__name__ = 'float';
+    __all__.float = float;
+
+    var int = function (any) {
+        return float (any) | 0
+    };
+    int.__name__ = 'int';
+    __all__.int = int;
+
+    var py_typeof = function (anObject) {
+        var aType = typeof anObject;
+        if (aType == 'object') {    // Directly trying '__class__ in anObject' turns out to wreck anObject in Chrome if its a primitive
+            try {
+                return anObject.__class__;
+            }
+            catch (exception) {
+                return aType;
+            }
+        }
+        else {
+            return (    // Odly, the braces are required here
+                aType == 'boolean' ? bool :
+                aType == 'string' ? str :
+                aType == 'number' ? (anObject % 1 == 0 ? int : float) :
+                null
+            );
+        }
+    };
+    __all__.py_typeof = py_typeof;
+
+    var isinstance = function (anObject, classinfo) {
+        function isA (queryClass) {
+            if (queryClass == classinfo) {
+                return true;
+            }
+            for (var index = 0; index < queryClass.__bases__.length; index++) {
+                if (isA (queryClass.__bases__ [index], classinfo)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        if (classinfo instanceof Array) {   // Assume in most cases it isn't, then making it recursive rather than two functions saves a call
+            for (let aClass of classinfo) {
+                if (isinstance (anObject, aClass)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        try {                   // Most frequent use case first
+            return '__class__' in anObject ? isA (anObject.__class__) : anObject instanceof classinfo;
+        }
+        catch (exception) {     // Using isinstance on primitives assumed rare
+            var aType = py_typeof (anObject);
+            return aType == classinfo || (aType == bool && classinfo == int);
+        }
+    };
+    __all__.isinstance = isinstance;
+
+    var callable = function (anObject) {
+        if ( typeof anObject == 'object' && '__call__' in anObject ) {
+            return true;
+        }
+        else {
+            return typeof anObject === 'function';
+        }
+    };
+    __all__.callable = callable;
+
+    // Repr function uses __repr__ method, then __str__, then toString
+    var repr = function (anObject) {
+        try {
+            return anObject.__repr__ ();
+        }
+        catch (exception) {
+            try {
+                return anObject.__str__ ();
+            }
+            catch (exception) { // anObject has no __repr__ and no __str__
+                try {
+                    if (anObject == null) {
+                        return 'None';
+                    }
+                    else if (anObject.constructor == Object) {
+                        var result = '{';
+                        var comma = false;
+                        for (var attrib in anObject) {
+                            if (!__specialattrib__ (attrib)) {
+                                if (attrib.isnumeric ()) {
+                                    var attribRepr = attrib;                // If key can be interpreted as numerical, we make it numerical
+                                }                                           // So we accept that '1' is misrepresented as 1
+                                else {
+                                    var attribRepr = '\'' + attrib + '\'';  // Alpha key in dict
+                                }
+
+                                if (comma) {
+                                    result += ', ';
+                                }
+                                else {
+                                    comma = true;
+                                }
+                                result += attribRepr + ': ' + repr (anObject [attrib]);
+                            }
+                        }
+                        result += '}';
+                        return result;
+                    }
+                    else {
+                        return typeof anObject == 'boolean' ? anObject.toString () .capitalize () : anObject.toString ();
+                    }
+                }
+                catch (exception) {
+                    return '<object of type: ' + typeof anObject + '>';
+                }
+            }
+        }
+    };
+    __all__.repr = repr;
+
+    // Char from Unicode or ASCII
+    var chr = function (charCode) {
+        return String.fromCharCode (charCode);
+    };
+    __all__.chr = chr;
+
+    // Unicode or ASCII from char
+    var ord = function (aChar) {
+        return aChar.charCodeAt (0);
+    };
+    __all__.ord = ord;
+
+    // Maximum of n numbers
+    var max = Math.max;
+    __all__.max = max;
+
+    // Minimum of n numbers
+    var min = Math.min;
+    __all__.min = min;
+
+    // Absolute value
+    var abs = function (x) {
+        try {
+            return Math.abs (x);
+        }
+        catch (exception) {
+            return Math.sqrt (x.real * x.real + x.imag * x.imag);
+        }
+    };
+
+    // Bankers rounding
+    var round = function (number, ndigits) {
+        if (ndigits) {
+            var scale = Math.pow (10, ndigits);
+            number *= scale;
+        }
+
+        var rounded = Math.round (number);
+        if (rounded - number == 0.5 && rounded % 2) {   // Has rounded up to odd, should have rounded down to even
+            rounded -= 1;
+        }
+
+        if (ndigits) {
+            rounded /= scale;
+        }
+
+        return rounded;
+    };
+    __all__.round = round;
+
+    // BEGIN unified iterator model
+
+    function __jsUsePyNext__ () {       // Add as 'next' method to make Python iterator JavaScript compatible
+        try {
+            var result = this.__next__ ();
+            return {value: result, done: false};
+        }
+        catch (exception) {
+            return {value: undefined, done: true};
+        }
+    }
+
+    function __pyUseJsNext__ () {       // Add as '__next__' method to make JavaScript iterator Python compatible
+        var result = this.next ();
+        if (result.done) {
+            throw StopIteration (new Error ());
+        }
+        else {
+            return result.value;
+        }
+    }
+
+    function py_iter (iterable) {                   // Alias for Python's iter function, produces a universal iterator / iterable, usable in Python and JavaScript
+        if (typeof iterable == 'string' || '__iter__' in iterable) {    // JavaScript Array or string or Python iterable (string has no 'in')
+            var result = iterable.__iter__ ();                          // Iterator has a __next__
+            result.next = __jsUsePyNext__;                              // Give it a next
+        }
+        else if ('selector' in iterable) {                              // Assume it's a JQuery iterator
+            var result = list (iterable) .__iter__ ();                  // Has a __next__
+            result.next = __jsUsePyNext__;                              // Give it a next
+        }
+        else if ('next' in iterable) {                                  // It's a JavaScript iterator already,  maybe a generator, has a next and may have a __next__
+            var result = iterable
+            if (! ('__next__' in result)) {                             // If there's no danger of recursion
+                result.__next__ = __pyUseJsNext__;                      // Give it a __next__
+            }
+        }
+        else if (Symbol.iterator in iterable) {                         // It's a JavaScript iterable such as a typed array, but not an iterator
+            var result = iterable [Symbol.iterator] ();                 // Has a next
+            result.__next__ = __pyUseJsNext__;                          // Give it a __next__
+        }
+        else {
+            throw IterableError (new Error ()); // No iterator at all
+        }
+        result [Symbol.iterator] = function () {return result;};
+        return result;
+    }
+
+    function py_next (iterator) {               // Called only in a Python context, could receive Python or JavaScript iterator
+        try {                                   // Primarily assume Python iterator, for max speed
+            var result = iterator.__next__ ();
+        }
+        catch (exception) {                     // JavaScript iterators are the exception here
+            var result = iterator.next ();
+            if (result.done) {
+                throw StopIteration (new Error ());
+            }
+            else {
+                return result.value;
+            }
+        }
+        if (result == undefined) {
+            throw StopIteration (new Error ());
+        }
+        else {
+            return result;
+        }
+    }
+
+    function __PyIterator__ (iterable) {
+        this.iterable = iterable;
+        this.index = 0;
+    }
+
+    __PyIterator__.prototype.__next__ = function () {
+        if (this.index < this.iterable.length) {
+            return this.iterable [this.index++];
+        }
+        else {
+            throw StopIteration (new Error ());
+        }
+    };
+
+    function __JsIterator__ (iterable) {
+        this.iterable = iterable;
+        this.index = 0;
+    }
+
+    __JsIterator__.prototype.next = function () {
+        if (this.index < this.iterable.py_keys.length) {
+            return {value: this.index++, done: false};
+        }
+        else {
+            return {value: undefined, done: true};
+        }
+    };
+
+    // END unified iterator model
+
+    // Reversed function for arrays
+    var py_reversed = function (iterable) {
+        iterable = iterable.slice ();
+        iterable.reverse ();
+        return iterable;
+    };
+    __all__.py_reversed = py_reversed;
+
+    // Zip method for arrays and strings
+    var zip = function () {
+        var args = [] .slice.call (arguments);
+        for (var i = 0; i < args.length; i++) {
+            if (typeof args [i] == 'string') {
+                args [i] = args [i] .split ('');
+            }
+            else if (!Array.isArray (args [i])) {
+                args [i] = Array.from (args [i]);
+            }
+        }
+        var shortest = args.length == 0 ? [] : args.reduce (    // Find shortest array in arguments
+            function (array0, array1) {
+                return array0.length < array1.length ? array0 : array1;
+            }
+        );
+        return shortest.map (                   // Map each element of shortest array
+            function (current, index) {         // To the result of this function
+                return args.map (               // Map each array in arguments
+                    function (current) {        // To the result of this function
+                        return current [index]; // Namely it's index't entry
+                    }
+                );
+            }
+        );
+    };
+    __all__.zip = zip;
+
+    // Range method, returning an array
+    function range (start, stop, step) {
+        if (stop == undefined) {
+            // one param defined
+            stop = start;
+            start = 0;
+        }
+        if (step == undefined) {
+            step = 1;
+        }
+        if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
+            return [];
+        }
+        var result = [];
+        for (var i = start; step > 0 ? i < stop : i > stop; i += step) {
+            result.push(i);
+        }
+        return result;
+    };
+    __all__.range = range;
+
+    // Any, all and sum
+
+    function any (iterable) {
+        for (let item of iterable) {
+            if (bool (item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function all (iterable) {
+        for (let item of iterable) {
+            if (! bool (item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function sum (iterable) {
+        let result = 0;
+        for (let item of iterable) {
+            result += item;
+        }
+        return result;
+    }
+
+    __all__.any = any;
+    __all__.all = all;
+    __all__.sum = sum;
+
+    // Enumerate method, returning a zipped list
+    function enumerate (iterable) {
+        return zip (range (len (iterable)), iterable);
+    }
+    __all__.enumerate = enumerate;
+
+    // Shallow and deepcopy
+
+    function copy (anObject) {
+        if (anObject == null || typeof anObject == "object") {
+            return anObject;
+        }
+        else {
+            var result = {};
+            for (var attrib in obj) {
+                if (anObject.hasOwnProperty (attrib)) {
+                    result [attrib] = anObject [attrib];
+                }
+            }
+            return result;
+        }
+    }
+    __all__.copy = copy;
+
+    function deepcopy (anObject) {
+        if (anObject == null || typeof anObject == "object") {
+            return anObject;
+        }
+        else {
+            var result = {};
+            for (var attrib in obj) {
+                if (anObject.hasOwnProperty (attrib)) {
+                    result [attrib] = deepcopy (anObject [attrib]);
+                }
+            }
+            return result;
+        }
+    }
+    __all__.deepcopy = deepcopy;
+
+    // List extensions to Array
+
+    function list (iterable) {                                      // All such creators should be callable without new
+        var instance = iterable ? Array.from (iterable) : [];
+        // Sort is the normal JavaScript sort, Python sort is a non-member function
+        return instance;
+    }
+    __all__.list = list;
+    Array.prototype.__class__ = list;   // All arrays are lists (not only if constructed by the list ctor), unless constructed otherwise
+    list.__name__ = 'list';
+
+    /*
+    Array.from = function (iterator) { // !!! remove
+        result = [];
+        for (item of iterator) {
+            result.push (item);
+        }
+        return result;
+    }
+    */
+
+    Array.prototype.__iter__ = function () {return new __PyIterator__ (this);};
+
+    Array.prototype.__getslice__ = function (start, stop, step) {
+        if (start < 0) {
+            start = this.length + start;
+        }
+
+        if (stop == null) {
+            stop = this.length;
+        }
+        else if (stop < 0) {
+            stop = this.length + stop;
+        }
+        else if (stop > this.length) {
+            stop = this.length;
+        }
+
+        var result = list ([]);
+        for (var index = start; index < stop; index += step) {
+            result.push (this [index]);
+        }
+
+        return result;
+    };
+
+    Array.prototype.__setslice__ = function (start, stop, step, source) {
+        if (start < 0) {
+            start = this.length + start;
+        }
+
+        if (stop == null) {
+            stop = this.length;
+        }
+        else if (stop < 0) {
+            stop = this.length + stop;
+        }
+
+        if (step == null) { // Assign to 'ordinary' slice, replace subsequence
+            Array.prototype.splice.apply (this, [start, stop - start] .concat (source));
+        }
+        else {              // Assign to extended slice, replace designated items one by one
+            var sourceIndex = 0;
+            for (var targetIndex = start; targetIndex < stop; targetIndex += step) {
+                this [targetIndex] = source [sourceIndex++];
+            }
+        }
+    };
+
+    Array.prototype.__repr__ = function () {
+        if (this.__class__ == set && !this.length) {
+            return 'set()';
+        }
+
+        var result = !this.__class__ || this.__class__ == list ? '[' : this.__class__ == tuple ? '(' : '{';
+
+        for (var index = 0; index < this.length; index++) {
+            if (index) {
+                result += ', ';
+            }
+            result += repr (this [index]);
+        }
+
+        if (this.__class__ == tuple && this.length == 1) {
+            result += ',';
+        }
+
+        result += !this.__class__ || this.__class__ == list ? ']' : this.__class__ == tuple ? ')' : '}';;
+        return result;
+    };
+
+    Array.prototype.__str__ = Array.prototype.__repr__;
+
+    Array.prototype.append = function (element) {
+        this.push (element);
+    };
+
+    Array.prototype.py_clear = function () {
+        this.length = 0;
+    };
+
+    Array.prototype.extend = function (aList) {
+        this.push.apply (this, aList);
+    };
+
+    Array.prototype.insert = function (index, element) {
+        this.splice (index, 0, element);
+    };
+
+    Array.prototype.remove = function (element) {
+        var index = this.indexOf (element);
+        if (index == -1) {
+            throw ValueError ("list.remove(x): x not in list", new Error ());
+        }
+        this.splice (index, 1);
+    };
+
+    Array.prototype.index = function (element) {
+        return this.indexOf (element);
+    };
+
+    Array.prototype.py_pop = function (index) {
+        if (index == undefined) {
+            return this.pop ();  // Remove last element
+        }
+        else {
+            return this.splice (index, 1) [0];
+        }
+    };
+
+    Array.prototype.py_sort = function () {
+        __sort__.apply  (null, [this].concat ([] .slice.apply (arguments)));    // Can't work directly with arguments
+        // Python params: (iterable, key = None, reverse = False)
+        // py_sort is called with the Transcrypt kwargs mechanism, and just passes the params on to __sort__
+        // __sort__ is def'ed with the Transcrypt kwargs mechanism
+    };
+
+    Array.prototype.__add__ = function (aList) {
+        return list (this.concat (aList));
+    };
+
+    Array.prototype.__mul__ = function (scalar) {
+        var result = this;
+        for (var i = 1; i < scalar; i++) {
+            result = result.concat (this);
+        }
+        return result;
+    };
+
+    Array.prototype.__rmul__ = Array.prototype.__mul__;
+
+    // Tuple extensions to Array
+
+    function tuple (iterable) {
+        var instance = iterable ? [] .slice.apply (iterable) : [];
+        instance.__class__ = tuple; // Not all arrays are tuples
+        return instance;
+    }
+    __all__.tuple = tuple;
+    tuple.__name__ = 'tuple';
+
+    // Set extensions to Array
+    // N.B. Since sets are unordered, set operations will occasionally alter the 'this' array by sorting it
+
+    function set (iterable) {
+        var instance = [];
+        if (iterable) {
+            for (var index = 0; index < iterable.length; index++) {
+                instance.add (iterable [index]);
+            }
+        }
+        instance.__class__ = set;   // Not all arrays are sets
+        return instance;
+    }
+    __all__.set = set;
+    set.__name__ = 'set';
+
+    Array.prototype.__bindexOf__ = function (element) { // Used to turn O (n^2) into O (n log n)
+    // Since sorting is lex, compare has to be lex. This also allows for mixed lists
+
+        element += '';
+
+        var mindex = 0;
+        var maxdex = this.length - 1;
+
+        while (mindex <= maxdex) {
+            var index = (mindex + maxdex) / 2 | 0;
+            var middle = this [index] + '';
+
+            if (middle < element) {
+                mindex = index + 1;
+            }
+            else if (middle > element) {
+                maxdex = index - 1;
+            }
+            else {
+                return index;
+            }
+        }
+
+        return -1;
+    };
+
+    Array.prototype.add = function (element) {
+        if (this.indexOf (element) == -1) { // Avoid duplicates in set
+            this.push (element);
+        }
+    };
+
+    Array.prototype.discard = function (element) {
+        var index = this.indexOf (element);
+        if (index != -1) {
+            this.splice (index, 1);
+        }
+    };
+
+    Array.prototype.isdisjoint = function (other) {
+        this.sort ();
+        for (var i = 0; i < other.length; i++) {
+            if (this.__bindexOf__ (other [i]) != -1) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    Array.prototype.issuperset = function (other) {
+        this.sort ();
+        for (var i = 0; i < other.length; i++) {
+            if (this.__bindexOf__ (other [i]) == -1) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    Array.prototype.issubset = function (other) {
+        return set (other.slice ()) .issuperset (this); // Sort copy of 'other', not 'other' itself, since it may be an ordered sequence
+    };
+
+    Array.prototype.union = function (other) {
+        var result = set (this.slice () .sort ());
+        for (var i = 0; i < other.length; i++) {
+            if (result.__bindexOf__ (other [i]) == -1) {
+                result.push (other [i]);
+            }
+        }
+        return result;
+    };
+
+    Array.prototype.intersection = function (other) {
+        this.sort ();
+        var result = set ();
+        for (var i = 0; i < other.length; i++) {
+            if (this.__bindexOf__ (other [i]) != -1) {
+                result.push (other [i]);
+            }
+        }
+        return result;
+    };
+
+    Array.prototype.difference = function (other) {
+        var sother = set (other.slice () .sort ());
+        var result = set ();
+        for (var i = 0; i < this.length; i++) {
+            if (sother.__bindexOf__ (this [i]) == -1) {
+                result.push (this [i]);
+            }
+        }
+        return result;
+    };
+
+    Array.prototype.symmetric_difference = function (other) {
+        return this.union (other) .difference (this.intersection (other));
+    };
+
+    Array.prototype.py_update = function () {   // O (n)
+        var updated = [] .concat.apply (this.slice (), arguments) .sort ();
+        this.py_clear ();
+        for (var i = 0; i < updated.length; i++) {
+            if (updated [i] != updated [i - 1]) {
+                this.push (updated [i]);
+            }
+        }
+    };
+
+    Array.prototype.__eq__ = function (other) { // Also used for list
+        if (this.length != other.length) {
+            return false;
+        }
+        if (this.__class__ == set) {
+            this.sort ();
+            other.sort ();
+        }
+        for (var i = 0; i < this.length; i++) {
+            if (this [i] != other [i]) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    Array.prototype.__ne__ = function (other) { // Also used for list
+        return !this.__eq__ (other);
+    };
+
+    Array.prototype.__le__ = function (other) {
+        return this.issubset (other);
+    };
+
+    Array.prototype.__ge__ = function (other) {
+        return this.issuperset (other);
+    };
+
+    Array.prototype.__lt__ = function (other) {
+        return this.issubset (other) && !this.issuperset (other);
+    };
+
+    Array.prototype.__gt__ = function (other) {
+        return this.issuperset (other) && !this.issubset (other);
+    };
+
+    // Byte array extensions
+    
+    function bytearray (bytable, encoding) {
+        if (bytable == undefined) {
+            return new Uint8Array (0);
+        }
+        else {
+            var aType = py_typeof (bytable);
+            if (aType == int) {
+                return new Uint8Array (bytable);
+            }
+            else if (aType == str) {
+                var aBytes = new Uint8Array (len (bytable));
+                for (var i = 0; i < len (bytable); i++) {
+                    aBytes [i] = bytable.charCodeAt (i);
+                }
+                return aBytes;
+            }
+            else if (aType == list || aType == tuple) {
+                return new Uint8Array (bytable);
+            }
+            else {
+                throw py_TypeError;
+            }
+        }
+    }
+
+    var bytes = bytearray;
+    
+    __all__.bytearray = bytearray;
+    __all__.bytes = bytearray;
+   
+    Uint8Array.prototype.__add__ = function (aBytes) {
+        var result = new Uint8Array (this.length + aBytes.length);
+        result.set (this);
+        result.set (aBytes, this.length);
+        return result;
+    };
+
+    Uint8Array.prototype.__mul__ = function (scalar) {
+        var result = new Uint8Array (scalar * this.length);
+        for (var i = 0; i < scalar; i++) {
+            result.set (this, i * this.length);
+        }
+        return result;
+    };
+
+    Uint8Array.prototype.__rmul__ = Uint8Array.prototype.__mul__;
+    
+    // String extensions
+
+    function str (stringable) {
+        try {
+            return stringable.__str__ ();
+        }
+        catch (exception) {
+            try {
+                return repr (stringable);
+            }
+            catch (exception) {
+                return String (stringable); // No new, so no permanent String object but a primitive in a temporary 'just in time' wrapper
+            }
+        }
+    };
+    __all__.str = str;
+
+    String.prototype.__class__ = str;   // All strings are str
+    str.__name__ = 'str';
+
+    String.prototype.__iter__ = function () {new __PyIterator__ (this);};
+
+    String.prototype.__repr__ = function () {
+        return (this.indexOf ('\'') == -1 ? '\'' + this + '\'' : '"' + this + '"') .py_replace ('\t', '\\t') .py_replace ('\n', '\\n');
+    };
+
+    String.prototype.__str__ = function () {
+        return this;
+    };
+
+    String.prototype.capitalize = function () {
+        return this.charAt (0).toUpperCase () + this.slice (1);
+    };
+
+    String.prototype.endswith = function (suffix) {
+        return suffix == '' || this.slice (-suffix.length) == suffix;
+    };
+
+    String.prototype.find  = function (sub, start) {
+        return this.indexOf (sub, start);
+    };
+
+    String.prototype.__getslice__ = function (start, stop, step) {
+        if (start < 0) {
+            start = this.length + start;
+        }
+
+        if (stop == null) {
+            stop = this.length;
+        }
+        else if (stop < 0) {
+            stop = this.length + stop;
+        }
+
+        var result = '';
+        if (step == 1) {
+            result = this.substring (start, stop);
+        }
+        else {
+            for (var index = start; index < stop; index += step) {
+                result = result.concat (this.charAt(index));
+            }
+        }
+        return result;
+    }
+
+    // Since it's worthwhile for the 'format' function to be able to deal with *args, it is defined as a property
+    // __get__ will produce a bound function if there's something before the dot
+    // Since a call using *args is compiled to e.g. <object>.<function>.apply (null, args), the function has to be bound already
+    // Otherwise it will never be, because of the null argument
+    // Using 'this' rather than 'null' contradicts the requirement to be able to pass bound functions around
+    // The object 'before the dot' won't be available at call time in that case, unless implicitly via the function bound to it
+    // While for Python methods this mechanism is generated by the compiler, for JavaScript methods it has to be provided manually
+    // Call memoizing is unattractive here, since every string would then have to hold a reference to a bound format method
+    __setProperty__ (String.prototype, 'format', {
+        get: function () {return __get__ (this, function (self) {
+            var args = tuple ([] .slice.apply (arguments).slice (1));
+            var autoIndex = 0;
+            return self.replace (/\{(\w*)\}/g, function (match, key) {
+                if (key == '') {
+                    key = autoIndex++;
+                }
+                if (key == +key) {  // So key is numerical
+                    return args [key] == undefined ? match : str (args [key]);
+                }
+                else {              // Key is a string
+                    for (var index = 0; index < args.length; index++) {
+                        // Find first 'dict' that has that key and the right field
+                        if (typeof args [index] == 'object' && args [index][key] != undefined) {
+                            return str (args [index][key]); // Return that field field
+                        }
+                    }
+                    return match;
+                }
+            });
+        });},
+        enumerable: true
+    });
+
+    String.prototype.isalnum = function () {
+        return /^[0-9a-zA-Z]{1,}$/.test(this)
+    }
+
+    String.prototype.isalpha = function () {
+        return /^[a-zA-Z]{1,}$/.test(this)
+    }
+
+    String.prototype.isdecimal = function () {
+        return /^[0-9]{1,}$/.test(this)
+    }
+
+    String.prototype.isdigit = function () {
+        return this.isdecimal()
+    }
+
+    String.prototype.islower = function () {
+        return /^[a-z]{1,}$/.test(this)
+    }
+
+    String.prototype.isupper = function () {
+        return /^[A-Z]{1,}$/.test(this)
+    }
+
+    String.prototype.isspace = function () {
+        return /^[\s]{1,}$/.test(this)
+    }
+
+    String.prototype.isnumeric = function () {
+        return !isNaN (parseFloat (this)) && isFinite (this);
+    };
+
+    String.prototype.join = function (strings) {
+        strings = Array.from (strings); // Much faster than iterating through strings char by char
+        return strings.join (this);
+    };
+
+    String.prototype.lower = function () {
+        return this.toLowerCase ();
+    };
+
+    String.prototype.py_replace = function (old, aNew, maxreplace) {
+        return this.split (old, maxreplace) .join (aNew);
+    };
+
+    String.prototype.lstrip = function () {
+        return this.replace (/^\s*/g, '');
+    };
+
+    String.prototype.rfind = function (sub, start) {
+        return this.lastIndexOf (sub, start);
+    };
+
+    String.prototype.rsplit = function (sep, maxsplit) {    // Combination of general whitespace sep and positive maxsplit neither supported nor checked, expensive and rare
+        if (sep == undefined || sep == null) {
+            sep = /\s+/;
+            var stripped = this.strip ();
+        }
+        else {
+            var stripped = this;
+        }
+
+        if (maxsplit == undefined || maxsplit == -1) {
+            return stripped.split (sep);
+        }
+        else {
+            var result = stripped.split (sep);
+            if (maxsplit < result.length) {
+                var maxrsplit = result.length - maxsplit;
+                return [result.slice (0, maxrsplit) .join (sep)] .concat (result.slice (maxrsplit));
+            }
+            else {
+                return result;
+            }
+        }
+    };
+
+    String.prototype.rstrip = function () {
+        return this.replace (/\s*$/g, '');
+    };
+
+    String.prototype.py_split = function (sep, maxsplit) {  // Combination of general whitespace sep and positive maxsplit neither supported nor checked, expensive and rare
+        if (sep == undefined || sep == null) {
+            sep = /\s+/;
+            var stripped = this.strip ();
+        }
+        else {
+            var stripped = this;
+        }
+
+        if (maxsplit == undefined || maxsplit == -1) {
+            return stripped.split (sep);
+        }
+        else {
+            var result = stripped.split (sep);
+            if (maxsplit < result.length) {
+                return result.slice (0, maxsplit).concat ([result.slice (maxsplit).join (sep)]);
+            }
+            else {
+                return result;
+            }
+        }
+    };
+
+    String.prototype.startswith = function (prefix) {
+        return this.indexOf (prefix) == 0;
+    };
+
+    String.prototype.strip = function () {
+        return this.trim ();
+    };
+
+    String.prototype.upper = function () {
+        return this.toUpperCase ();
+    };
+
+    String.prototype.__mul__ = function (scalar) {
+        var result = this;
+        for (var i = 1; i < scalar; i++) {
+            result = result + this;
+        }
+        return result;
+    };
+
+    String.prototype.__rmul__ = String.prototype.__mul__;
+
+    // Dict extensions to object
+
+    function __keys__ () {
+        var keys = [];
+        for (var attrib in this) {
+            if (!__specialattrib__ (attrib)) {
+                keys.push (attrib);
+            }
+        }
+        return keys;
+    }
+
+    function __items__ () {
+        var items = [];
+        for (var attrib in this) {
+            if (!__specialattrib__ (attrib)) {
+                items.push ([attrib, this [attrib]]);
+            }
+        }
+        return items;
+    }
+
+    function __del__ (key) {
+        delete this [key];
+    }
+
+    function __clear__ () {
+        for (var attrib in this) {
+            delete this [attrib];
+        }
+    }
+
+    function __getdefault__ (aKey, aDefault) {  // Each Python object already has a function called __get__, so we call this one __getdefault__
+        var result = this [aKey];
+        return result == undefined ? (aDefault == undefined ? null : aDefault) : result;
+    }
+
+    function __setdefault__ (aKey, aDefault) {
+        var result = this [aKey];
+        if (result != undefined) {
+            return result;
+        }
+        var val = aDefault == undefined ? null : aDefault;
+        this [aKey] = val;
+        return val;
+    }
+
+    function __pop__ (aKey, aDefault) {
+        var result = this [aKey];
+        if (result != undefined) {
+            delete this [aKey];
+            return result;
+        } else {
+            // Identify check because user could pass None
+            if ( aDefault === undefined ) {
+                throw KeyError (aKey, new Error());
+            }
+        }
+        return aDefault;
+    }
+    
+    function __popitem__ () {
+        var aKey = Object.keys (this) [0];
+        if (aKey == null) {
+            throw KeyError ("popitem(): dictionary is empty", new Error ());
+        }
+        var result = tuple ([aKey, this [aKey]]);
+        delete this [aKey];
+        return result;
+    }
+    
+    function __update__ (aDict) {
+        for (var aKey in aDict) {
+            this [aKey] = aDict [aKey];
+        }
+    }
+    
+    function __values__ () {
+        var values = [];
+        for (var attrib in this) {
+            if (!__specialattrib__ (attrib)) {
+                values.push (this [attrib]);
+            }
+        }
+        return values;
+
+    }
+    
+    function __dgetitem__ (aKey) {
+        return this [aKey];
+    }
+    
+    function __dsetitem__ (aKey, aValue) {
+        this [aKey] = aValue;
+    }
+
+    function dict (objectOrPairs) {
+        var instance = {};
+        if (!objectOrPairs || objectOrPairs instanceof Array) { // It's undefined or an array of pairs
+            if (objectOrPairs) {
+                for (var index = 0; index < objectOrPairs.length; index++) {
+                    var pair = objectOrPairs [index];
+                    if ( !(pair instanceof Array) || pair.length != 2) {
+                        throw ValueError(
+                            "dict update sequence element #" + index +
+                            " has length " + pair.length +
+                            "; 2 is required", new Error());
+                    }
+                    var key = pair [0];
+                    var val = pair [1];
+                    if (!(objectOrPairs instanceof Array) && objectOrPairs instanceof Object) {
+                         // User can potentially pass in an object
+                         // that has a hierarchy of objects. This
+                         // checks to make sure that these objects
+                         // get converted to dict objects instead of
+                         // leaving them as js objects.
+                         
+                         if (!isinstance (objectOrPairs, dict)) {
+                             val = dict (val);
+                         }
+                    }
+                    instance [key] = val;
+                }
+            }
+        }
+        else {
+            if (isinstance (objectOrPairs, dict)) {
+                // Passed object is a dict already so we need to be a little careful
+                // N.B. - this is a shallow copy per python std - so
+                // it is assumed that children have already become
+                // python objects at some point.
+                
+                var aKeys = objectOrPairs.py_keys ();
+                for (var index = 0; index < aKeys.length; index++ ) {
+                    var key = aKeys [index];
+                    instance [key] = objectOrPairs [key];
+                }
+            } else if (objectOrPairs instanceof Object) {
+                // Passed object is a JavaScript object but not yet a dict, don't copy it
+                instance = objectOrPairs;
+            } else {
+                // We have already covered Array so this indicates
+                // that the passed object is not a js object - i.e.
+                // it is an int or a string, which is invalid.
+                
+                throw ValueError ("Invalid type of object for dict creation", new Error ());
+            }
+        }
+
+        // Trancrypt interprets e.g. {aKey: 'aValue'} as a Python dict literal rather than a JavaScript object literal
+        // So dict literals rather than bare Object literals will be passed to JavaScript libraries
+        // Some JavaScript libraries call all enumerable callable properties of an object that's passed to them
+        // So the properties of a dict should be non-enumerable
+        __setProperty__ (instance, '__class__', {value: dict, enumerable: false, writable: true});
+        __setProperty__ (instance, 'py_keys', {value: __keys__, enumerable: false});
+        __setProperty__ (instance, '__iter__', {value: function () {new __PyIterator__ (this.py_keys ());}, enumerable: false});
+        __setProperty__ (instance, Symbol.iterator, {value: function () {new __JsIterator__ (this.py_keys ());}, enumerable: false});
+        __setProperty__ (instance, 'py_items', {value: __items__, enumerable: false});
+        __setProperty__ (instance, 'py_del', {value: __del__, enumerable: false});
+        __setProperty__ (instance, 'py_clear', {value: __clear__, enumerable: false});
+        __setProperty__ (instance, 'py_get', {value: __getdefault__, enumerable: false});
+        __setProperty__ (instance, 'py_setdefault', {value: __setdefault__, enumerable: false});
+        __setProperty__ (instance, 'py_pop', {value: __pop__, enumerable: false});
+        __setProperty__ (instance, 'py_popitem', {value: __popitem__, enumerable: false});
+        __setProperty__ (instance, 'py_update', {value: __update__, enumerable: false});
+        __setProperty__ (instance, 'py_values', {value: __values__, enumerable: false});
+        __setProperty__ (instance, '__getitem__', {value: __dgetitem__, enumerable: false});    // Needed since compound keys necessarily
+        __setProperty__ (instance, '__setitem__', {value: __dsetitem__, enumerable: false});    // trigger overloading to deal with slices
+        return instance;
+    }
+
+    __all__.dict = dict;
+    dict.__name__ = 'dict';
+    
+    // Docstring setter
+
+    function __setdoc__ (docString) {
+        this.__doc__ = docString;
+        return this;
+    }
+
+    // Python classes, methods and functions are all translated to JavaScript functions
+    __setProperty__ (Function.prototype, '__setdoc__', {value: __setdoc__, enumerable: false});
+
+    // General operator overloading, only the ones that make most sense in matrix and complex operations
+
+    var __neg__ = function (a) {
+        if (typeof a == 'object' && '__neg__' in a) {
+            return a.__neg__ ();
+        }
+        else {
+            return -a;
+        }
+    };
+    __all__.__neg__ = __neg__;
+
+    var __matmul__ = function (a, b) {
+        return a.__matmul__ (b);
+    };
+    __all__.__matmul__ = __matmul__;
+
+    var __pow__ = function (a, b) {
+        if (typeof a == 'object' && '__pow__' in a) {
+            return a.__pow__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rpow__ (a);
+        }
+        else {
+            return Math.pow (a, b);
+        }
+    };
+    __all__.pow = __pow__;
+
+    var __jsmod__ = function (a, b) {
+        if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return a % b;
+        }
+    };
+    __all__.__jsmod__ = __jsmod__;
+    
+    var __mod__ = function (a, b) {
+        if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return ((a % b) + b) % b;
+        }
+    };
+    __all__.mod = __mod__;
+
+    // Overloaded binary arithmetic
+    
+    var __mul__ = function (a, b) {
+        if (typeof a == 'object' && '__mul__' in a) {
+            return a.__mul__ (b);
+        }
+        else if (typeof b == 'object' && '__rmul__' in b) {
+            return b.__rmul__ (a);
+        }
+        else if (typeof a == 'string') {
+            return a.__mul__ (b);
+        }
+        else if (typeof b == 'string') {
+            return b.__rmul__ (a);
+        }
+        else {
+            return a * b;
+        }
+    };
+    __all__.__mul__ = __mul__;
+
+    var __truediv__ = function (a, b) {
+        if (typeof a == 'object' && '__truediv__' in a) {
+            return a.__truediv__ (b);
+        }
+        else if (typeof b == 'object' && '__rtruediv__' in b) {
+            return b.__rtruediv__ (a);
+        }
+        else if (typeof a == 'object' && '__div__' in a) {
+            return a.__div__ (b);
+        }
+        else if (typeof b == 'object' && '__rdiv__' in b) {
+            return b.__rdiv__ (a);
+        }
+        else {
+            return a / b;
+        }
+    };
+    __all__.__truediv__ = __truediv__;
+
+    var __floordiv__ = function (a, b) {
+        if (typeof a == 'object' && '__floordiv__' in a) {
+            return a.__floordiv__ (b);
+        }
+        else if (typeof b == 'object' && '__rfloordiv__' in b) {
+            return b.__rfloordiv__ (a);
+        }
+        else if (typeof a == 'object' && '__div__' in a) {
+            return a.__div__ (b);
+        }
+        else if (typeof b == 'object' && '__rdiv__' in b) {
+            return b.__rdiv__ (a);
+        }
+        else {
+            return Math.floor (a / b);
+        }
+    };
+    __all__.__floordiv__ = __floordiv__;
+
+    var __add__ = function (a, b) {
+        if (typeof a == 'object' && '__add__' in a) {
+            return a.__add__ (b);
+        }
+        else if (typeof b == 'object' && '__radd__' in b) {
+            return b.__radd__ (a);
+        }
+        else {
+            return a + b;
+        }
+    };
+    __all__.__add__ = __add__;
+
+    var __sub__ = function (a, b) {
+        if (typeof a == 'object' && '__sub__' in a) {
+            return a.__sub__ (b);
+        }
+        else if (typeof b == 'object' && '__rsub__' in b) {
+            return b.__rsub__ (a);
+        }
+        else {
+            return a - b;
+        }
+    };
+    __all__.__sub__ = __sub__;
+
+    // Overloaded binary bitwise
+    
+    var __lshift__ = function (a, b) {
+        if (typeof a == 'object' && '__lshift__' in a) {
+            return a.__lshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rlshift__' in b) {
+            return b.__rlshift__ (a);
+        }
+        else {
+            return a << b;
+        }
+    };
+    __all__.__lshift__ = __lshift__;
+
+    var __rshift__ = function (a, b) {
+        if (typeof a == 'object' && '__rshift__' in a) {
+            return a.__rshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rrshift__' in b) {
+            return b.__rrshift__ (a);
+        }
+        else {
+            return a >> b;
+        }
+    };
+    __all__.__rshift__ = __rshift__;
+
+    var __or__ = function (a, b) {
+        if (typeof a == 'object' && '__or__' in a) {
+            return a.__or__ (b);
+        }
+        else if (typeof b == 'object' && '__ror__' in b) {
+            return b.__ror__ (a);
+        }
+        else {
+            return a | b;
+        }
+    };
+    __all__.__or__ = __or__;
+
+    var __xor__ = function (a, b) {
+        if (typeof a == 'object' && '__xor__' in a) {
+            return a.__xor__ (b);
+        }
+        else if (typeof b == 'object' && '__rxor__' in b) {
+            return b.__rxor__ (a);
+        }
+        else {
+            return a ^ b;
+        }
+    };
+    __all__.__xor__ = __xor__;
+
+    var __and__ = function (a, b) {
+        if (typeof a == 'object' && '__and__' in a) {
+            return a.__and__ (b);
+        }
+        else if (typeof b == 'object' && '__rand__' in b) {
+            return b.__rand__ (a);
+        }
+        else {
+            return a & b;
+        }
+    };
+    __all__.__and__ = __and__;
+
+    // Overloaded binary compare
+    
+    var __eq__ = function (a, b) {
+        if (typeof a == 'object' && '__eq__' in a) {
+            return a.__eq__ (b);
+        }
+        else {
+            return a == b;
+        }
+    };
+    __all__.__eq__ = __eq__;
+
+    var __ne__ = function (a, b) {
+        if (typeof a == 'object' && '__ne__' in a) {
+            return a.__ne__ (b);
+        }
+        else {
+            return a != b
+        }
+    };
+    __all__.__ne__ = __ne__;
+
+    var __lt__ = function (a, b) {
+        if (typeof a == 'object' && '__lt__' in a) {
+            return a.__lt__ (b);
+        }
+        else {
+            return a < b;
+        }
+    };
+    __all__.__lt__ = __lt__;
+
+    var __le__ = function (a, b) {
+        if (typeof a == 'object' && '__le__' in a) {
+            return a.__le__ (b);
+        }
+        else {
+            return a <= b;
+        }
+    };
+    __all__.__le__ = __le__;
+
+    var __gt__ = function (a, b) {
+        if (typeof a == 'object' && '__gt__' in a) {
+            return a.__gt__ (b);
+        }
+        else {
+            return a > b;
+        }
+    };
+    __all__.__gt__ = __gt__;
+
+    var __ge__ = function (a, b) {
+        if (typeof a == 'object' && '__ge__' in a) {
+            return a.__ge__ (b);
+        }
+        else {
+            return a >= b;
+        }
+    };
+    __all__.__ge__ = __ge__;
+    
+    // Overloaded augmented general
+    
+    var __imatmul__ = function (a, b) {
+        if ('__imatmul__' in a) {
+            return a.__imatmul__ (b);
+        }
+        else {
+            return a.__matmul__ (b);
+        }
+    };
+    __all__.__imatmul__ = __imatmul__;
+
+    var __ipow__ = function (a, b) {
+        if (typeof a == 'object' && '__pow__' in a) {
+            return a.__ipow__ (b);
+        }
+        else if (typeof a == 'object' && '__ipow__' in a) {
+            return a.__pow__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rpow__ (a);
+        }
+        else {
+            return Math.pow (a, b);
+        }
+    };
+    __all__.ipow = __ipow__;
+
+    var __ijsmod__ = function (a, b) {
+        if (typeof a == 'object' && '__imod__' in a) {
+            return a.__ismod__ (b);
+        }
+        else if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return a % b;
+        }
+    };
+    __all__.ijsmod__ = __ijsmod__;
+    
+    var __imod__ = function (a, b) {
+        if (typeof a == 'object' && '__imod__' in a) {
+            return a.__imod__ (b);
+        }
+        else if (typeof a == 'object' && '__mod__' in a) {
+            return a.__mod__ (b);
+        }
+        else if (typeof b == 'object' && '__rpow__' in b) {
+            return b.__rmod__ (a);
+        }
+        else {
+            return ((a % b) + b) % b;
+        }
+    };
+    __all__.imod = __imod__;
+    
+    // Overloaded augmented arithmetic
+    
+    var __imul__ = function (a, b) {
+        if (typeof a == 'object' && '__imul__' in a) {
+            return a.__imul__ (b);
+        }
+        else if (typeof a == 'object' && '__mul__' in a) {
+            return a = a.__mul__ (b);
+        }
+        else if (typeof b == 'object' && '__rmul__' in b) {
+            return a = b.__rmul__ (a);
+        }
+        else if (typeof a == 'string') {
+            return a = a.__mul__ (b);
+        }
+        else if (typeof b == 'string') {
+            return a = b.__rmul__ (a);
+        }
+        else {
+            return a *= b;
+        }
+    };
+    __all__.__imul__ = __imul__;
+
+    var __idiv__ = function (a, b) {
+        if (typeof a == 'object' && '__idiv__' in a) {
+            return a.__idiv__ (b);
+        }
+        else if (typeof a == 'object' && '__div__' in a) {
+            return a = a.__div__ (b);
+        }
+        else if (typeof b == 'object' && '__rdiv__' in b) {
+            return a = b.__rdiv__ (a);
+        }
+        else {
+            return a /= b;
+        }
+    };
+    __all__.__idiv__ = __idiv__;
+
+    var __iadd__ = function (a, b) {
+        if (typeof a == 'object' && '__iadd__' in a) {
+            return a.__iadd__ (b);
+        }
+        else if (typeof a == 'object' && '__add__' in a) {
+            return a = a.__add__ (b);
+        }
+        else if (typeof b == 'object' && '__radd__' in b) {
+            return a = b.__radd__ (a);
+        }
+        else {
+            return a += b;
+        }
+    };
+    __all__.__iadd__ = __iadd__;
+
+    var __isub__ = function (a, b) {
+        if (typeof a == 'object' && '__isub__' in a) {
+            return a.__isub__ (b);
+        }
+        else if (typeof a == 'object' && '__sub__' in a) {
+            return a = a.__sub__ (b);
+        }
+        else if (typeof b == 'object' && '__rsub__' in b) {
+            return a = b.__rsub__ (a);
+        }
+        else {
+            return a -= b;
+        }
+    };
+    __all__.__isub__ = __isub__;
+
+    // Overloaded augmented bitwise
+    
+    var __ilshift__ = function (a, b) {
+        if (typeof a == 'object' && '__ilshift__' in a) {
+            return a.__ilshift__ (b);
+        }
+        else if (typeof a == 'object' && '__lshift__' in a) {
+            return a = a.__lshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rlshift__' in b) {
+            return a = b.__rlshift__ (a);
+        }
+        else {
+            return a <<= b;
+        }
+    };
+    __all__.__ilshift__ = __ilshift__;
+
+    var __irshift__ = function (a, b) {
+        if (typeof a == 'object' && '__irshift__' in a) {
+            return a.__irshift__ (b);
+        }
+        else if (typeof a == 'object' && '__rshift__' in a) {
+            return a = a.__rshift__ (b);
+        }
+        else if (typeof b == 'object' && '__rrshift__' in b) {
+            return a = b.__rrshift__ (a);
+        }
+        else {
+            return a >>= b;
+        }
+    };
+    __all__.__irshift__ = __irshift__;
+
+    var __ior__ = function (a, b) {
+        if (typeof a == 'object' && '__ior__' in a) {
+            return a.__ior__ (b);
+        }
+        else if (typeof a == 'object' && '__or__' in a) {
+            return a = a.__or__ (b);
+        }
+        else if (typeof b == 'object' && '__ror__' in b) {
+            return a = b.__ror__ (a);
+        }
+        else {
+            return a |= b;
+        }
+    };
+    __all__.__ior__ = __ior__;
+
+    var __ixor__ = function (a, b) {
+        if (typeof a == 'object' && '__ixor__' in a) {
+            return a.__ixor__ (b);
+        }
+        else if (typeof a == 'object' && '__xor__' in a) {
+            return a = a.__xor__ (b);
+        }
+        else if (typeof b == 'object' && '__rxor__' in b) {
+            return a = b.__rxor__ (a);
+        }
+        else {
+            return a ^= b;
+        }
+    };
+    __all__.__ixor__ = __ixor__;
+
+    var __iand__ = function (a, b) {
+        if (typeof a == 'object' && '__iand__' in a) {
+            return a.__iand__ (b);
+        }
+        else if (typeof a == 'object' && '__and__' in a) {
+            return a = a.__and__ (b);
+        }
+        else if (typeof b == 'object' && '__rand__' in b) {
+            return a = b.__rand__ (a);
+        }
+        else {
+            return a &= b;
+        }
+    };
+    __all__.__iand__ = __iand__;
+    
+    // Indices and slices
+
+    var __getitem__ = function (container, key) {                           // Slice c.q. index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__getitem__' in container) {
+            return container.__getitem__ (key);                             // Overloaded on container
+        }
+        else {
+            return container [key];                                         // Container must support bare JavaScript brackets
+        }
+    };
+    __all__.__getitem__ = __getitem__;
+
+    var __setitem__ = function (container, key, value) {                    // Slice c.q. index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__setitem__' in container) {
+            container.__setitem__ (key, value);                             // Overloaded on container
+        }
+        else {
+            container [key] = value;                                        // Container must support bare JavaScript brackets
+        }
+    };
+    __all__.__setitem__ = __setitem__;
+
+    var __getslice__ = function (container, lower, upper, step) {           // Slice only, no index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__getitem__' in container) {
+            return container.__getitem__ ([lower, upper, step]);            // Container supports overloaded slicing c.q. indexing
+        }
+        else {
+            return container.__getslice__ (lower, upper, step);             // Container only supports slicing injected natively in prototype
+        }
+    };
+    __all__.__getslice__ = __getslice__;
+
+    var __setslice__ = function (container, lower, upper, step, value) {    // Slice, no index, direct generated call to runtime switch
+        if (typeof container == 'object' && '__setitem__' in container) {
+            container.__setitem__ ([lower, upper, step], value);            // Container supports overloaded slicing c.q. indexing
+        }
+        else {
+            container.__setslice__ (lower, upper, step, value);             // Container only supports slicing injected natively in prototype
+        }
+    };
+    __all__.__setslice__ = __setslice__;
+    __nest__ (
+        __all__,
+        'itertools', {
+            __all__: {
+                __inited__: false,
+                __init__: function (__all__) {
+                    var count = function* (start, step) {
+                        if (start == undefined) {
+                            start = 0;
+                        }
+                        if (step == undefined) {
+                            step = 1;
+                        }
+                        while (true) {
+                            yield start;
+                            start += step;
+                        }
+                    }
+                    var cycle = function* (iterable) {                      
+                        let buffer = Array.from (iterable); // Can't reset, Chrome can't obtain iter from gener
+                        while (true) {
+                            for (let item of buffer) {
+                                yield item;
+                            }
+                        }
+                    }
+                    var repeat = function* (item, n) {
+                        if (typeof n == 'undefined') {
+                            while (true) {
+                                yield item;
+                            }
+                        }
+                        else {
+                            for (let index = 0; index < n; index++) {
+                                yield item;
+                            }
+                        }
+                    }
+                    var accumulate = function* (iterable, func) {
+                        let sum;
+                        let first = true;
+                        if (func) {
+                            for (let item of iterable) {
+                                if (first) {
+                                    sum = item;
+                                    first = false;
+                                }
+                                else {
+                                    sum = func (sum, item);
+                                }
+                                yield sum;
+                            }
+                        }
+                        else {
+                            for (let item of iterable) {
+                                if (first) {
+                                    sum = item;
+                                    first = false;
+                                }
+                                else {
+                                    sum = sum + item;
+                                }
+                                yield sum;
+                            }
+                        }
+                    }
+                    var chain = function* () {
+                        let args = [] .slice.apply (arguments);                         
+                        for (let arg of args) {
+                            for (let item of arg) {
+                                yield item;
+                            }
+                        }
+                    }
+                    chain.from_iterable = function* (iterable) {                        
+                        for (let item of iterable) {
+                            for (let subItem of item) {
+                                yield subItem;
+                            }
+                        }
+                    }
+                    var compress = function* (data, selectors) {
+                        let dataIterator = data [Symbol.iterator] .call (data);
+                        let selectorsIterator = selectors [Symbol.iterator] ();
+                        while (true) {
+                            let dataItem = dataIterator.next ();
+                            let selectorsItem = selectorsIterator.next ();
+                            if (dataItem.done || selectorsItem.done) {
+                                break;
+                            }
+                            else {
+                                if (selectorsItem.value) {
+                                    yield dataItem.value;
+                                }
+                            }
+                        }
+                    }
+                    var dropwhile = function* (pred, seq) {
+                        let started = false;
+                        for (let item of seq) {
+                            if (started) {
+                                yield item;
+                            }
+                            else if (!pred (item)) {
+                                started = true;
+                                yield item;
+                            }
+                        }
+                    }
+                    var filterfalse = function* (pred, seq) {
+                        for (let item of seq) {
+                            if (!pred (item)) {
+                                yield item;
+                            }
+                        }
+                    }
+                    var groupby = function* (iterable, keyfunc) {
+                        let anIterator = iterable [Symbol.iterator] ();
+                        let item = anIterator.next ();
+                        
+                        if (item.done) {
+                            return;
+                        }
+                        
+                        let groupKey = keyfunc (item.value);
+                        let more = true;
+                        
+                        function* group () {
+                            while (true) {
+                                yield (item.value);
+                                item = anIterator.next ();
+                                
+                                if (item.done) {
+                                    more = false;
+                                    return;
+                                }
+                                
+                                let key = keyfunc (item.value);
+                                
+                                if (key != groupKey) {
+                                    groupKey = key;
+                                    return;
+                                }
+                            }
+                        }
+                        
+                        while (more) {
+                            yield tuple ([groupKey, group ()]);
+                        }
+                    }
+                    
+                    var islice = function* () {
+                        let start;  // Have to be defined at function level, or Closure compiler will loose them after a yield 
+                        let stop;   //
+                        let step;   //
+                        
+                        let args = [] .slice.apply (arguments);
+                        let anIterator = args [0][Symbol.iterator] ();
+                        if (args.length == 2) {
+                            stop = args [1];
+                            start = 0;
+                            step = 1;
+                        }
+                        else {
+                            start = args [1];
+                            stop = args [2];
+                            if (args.length == 4) {
+                                step = args [3];
+                            }
+                            else {
+                                step = 1;
+                            }
+                        }
+                        for (let index = 0; index < start; index++) {
+                            if (anIterator.next (). done) {
+                                return;
+                            }
+                        }
+                        for (let index = 0; index < stop - start; index++) {
+                            let next = anIterator.next ();
+                            if (next.done) {
+                                return;
+                            }
+                            if (index % step == 0) {
+                                yield next.value;
+                            }
+                        }
+                    }
+                    var starmap = function* (func, seq) {
+                        let anIterator = seq [Symbol.iterator] ();
+                        while (true) {
+                            let next = anIterator.next ()
+                            if (next.done) {
+                                return;
+                            }
+                            else {
+                                yield func (...next.value); 
+                            }
+                        }
+                    }
+                    var takewhile = function* (pred, seq) {
+                        for (let item of seq) {
+                            if (pred (item)) {
+                                yield item;
+                            }
+                            else {
+                                return;
+                            }
+                        }
+                    }
+                    var tee = function (iterable, n) {
+                        if (n == undefined) {
+                            n = 2;
+                        }
+                        let all = [];                               // Don't return iterator since destructuring assignment cannot yet deal with that
+                        let one = list (iterable);
+                        for (let i = 0; i < n; i++) {
+                            all.append (one [Symbol.iterator] ());  // Iterator rather than list, exhaustable for semantic equivalence
+                        }
+                        return list (all);
+                    }
+                    
+                    var product = function () {
+                        let args = [] .slice.apply (arguments);
+                        if (args.length && args [args.length - 1] .hasOwnProperty ('__kwargtrans__')) {
+                            var repeat = args.pop () ['repeat']; 
+                        }
+                        else {
+                            var repeat = 1;
+                        }
+                        
+                        let oldMolecules = [tuple ([])];
+                        for (let i = 0; i < repeat; i++) {
+                            for (let arg of args) {
+                                let newMolecules = [];
+                                for (let oldMolecule of oldMolecules) {
+                                    for (let atom of arg) {
+                                        newMolecules.append (tuple (oldMolecule.concat (atom)));
+                                    }
+                                }
+                                oldMolecules = newMolecules;
+                            }
+                        }
+                        return list (oldMolecules); // Also works if args is emptpy
+                    }
+                    var permutations = function (iterable, r) {
+                        if (r == undefined) {
+                            try {
+                                r = len (iterable);
+                            }
+                            catch (exception) {
+                                r = len (list (iterable));
+                            }
+                        }
+                        let aProduct = product (iterable, __kwargtrans__ ({repeat: r}));
+                        let result = [];
+                        for (let molecule of aProduct) {
+                            if (len (set (molecule)) == r) {    // Weed out doubles
+                                result.append (molecule);
+                            }
+                        }
+                        return list (result);
+                    }
+                    var combinations = function (iterable, r) {
+                        let tail = list (iterable);
+                        function recurse (tail, molecule, rNext) {
+                            for (let index = 0; index < len (tail) - rNext; index++) {
+                                let newMolecule = molecule.concat (tail.slice (index, index + 1));
+
+                                if (rNext) {
+                                    recurse (tail.slice (index + 1), newMolecule, rNext - 1);
+                                }
+                                else {
+                                    result.append (tuple (newMolecule));
+                                }
+                            }
+                        }
+                        let result = [];
+                        recurse (tail, tail.slice (0, 0), r - 1);
+                        return list (result);
+                    }
+                    var combinations_with_replacement = function (iterable, r) {
+                        let tail = list (iterable);
+                        function recurse (tail, molecule, rNext) {
+                            for (let index = 0; index < len (tail); index++) {
+                                let newMolecule = molecule.concat (tail.slice (index, index + 1));
+
+                                if (rNext) {
+                                    recurse (tail.slice (index), newMolecule, rNext - 1);
+                                }
+                                else {
+                                    result.append (tuple (newMolecule));
+                                }
+                            }
+                        }
+                        let result = [];
+                        recurse (tail, tail.slice (0, 0), r - 1);
+                        return list (result);
+                    }
+                    //<all>
+                    __all__.count = count;
+                    __all__.cycle = cycle;
+                    __all__.repeat = repeat;
+                    __all__.accumulate = accumulate;
+                    __all__.chain = chain;
+                    __all__.compress = compress;
+                    __all__.dropwhile = dropwhile;
+                    __all__.filterfalse = filterfalse;
+                    __all__.groupby = groupby;
+                    __all__.islice = islice;
+                    __all__.starmap = starmap;
+                    __all__.takewhile = takewhile;
+                    __all__.tee = tee;
+                    __all__.product = product;
+                    __all__.permutations = permutations;
+                    __all__.combinations = combinations;
+                    __all__.combinations_with_replacement = combinations_with_replacement;
+                    //</all>
+                }
+            }
+        }
+    );
+	__nest__ (
+		__all__,
+		'math', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'math';
+					var pi = Math.PI;
+					var e = Math.E;
+					var exp = Math.exp;
+					var expm1 = function (x) {
+						return Math.exp (x) - 1;
+					};
+					var log = function (x, base) {
+						return (base === undefined ? Math.log (x) : Math.log (x) / Math.log (base));
+					};
+					var log1p = function (x) {
+						return Math.log (x + 1);
+					};
+					var log2 = function (x) {
+						return Math.log (x) / Math.LN2;
+					};
+					var log10 = function (x) {
+						return Math.log (x) / Math.LN10;
+					};
+					var pow = Math.pow;
+					var sqrt = Math.sqrt;
+					var sin = Math.sin;
+					var cos = Math.cos;
+					var tan = Math.tan;
+					var asin = Math.asin;
+					var acos = Math.acos;
+					var atan = Math.atan;
+					var atan2 = Math.atan2;
+					var hypot = Math.hypot;
+					var degrees = function (x) {
+						return (x * 180) / Math.PI;
+					};
+					var radians = function (x) {
+						return (x * Math.PI) / 180;
+					};
+					var sinh = Math.sinh;
+					var cosh = Math.cosh;
+					var tanh = Math.tanh;
+					var asinh = Math.asinh;
+					var acosh = Math.acosh;
+					var atanh = Math.atanh;
+					var floor = Math.floor;
+					var ceil = Math.ceil;
+					var trunc = Math.trunc;
+					var isnan = isNaN;
+					var inf = Infinity;
+					var nan = NaN;
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.acos = acos;
+						__all__.acosh = acosh;
+						__all__.asin = asin;
+						__all__.asinh = asinh;
+						__all__.atan = atan;
+						__all__.atan2 = atan2;
+						__all__.atanh = atanh;
+						__all__.ceil = ceil;
+						__all__.cos = cos;
+						__all__.cosh = cosh;
+						__all__.degrees = degrees;
+						__all__.e = e;
+						__all__.exp = exp;
+						__all__.expm1 = expm1;
+						__all__.floor = floor;
+						__all__.hypot = hypot;
+						__all__.inf = inf;
+						__all__.isnan = isnan;
+						__all__.log = log;
+						__all__.log10 = log10;
+						__all__.log1p = log1p;
+						__all__.log2 = log2;
+						__all__.nan = nan;
+						__all__.pi = pi;
+						__all__.pow = pow;
+						__all__.radians = radians;
+						__all__.sin = sin;
+						__all__.sinh = sinh;
+						__all__.sqrt = sqrt;
+						__all__.tan = tan;
+						__all__.tanh = tanh;
+						__all__.trunc = trunc;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'numscrypt', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var itertools = {};
+					var __name__ = 'numscrypt';
+					__nest__ (itertools, '', __init__ (__world__.itertools));
+					var ns_ctors = dict ({'int32': Int32Array, 'float32': Float32Array, 'float64': Float64Array});
+					var ns_complex = function (dtype) {
+						return __in__ (dtype, tuple (['complex64', 'complex128']));
+					};
+					var ns_buffertype = function (dtype) {
+						return (dtype == 'complex64' ? 'float32' : (dtype == 'complex128' ? 'float64' : dtype));
+					};
+					var ns_complextype = function (dtype) {
+						return (dtype == 'float32' ? 'complex64' : (dtype == 'float64' ? 'complex128' : null));
+					};
+					var ns_createbuf = function (imag, dtype, size) {
+						return (!(imag) || ns_complex (dtype) ? new ns_ctors [ns_buffertype (dtype)] (size) : null);
+					};
+					var ndarray = __class__ ('ndarray', [object], {
+						__module__: __name__,
+						get __init__ () {return __get__ (this, function (self, shape, dtype, realbuf, imagbuf) {
+							if (typeof realbuf == 'undefined' || (realbuf != null && realbuf .hasOwnProperty ("__kwargtrans__"))) {;
+								var realbuf = null;
+							};
+							if (typeof imagbuf == 'undefined' || (imagbuf != null && imagbuf .hasOwnProperty ("__kwargtrans__"))) {;
+								var imagbuf = null;
+							};
+							self.dtype = dtype;
+							self.ns_complex = ns_complex (dtype);
+							self.realbuf = realbuf;
+							if (self.ns_complex) {
+								self.imagbuf = imagbuf;
+							}
+							self.setshape (shape);
+						}, '__init__');},
+						get setshape () {return __get__ (this, function (self, shape) {
+							self.shape = shape;
+							self.ndim = shape.length;
+							self.ns_nrows = shape [0];
+							if (self.ndim == 1) {
+								self.size = self.ns_nrows;
+							}
+							else {
+								self.ns_ncols = shape [1];
+								self.size = self.ns_nrows * self.ns_ncols;
+							}
+						}, 'setshape');},
+						get astype () {return __get__ (this, function (self, dtype) {
+							var result = empty (self.shape, dtype);
+							result.realbuf.set (self.realbuf);
+							if (self.ns_complex) {
+								result.imagbuf.set (self.imagbuf);
+							}
+							return result;
+						}, 'astype');},
+						get tolist () {return __get__ (this, function (self) {
+							if (self.ns_complex) {
+								var flat = (function () {
+									var __accu0__ = [];
+									for (var [real, imag] of zip (list (self.realbuf), list (self.imagbuf))) {
+										__accu0__.append (complex (real, imag));
+									}
+									return __accu0__;
+								}) ();
+							}
+							else {
+								var flat = self.realbuf;
+							}
+							if (self.ndim == 1) {
+								return list (flat);
+							}
+							else {
+								return (function () {
+									var __accu0__ = [];
+									for (var irow = 0; irow < self.ns_nrows; irow++) {
+										__accu0__.append ((function () {
+											var __accu1__ = [];
+											for (var icol = 0; icol < self.ns_ncols; icol++) {
+												__accu1__.append (flat [self.ns_ncols * irow + icol]);
+											}
+											return __accu1__;
+										}) ());
+									}
+									return __accu0__;
+								}) ();
+							}
+						}, 'tolist');},
+						get __repr__ () {return __get__ (this, function (self) {
+							return 'array({})'.format (repr (self.tolist ()));
+						}, '__repr__');},
+						get __str__ () {return __get__ (this, function (self) {
+							if (self.ndim == 1) {
+								return str (self.tolist ());
+							}
+							else {
+								return '[\n\t{}\n]\n'.format ('\n\t'.join ((function () {
+									var __accu0__ = [];
+									for (var row of self.tolist ()) {
+										__accu0__.append (str (row));
+									}
+									return __accu0__;
+								}) ()));
+							}
+						}, '__str__');},
+						get reshape () {return __get__ (this, function (self, shape) {
+							if (self.ndim == 1) {
+								return tuple ([array (self, self.dtype)]);
+							}
+							else {
+								var result = array (self, self.dtype);
+								result.setshape (self.ns_ncols, self.ns_nrows);
+								return result;
+							}
+						}, 'reshape');},
+						get transpose () {return __get__ (this, function (self) {
+							if (self.ndim == 1) {
+								var result = array (self, dtype);
+							}
+							else {
+								var result = empty (tuple ([self.ns_ncols, self.ns_nrows]), self.dtype);
+								var itarget = 0;
+								if (self.ns_complex) {
+									for (var icol = 0; icol < self.ns_ncols; icol++) {
+										var isource = icol;
+										for (var irow = 0; irow < self.ns_nrows; irow++) {
+											var isource = self.ns_ncols * irow + icol;
+											result.imagbuf [itarget] = self.imagbuf [isource];
+											result.realbuf [itarget++] = self.realbuf [isource];
+											isource += self.ns_ncols;
+										}
+									}
+								}
+								else {
+									for (var icol = 0; icol < self.ns_ncols; icol++) {
+										var isource = icol;
+										for (var irow = 0; irow < self.ns_nrows; irow++) {
+											result.realbuf [itarget++] = self.realbuf [isource];
+											isource += self.ns_ncols;
+										}
+									}
+								}
+							}
+							return result;
+						}, 'transpose');},
+						get __getitem__ () {return __get__ (this, function (self, key) {
+							if (self.ndim == 1) {
+								if (py_typeof (key) == tuple) {
+									if (key [1] == null) {
+										key [1] = self.size;
+									}
+									else if (key [1] < 0) {
+										key [1] += self.size;
+									}
+									var result = empty (list ([(key [1] - key [0]) / key [2]]), self.dtype);
+									var itarget = 0;
+									if (self.ns_complex) {
+										for (var isource of range (...self.shape)) {
+											result.realbuf [itarget] = self.realbuf [isource];
+											result.imagbuf [itarget++] = self.imagbuf [isource];
+										}
+									}
+									else {
+										for (var isource of range (...self.shape)) {
+											result.realbuf [itarget++] = self.realbuf [isource];
+										}
+									}
+									return result;
+								}
+								else if (self.ns_complex) {
+									return complex (self.realbuf [key], self.imagbuf [key]);
+								}
+								else {
+									return self.realbuf [key];
+								}
+							}
+							else {
+								var rowkey = key [0];
+								var colkey = key [1];
+								var rowistup = py_typeof (rowkey) == tuple;
+								var colistup = py_typeof (colkey) == tuple;
+								if (rowistup) {
+									if (rowkey [1] == null) {
+										rowkey [1] = self.ns_nrows;
+									}
+									else if (rowkey [1] < 0) {
+										rowkey [1] += self.ns_nrows;
+									}
+								}
+								if (colistup) {
+									if (colkey [1] == null) {
+										colkey [1] = self.ns_ncols;
+									}
+									else if (colkey [1] < 0) {
+										colkey [1] += self.ns_ncols;
+									}
+								}
+								if (rowistup || colistup) {
+									if (!(rowistup)) {
+										var result = empty (tuple ([(colkey [1] - colkey [0]) / colkey [2]]), self.dtype);
+										var itarget = 0;
+										if (self.ns_complex) {
+											for (var isourcecol of range (...colkey)) {
+												var isource = self.ns_ncols * rowkey + isourcecol;
+												result.realbuf [itarget] = self.realbuf [isource];
+												result.imagbuf [itarget++] = self.imagbuf [isource];
+											}
+										}
+										else {
+											for (var isourcecol of range (...colkey)) {
+												result.realbuf [itarget++] = self.realbuf [self.ns_ncols * rowkey + isourcecol];
+											}
+										}
+									}
+									else if (!(colistup)) {
+										var result = empty (tuple ([(rowkey [1] - rowkey [0]) / rowkey [2]]), self.dtype);
+										var itarget = 0;
+										if (self.ns_complex) {
+											for (var isourcerow of range (...rowkey)) {
+												var isource = self.ns_ncols * isourcerow + colkey;
+												result.realbuf [itarget] = self.realbuf [isource];
+												result.imagbuf [itarget++] = self.imagbuf [isource];
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												result.realbuf [itarget++] = self.realbuf [self.ns_ncols * isourcerow + colkey];
+											}
+										}
+									}
+									else {
+										var result = empty (tuple ([(key [0] [1] - key [0] [0]) / key [0] [2], (key [1] [1] - key [1] [0]) / key [1] [2]]), self.dtype);
+										var itarget = 0;
+										if (self.ns_complex) {
+											for (var isourcerow of range (...rowkey)) {
+												for (var isourcecol of range (...colkey)) {
+													var isource = self.ns_ncols * isourcerow + isourcecol;
+													result.realbuf [itarget] = self.realbuf [isource];
+													result.imagbuf [itarget++] = self.imagbuf [isource];
+												}
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												for (var isourcecol of range (...colkey)) {
+													result.realbuf [itarget++] = self.realbuf [self.ns_ncols * isourcerow + isourcecol];
+												}
+											}
+										}
+									}
+									return result;
+								}
+								else if (self.ns_complex) {
+									var isource = self.ns_ncols * key [0] + key [1];
+									return complex (self.realbuf [isource], self.imagbuf [isource]);
+								}
+								else {
+									return self.realbuf [self.ns_ncols * key [0] + key [1]];
+								}
+							}
+						}, '__getitem__');},
+						get __setitem__ () {return __get__ (this, function (self, key, value) {
+							if (self.ndim == 1) {
+								if (py_typeof (key) == tuple) {
+									if (key [1] == null) {
+										key [1] = self.size;
+									}
+									else if (key [1] < 0) {
+										key [1] += self.size;
+									}
+									var isource = 0;
+									if (self.ns_complex) {
+										for (var itarget of range (...self.shape)) {
+											self.realbuf [itarget] = value.realbuf [isource];
+											self.imagbuf [itarget] = value.imagbuf [isource++];
+										}
+									}
+									else {
+										for (var itarget of range (...self.shape)) {
+											self.realbuf [itarget] = value.realbuf [isource++];
+										}
+									}
+									return result;
+								}
+								else if (self.ns_complex) {
+									self.realbuf [key] = value.real;
+									self.imagbuf [key] = value.imag;
+								}
+								else {
+									self.realbuf [key] = value;
+								}
+							}
+							else {
+								var rowkey = key [0];
+								var colkey = key [1];
+								var rowistup = py_typeof (rowkey) == tuple;
+								var colistup = py_typeof (colkey) == tuple;
+								if (rowistup) {
+									if (rowkey [1] == null) {
+										rowkey [1] = self.ns_nrows;
+									}
+									else if (rowkey [1] < 0) {
+										rowkey [1] += self.ns_nrows;
+									}
+								}
+								if (colistup) {
+									if (colkey [1] == null) {
+										colkey [1] = self.ns_ncols;
+									}
+									else if (colkey [1] < 0) {
+										colkey [1] += self.ns_ncols;
+									}
+								}
+								if (rowistup || colistup) {
+									if (!(rowistup)) {
+										var isource = 0;
+										if (self.ns_complex) {
+											for (var itargetcol of range (...colkey)) {
+												var itarget = self.ns_ncols * rowkey + itargetcol;
+												self.realbuf [itarget] = value.realbuf [isource];
+												self.imagbuf [itarget] = value.imagbuf [isource++];
+											}
+										}
+										else {
+											for (var itargetcol of range (...colkey)) {
+												result.realbuf [self.ns_ncols * rowkey + itargetcol] = self.realbuf [isource++];
+											}
+										}
+									}
+									else if (!(colistup)) {
+										var isource = 0;
+										if (self.ns_complex) {
+											for (var itargetrow of range (...rowkey)) {
+												var itarget = self.ns_ncols * itargetrow + colkey;
+												self.realbuf [itarget] = value.realbuf [isource];
+												self.imagbuf [itarget] = value.imagbuf [isource++];
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												self.realbuf [self.ns_ncols * isourcerow + colkey] = value [isource++];
+											}
+										}
+									}
+									else {
+										var isource = 0;
+										if (self.ns_complex) {
+											for (var itargetrow of range (...rowkey)) {
+												for (var itargetcol of range (...colkey)) {
+													var itarget = self.ns_ncols * itargetrow + itargetcol;
+													self.realbuf [itarget] = value.realbuf [isource];
+													self.imagbuf [itarget] = value.imagbuf [isource++];
+												}
+											}
+										}
+										else {
+											for (var isourcerow of range (...rowkey)) {
+												for (var isourcecol of range (...colkey)) {
+													self.realbuf [self.ns_ncols * itargetrow + itargetcol] = value.realbuf [isource++];
+												}
+											}
+										}
+									}
+								}
+								else if (self.ns_complex) {
+									var itarget = self.ns_ncols * key [0] + key [1];
+									self.realbuf [itarget] = value.real;
+									self.imagbuf [itarget] = value.imag;
+								}
+								else {
+									self.realbuf [self.ns_ncols * key [0] + key [1]] = value;
+								}
+							}
+						}, '__setitem__');},
+						get real () {return __get__ (this, function (self) {
+							return ndarray (self.shape, ns_buffertype (self.dtype), self.realbuf);
+						}, 'real');},
+						get imag () {return __get__ (this, function (self) {
+							return ndarray (self.shape, ns_buffertype (self.dtype), self.imagbuf);
+						}, 'imag');},
+						get __neg__ () {return __get__ (this, function (self) {
+							var result = empty (self.shape, self.dtype);
+							if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = -(self.realbuf [i]);
+									result.imagbuf [i] = -(self.imagbuf [i]);
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = -(self.realbuf [i]);
+								}
+							}
+							return result;
+						}, '__neg__');},
+						get __ns_inv__ () {return __get__ (this, function (self) {
+							var result = empty (self.shape, self.dtype);
+							if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									var real = self.realbuf [i];
+									var imag = self.imagbuf [i];
+									var denom = real * real + imag * imag;
+									result.realbuf [i] = real / denom;
+									result.imagbuf [i] = -(imag) / denom;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = 1 / self.realbuf [i];
+								}
+							}
+							return result;
+						}, '__ns_inv__');},
+						get __add__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] + other.realbuf [i];
+										result.imagbuf [i] = self.imagbuf [i] + other.imagbuf [i];
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] + other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] + other.real;
+									result.imagbuf [i] = self.imagbuf [i] + other.imag;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] + other;
+								}
+							}
+							return result;
+						}, '__add__');},
+						get __radd__ () {return __get__ (this, function (self, scalar) {
+							return self.__add__ (scalar);
+						}, '__radd__');},
+						get __sub__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] - other.realbuf [i];
+										result.imagbuf [i] = self.imagbuf [i] - other.imagbuf [i];
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] - other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] - other.real;
+									result.imagbuf [i] = self.imagbuf [i] - other.imag;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] - other;
+								}
+							}
+							return result;
+						}, '__sub__');},
+						get __rsub__ () {return __get__ (this, function (self, scalar) {
+							return self.__neg__ ().__add__ (scalar);
+						}, '__rsub__');},
+						get __mul__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] * other.realbuf [i] - self.imagbuf [i] * other.imagbuf [i];
+										result.imagbuf [i] = self.realbuf [i] * other.imagbuf [i] + self.imagbuf [i] * other.realbuf [i];
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] * other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] * other.real - self.imagbuf [i] * other.imag;
+									result.imagbuf [i] = self.realbuf [i] * other.imag + self.imagbuf [i] * other.real;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] * other;
+								}
+							}
+							return result;
+						}, '__mul__');},
+						get __rmul__ () {return __get__ (this, function (self, scalar) {
+							return self.__mul__ (scalar);
+						}, '__rmul__');},
+						get __div__ () {return __get__ (this, function (self, other) {
+							var result = empty (self.shape, self.dtype);
+							if (py_typeof (other) == ndarray) {
+								if (self.ns_complex) {
+									for (var i = 0; i < self.size; i++) {
+										var real = other.realbuf [i];
+										var imag = other.imagbuf [i];
+										var denom = real * real + imag * imag;
+										result.realbuf [i] = (self.realbuf [i] * real + self.imagbuf [i] * imag) / denom;
+										result.imagbuf [i] = (self.imagbuf [i] * real - self.realbuf [i] * imag) / denom;
+									}
+								}
+								else {
+									for (var i = 0; i < self.size; i++) {
+										result.realbuf [i] = self.realbuf [i] / other.realbuf [i];
+									}
+								}
+							}
+							else if (self.ns_complex) {
+								var real = other.real;
+								var imag = other.imag;
+								var denom = real * real + imag * imag;
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = (self.realbuf [i] * real + self.imagbuf [i] * imag) / denom;
+									result.imagbuf [i] = (self.imagbuf [i] * real - self.realbuf [i] * imag) / denom;
+								}
+							}
+							else {
+								for (var i = 0; i < self.size; i++) {
+									result.realbuf [i] = self.realbuf [i] / other;
+								}
+							}
+							return result;
+						}, '__div__');},
+						get __rdiv__ () {return __get__ (this, function (self, scalar) {
+							return self.__ns_inv__ ().__mul__ (scalar);
+						}, '__rdiv__');},
+						get __matmul__ () {return __get__ (this, function (self, other) {
+							var result = empty (tuple ([self.ns_nrows, other.ns_ncols]), self.dtype);
+							if (self.ns_complex) {
+								var iresult = 0;
+								for (var irow = 0; irow < self.ns_nrows; irow++) {
+									for (var icol = 0; icol < other.ns_ncols; icol++) {
+										result.realbuf [iresult] = 0;
+										result.imagbuf [iresult] = 0;
+										var iself = self.ns_ncols * irow;
+										var iother = icol;
+										for (var iterm = 0; iterm < self.ns_ncols; iterm++) {
+											result.realbuf [iresult] += self.realbuf [iself] * other.realbuf [iother] - self.imagbuf [iself] * other.imagbuf [iother];
+											result.imagbuf [iresult] += self.realbuf [iself] * other.imagbuf [iother] + self.imagbuf [iself++] * other.realbuf [iother];
+											iother += other.ns_ncols;
+										}
+										iresult++;
+									}
+								}
+							}
+							else {
+								var iresult = 0;
+								for (var irow = 0; irow < self.ns_nrows; irow++) {
+									for (var icol = 0; icol < other.ns_ncols; icol++) {
+										result.realbuf [iresult] = 0;
+										var iself = self.ns_ncols * irow;
+										var iother = icol;
+										for (var iterm = 0; iterm < self.ns_ncols; iterm++) {
+											result.realbuf [iresult] += self.realbuf [iself++] * other.realbuf [iother];
+											iother += other.ns_ncols;
+										}
+										iresult++;
+									}
+								}
+							}
+							return result;
+						}, '__matmul__');}
+					});
+					var empty = function (shape, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = ndarray (shape, dtype);
+						result.realbuf = ns_createbuf (false, dtype, result.size);
+						result.imagbuf = ns_createbuf (true, dtype, result.size);
+						return result;
+					};
+					var array = function (obj, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						if (Array.isArray (obj)) {
+							if (len (obj)) {
+								if (Array.isArray (obj [0])) {
+									var result = empty (tuple ([obj.length, obj [0].length]), dtype);
+									var iresult = 0;
+									if (result.ns_complex) {
+										for (var irow = 0; irow < result.ns_nrows; irow++) {
+											for (var icol = 0; icol < result.ns_ncols; icol++) {
+												var element = complex (obj [irow] [icol]);
+												result.realbuf [iresult] = element.real;
+												result.imagbuf [iresult++] = element.imag;
+											}
+										}
+									}
+									else {
+										for (var irow = 0; irow < result.ns_nrows; irow++) {
+											for (var icol = 0; icol < result.ns_ncols; icol++) {
+												result.realbuf [iresult++] = obj [irow] [icol];
+											}
+										}
+									}
+								}
+								else {
+									var result = empty (tuple ([obj.length]), dtype);
+									if (result.ns_complex) {
+										for (var i = 0; i < result.size; i++) {
+											var element = complex (obj [i]);
+											result.realbuf [i] = element.real;
+											result.imagbuf [i] = element.imag;
+										}
+									}
+									else {
+										for (var i = 0; i < result.size; i++) {
+											result.realbuf [i] = obj [i];
+										}
+									}
+								}
+							}
+							else {
+								var result = empty (tuple ([0]), dtype);
+							}
+						}
+						else {
+							var result = empty (obj.shape, dtype);
+							result.realbuf.set (obj.realbuf);
+							if (obj.ns_complex) {
+								result.imagbuf.set (obj.imagbuf);
+							}
+						}
+						return result;
+					};
+					var copy = function (obj) {
+						return array (obj, obj.dtype);
+					};
+					var hsplit = function (ary, nparts) {
+						var result = (function () {
+							var __accu0__ = [];
+							for (var ipart = 0; ipart < nparts; ipart++) {
+								__accu0__.append (empty (tuple ([ary.ns_nrows, ary.ns_ncols / nparts]), ary.dtype));
+							}
+							return __accu0__;
+						}) ();
+						var isource = 0;
+						if (ary.ns_complex) {
+							for (var irow = 0; irow < ary.ns_nrows; irow++) {
+								for (var part of result) {
+									var itarget = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										part.realbuf [itarget] = ary.realbuf [isource];
+										part.imagbuf [itarget++] = ary.imagbuf [isource++];
+									}
+								}
+							}
+						}
+						else {
+							for (var irow = 0; irow < ary.ns_nrows; irow++) {
+								for (var part of result) {
+									var itarget = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										part.realbuf [itarget++] = ary.realbuf [isource++];
+									}
+								}
+							}
+						}
+						return result;
+					};
+					var vsplit = function (ary, nparts) {
+						var result = (function () {
+							var __accu0__ = [];
+							for (var ipart = 0; ipart < nparts; ipart++) {
+								__accu0__.append (empty (tuple ([ary.ns_nrows / nparts, ary.ns_ncols]), array.dtype));
+							}
+							return __accu0__;
+						}) ();
+						var isource = 0;
+						if (ary.ns_complex) {
+							for (var part of result) {
+								for (var itarget = 0; itarget < part.size; itarget++) {
+									part.realbuf [itarget] = ary.realbuf [isource];
+									part.imagbuf [itarget] = ary.imagbuf [isource++];
+								}
+							}
+						}
+						else {
+							for (var part of result) {
+								for (var itarget = 0; itarget < part.size; itarget++) {
+									part.realbuf [itarget] = ary.realbuf [isource++];
+								}
+							}
+						}
+						return result;
+					};
+					var hstack = function (tup) {
+						var ncols = 0;
+						for (var part of tup) {
+							ncols += part.ns_ncols;
+						}
+						var result = empty (tuple ([tup [0].ns_nrows, ncols]), tup [0].dtype);
+						var itarget = 0;
+						if (result.ns_complex) {
+							for (var irow = 0; irow < result.ns_nrows; irow++) {
+								for (var part of tup) {
+									var isource = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										result.realbuf [itarget] = part.realbuf [isource];
+										result.imagbuf [itarget++] = part.imagbuf [isource++];
+									}
+								}
+							}
+						}
+						else {
+							for (var irow = 0; irow < result.ns_nrows; irow++) {
+								for (var part of tup) {
+									var isource = part.ns_ncols * irow;
+									for (var icol = 0; icol < part.ns_ncols; icol++) {
+										result.realbuf [itarget++] = part.realbuf [isource++];
+									}
+								}
+							}
+						}
+						return result;
+					};
+					var vstack = function (tup) {
+						var nrows = 0;
+						for (var part of tup) {
+							nrows += part.ns_nrows;
+						}
+						var result = empty (tuple ([nrows, tup [0].ns_ncols]), tup [0].dtype);
+						var itarget = 0;
+						if (result.ns_complex) {
+							for (var part of tup) {
+								for (var isource = 0; isource < part.size; isource++) {
+									result.realbuf [itarget] = part.realbuf [isource];
+									result.imagbuf [itarget++] = part.imagbuf [isource];
+								}
+							}
+						}
+						else {
+							for (var part of tup) {
+								for (var isource = 0; isource < part.size; isource++) {
+									result.realbuf [itarget++] = part.realbuf [isource];
+								}
+							}
+						}
+						return result;
+					};
+					var round = function (a, decimals) {
+						if (typeof decimals == 'undefined' || (decimals != null && decimals .hasOwnProperty ("__kwargtrans__"))) {;
+							var decimals = 0;
+						};
+						var result = empty (a.shape, a.dtype);
+						if (a.ns_complex) {
+							for (var i = 0; i < a.size; i++) {
+								result.realbuf [i] = a.realbuf [i].toFixed (decimals);
+								result.imagbuf [i] = a.imagbuf [i].toFixed (decimals);
+							}
+						}
+						else {
+							for (var i = 0; i < a.size; i++) {
+								result.realbuf [i] = a.realbuf [i].toFixed (decimals);
+							}
+						}
+						return result;
+					};
+					var zeros = function (shape, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = empty (shape, dtype);
+						if (result.ns_complex) {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 0;
+								result.imagbuf [i] = 0;
+							}
+						}
+						else {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 0;
+							}
+						}
+						return result;
+					};
+					var ones = function (shape, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = empty (shape, dtype);
+						if (result.ns_complex) {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 1;
+								result.imagbuf [i] = 0;
+							}
+						}
+						else {
+							for (var i = 0; i < result.size; i++) {
+								result.realbuf [i] = 1;
+							}
+						}
+						return result;
+					};
+					var identity = function (n, dtype) {
+						if (typeof dtype == 'undefined' || (dtype != null && dtype .hasOwnProperty ("__kwargtrans__"))) {;
+							var dtype = 'float64';
+						};
+						var result = zeros (tuple ([n, n]), dtype);
+						var i = 0;
+						var shift = n + 1;
+						for (var j = 0; j < n; j++) {
+							result.realbuf [i] = 1;
+							i += shift;
+						}
+						return result;
+					};
+					__pragma__ ('<use>' +
+						'itertools' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.array = array;
+						__all__.copy = copy;
+						__all__.empty = empty;
+						__all__.hsplit = hsplit;
+						__all__.hstack = hstack;
+						__all__.identity = identity;
+						__all__.ndarray = ndarray;
+						__all__.ns_buffertype = ns_buffertype;
+						__all__.ns_complex = ns_complex;
+						__all__.ns_complextype = ns_complextype;
+						__all__.ns_createbuf = ns_createbuf;
+						__all__.ns_ctors = ns_ctors;
+						__all__.ones = ones;
+						__all__.round = round;
+						__all__.vsplit = vsplit;
+						__all__.vstack = vstack;
+						__all__.zeros = zeros;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'numscrypt.linalg', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'numscrypt.linalg';
+					var ns =  __init__ (__world__.numscrypt);
+					var inv = function (a) {
+						if (a.ns_complex) {
+							return cinv (a);
+						}
+						else {
+							return rinv (a);
+						}
+					};
+					var rinv = function (a) {
+						var b = ns.hstack (tuple ([a, ns.identity (a.shape [0], a.dtype)]));
+						var real = b.realbuf;
+						var __left0__ = b.shape;
+						var nrows = __left0__ [0];
+						var ncols = __left0__ [1];
+						for (var ipiv = 0; ipiv < nrows; ipiv++) {
+							if (!(real [ipiv * ncols + ipiv])) {
+								for (var irow = ipiv + 1; irow < nrows; irow++) {
+									if (real [irow * ncols + ipiv]) {
+										for (var icol = 0; icol < ncols; icol++) {
+											var t = real [irow * ncols + icol];
+											real [irow * ncols + icol] = b [ipiv * ncols + icol];
+											real [ipiv * ncols + icol] = t;
+										}
+										break;
+									}
+								}
+							}
+							var piv = real [ipiv * ncols + ipiv];
+							for (var icol = ipiv; icol < ncols; icol++) {
+								real [ipiv * ncols + icol] /= piv;
+							}
+							for (var irow = 0; irow < nrows; irow++) {
+								if (irow != ipiv) {
+									var factor = real [irow * ncols + ipiv];
+									for (var icol = 0; icol < ncols; icol++) {
+										real [irow * ncols + icol] -= factor * real [ipiv * ncols + icol];
+									}
+								}
+							}
+						}
+						return ns.hsplit (b, 2) [1];
+					};
+					var cinv = function (a) {
+						var b = ns.hstack (tuple ([a, ns.identity (a.shape [0], a.dtype)]));
+						var real = b.realbuf;
+						var imag = b.imagbuf;
+						var __left0__ = b.shape;
+						var nrows = __left0__ [0];
+						var ncols = __left0__ [1];
+						for (var ipiv = 0; ipiv < nrows; ipiv++) {
+							var ipiv_flat = ipiv * ncols + ipiv;
+							if (!(real [ipiv_flat] || imag [ipiv_flat])) {
+								for (var irow = ipiv + 1; irow < nrows; irow++) {
+									var iswap = irow * ncols + ipiv;
+									if (real [iswap] || imag [iswap]) {
+										for (var icol = 0; icol < ncols; icol++) {
+											var isource = irow * ncols + icol;
+											var itarget = ipiv * ncols + icol;
+											var t = real [isource];
+											real [isource] = real [itarget];
+											real [itarget] = t;
+											var t = imag [isource_flat];
+											imag [isource] = imag [itarget];
+											imag [itarget] = t;
+										}
+										break;
+									}
+								}
+							}
+							var pivre = real [ipiv_flat];
+							var pivim = imag [ipiv_flat];
+							var denom = pivre * pivre + pivim * pivim;
+							for (var icol = ipiv; icol < ncols; icol++) {
+								var icur = ipiv * ncols + icol;
+								var oldre = real [icur];
+								var oldim = imag [icur];
+								real [icur] = (oldre * pivre + oldim * pivim) / denom;
+								imag [icur] = (oldim * pivre - oldre * pivim) / denom;
+							}
+							for (var irow = 0; irow < nrows; irow++) {
+								if (irow != ipiv) {
+									var ifac = irow * ncols + ipiv;
+									var facre = real [ifac];
+									var facim = imag [ifac];
+									for (var icol = 0; icol < ncols; icol++) {
+										var itarget = irow * ncols + icol;
+										var isource = ipiv * ncols + icol;
+										var oldre = real [isource];
+										var oldim = imag [isource];
+										real [itarget] -= facre * oldre - facim * oldim;
+										imag [itarget] -= facre * oldim + facim * oldre;
+									}
+								}
+							}
+						}
+						return ns.hsplit (b, 2) [1];
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.cinv = cinv;
+						__all__.inv = inv;
+						__all__.rinv = rinv;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'numscrypt.random', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var __name__ = 'numscrypt.random';
+					var ns =  __init__ (__world__.numscrypt);
+					var rand = function () {
+						var dims = tuple ([].slice.apply (arguments).slice (0));
+						var result = ns.empty (dims, 'float64');
+						for (var i = 0; i < result.size; i++) {
+							result.realbuf [i] = Math.random ();
+						}
+						return result;
+					};
+					__pragma__ ('<use>' +
+						'numscrypt' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__.rand = rand;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	__nest__ (
+		__all__,
+		'random', {
+			__all__: {
+				__inited__: false,
+				__init__: function (__all__) {
+					var math = {};
+					var __name__ = 'random';
+					__nest__ (math, '', __init__ (__world__.math));
+					var _array = (function () {
+						var __accu0__ = [];
+						for (var i = 0; i < 624; i++) {
+							__accu0__.append (0);
+						}
+						return __accu0__;
+					}) ();
+					var _index = 0;
+					var _bitmask1 = Math.pow (2, 32) - 1;
+					var _bitmask2 = Math.pow (2, 31);
+					var _bitmask3 = Math.pow (2, 31) - 1;
+					var _fill_array = function () {
+						for (var i = 0; i < 624; i++) {
+							var y = (_array [i] & _bitmask2) + (_array [__mod__ (i + 1, 624)] & _bitmask3);
+							_array [i] = _array [__mod__ (i + 397, 624)] ^ y >> 1;
+							if (__mod__ (y, 2) != 0) {
+								_array [i] ^= 2567483615;
+							}
+						}
+					};
+					var _random_integer = function () {
+						if (_index == 0) {
+							_fill_array ();
+						}
+						var y = _array [_index];
+						y ^= y >> 11;
+						y ^= y << 7 & 2636928640;
+						y ^= y << 15 & 4022730752;
+						y ^= y >> 18;
+						_index = __mod__ (_index + 1, 624);
+						return y;
+					};
+					var seed = function (x) {
+						if (typeof x == 'undefined' || (x != null && x .hasOwnProperty ("__kwargtrans__"))) {;
+							var x = int (_bitmask3 * Math.random ());
+						};
+						_array [0] = x;
+						for (var i = 1; i < 624; i++) {
+							_array [i] = (1812433253 * _array [i - 1] ^ (_array [i - 1] >> 30) + i) & _bitmask1;
+						}
+					};
+					var randint = function (a, b) {
+						return a + __mod__ (_random_integer (), (b - a) + 1);
+					};
+					var choice = function (seq) {
+						return seq [randint (0, len (seq) - 1)];
+					};
+					var random = function () {
+						return _random_integer () / _bitmask3;
+					};
+					var shuffle = function (x) {
+						for (var i = len (x) - 1; i > 0; i--) {
+							var j = math.floor (random () * (i + 1));
+							var temp = x [i];
+							x [i] = x [j];
+							x [j] = temp;
+						}
+					};
+					seed ();
+					__pragma__ ('<use>' +
+						'math' +
+					'</use>')
+					__pragma__ ('<all>')
+						__all__.__name__ = __name__;
+						__all__._array = _array;
+						__all__._bitmask1 = _bitmask1;
+						__all__._bitmask2 = _bitmask2;
+						__all__._bitmask3 = _bitmask3;
+						__all__._fill_array = _fill_array;
+						__all__._index = _index;
+						__all__._random_integer = _random_integer;
+						__all__.choice = choice;
+						__all__.randint = randint;
+						__all__.random = random;
+						__all__.seed = seed;
+						__all__.shuffle = shuffle;
+					__pragma__ ('</all>')
+				}
+			}
+		}
+	);
+	(function () {
+		var random = {};
+		var __name__ = '__main__';
+		var num =  __init__ (__world__.numscrypt);
+		var num_rand =  __init__ (__world__.numscrypt.random);
+		var linalg =  __init__ (__world__.numscrypt.linalg);
+		__nest__ (random, '', __init__ (__world__.random));
+		var result = '';
+		for (var useComplex of tuple ([false, true])) {
+			for (var transpose of tuple ([false, true])) {
+				if (useComplex) {
+					var a = num.array ((function () {
+						var __accu0__ = [];
+						for (var iRow = 0; iRow < 30; iRow++) {
+							__accu0__.append ((function () {
+								var __accu1__ = [];
+								for (var iCol = 0; iCol < 30; iCol++) {
+									__accu1__.append (complex (random.random (), random.random ()));
+								}
+								return __accu1__;
+							}) ());
+						}
+						return __accu0__;
+					}) (), 'complex128');
+				}
+				else {
+					var a = num_rand.rand (30, 30);
+				}
+				var timeStartTranspose = new Date ();
+				if (transpose) {
+					var a = a.transpose ();
+				}
+				var timeStartInv = new Date ();
+				var ai = linalg.inv (a);
+				var timeStartMul = new Date ();
+				var id = __matmul__ (a, ai);
+				var timeStartScalp = new Date ();
+				var sp = __mul__ (a, a);
+				var timeStartDiv = new Date ();
+				var sp = __truediv__ (a, a);
+				var timeStartAdd = new Date ();
+				var sp = __add__ (a, a);
+				var timeStartSub = new Date ();
+				var sp = __sub__ (a, a);
+				var timeEnd = new Date ();
+				result += '\n<pre>\na @ ai [0:5, 0:5] =\n\n{}\n'.format (str (num.round (id.__getitem__ ([tuple ([0, 5, 1]), tuple ([0, 5, 1])]), 2)).py_replace (' ', '\t'));
+				if (transpose) {
+					result += '\nTranspose took: {} ms'.format (timeStartInv - timeStartTranspose);
+				}
+				result += '\nInverse took: {} ms\nMatrix product (@) took: {} ms\nElementwise product (*) took: {} ms\nDivision took: {} ms\nAddition took: {} ms\nSubtraction took: {} ms\n</pre>\n'.format (timeStartMul - timeStartInv, timeStartScalp - timeStartMul, timeStartDiv - timeStartScalp, timeStartAdd - timeStartDiv, timeStartSub - timeStartAdd, timeEnd - timeStartSub);
+			}
+		}
+		document.getElementById ('result').innerHTML = result;
+		__pragma__ ('<use>' +
+			'numscrypt' +
+			'numscrypt.linalg' +
+			'numscrypt.random' +
+			'random' +
+		'</use>')
+		__pragma__ ('<all>')
+			__all__.__name__ = __name__;
+			__all__.a = a;
+			__all__.ai = ai;
+			__all__.id = id;
+			__all__.result = result;
+			__all__.sp = sp;
+			__all__.timeEnd = timeEnd;
+			__all__.timeStartAdd = timeStartAdd;
+			__all__.timeStartDiv = timeStartDiv;
+			__all__.timeStartInv = timeStartInv;
+			__all__.timeStartMul = timeStartMul;
+			__all__.timeStartScalp = timeStartScalp;
+			__all__.timeStartSub = timeStartSub;
+			__all__.timeStartTranspose = timeStartTranspose;
+			__all__.transpose = transpose;
+			__all__.useComplex = useComplex;
+		__pragma__ ('</all>')
+	}) ();
+   return __all__;
+}
+window ['test'] = test ();
diff --git a/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.min.js b/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.min.js
new file mode 100644
index 0000000..dbaeb5d
--- /dev/null
+++ b/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.min.js
@@ -0,0 +1,132 @@
+'use strict';var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(c,l,q){c!=Array.prototype&&c!=Object.prototype&&(c[l]=q.value)};$jscomp.getGlobal=function(c){return"undefined"!=typeof window&&window===c?c:"undefined"!=typeof global&&null!=global?global:c};$jscomp.global=$jscomp.getGlobal(this);
+$jscomp.SYMBOL_PREFIX="jscomp_symbol_";$jscomp.initSymbol=function(){$jscomp.initSymbol=function(){};$jscomp.global.Symbol||($jscomp.global.Symbol=$jscomp.Symbol)};$jscomp.symbolCounter_=0;$jscomp.Symbol=function(c){return $jscomp.SYMBOL_PREFIX+(c||"")+$jscomp.symbolCounter_++};
+$jscomp.initSymbolIterator=function(){$jscomp.initSymbol();var c=$jscomp.global.Symbol.iterator;c||(c=$jscomp.global.Symbol.iterator=$jscomp.global.Symbol("iterator"));"function"!=typeof Array.prototype[c]&&$jscomp.defineProperty(Array.prototype,c,{configurable:!0,writable:!0,value:function(){return $jscomp.arrayIterator(this)}});$jscomp.initSymbolIterator=function(){}};$jscomp.arrayIterator=function(c){var l=0;return $jscomp.iteratorPrototype(function(){return l<c.length?{done:!1,value:c[l++]}:{done:!0}})};
+$jscomp.iteratorPrototype=function(c){$jscomp.initSymbolIterator();c={next:c};c[$jscomp.global.Symbol.iterator]=function(){return this};return c};$jscomp.makeIterator=function(c){$jscomp.initSymbolIterator();$jscomp.initSymbol();$jscomp.initSymbolIterator();var l=c[Symbol.iterator];return l?l.call(c):$jscomp.arrayIterator(c)};$jscomp.arrayFromIterator=function(c){for(var l,q=[];!(l=c.next()).done;)q.push(l.value);return q};$jscomp.arrayFromIterable=function(c){return c instanceof Array?c:$jscomp.arrayFromIterator($jscomp.makeIterator(c))};
+$jscomp.polyfill=function(c,l,q,r){if(l){q=$jscomp.global;c=c.split(".");for(r=0;r<c.length-1;r++){var y=c[r];y in q||(q[y]={});q=q[y]}c=c[c.length-1];r=q[c];l=l(r);l!=r&&null!=l&&$jscomp.defineProperty(q,c,{configurable:!0,writable:!0,value:l})}};$jscomp.polyfill("Object.getOwnPropertySymbols",function(c){return c?c:function(){return[]}},"es6","es5");
+$jscomp.checkStringArgs=function(c,l,q){if(null==c)throw new TypeError("The 'this' value for String.prototype."+q+" must not be null or undefined");if(l instanceof RegExp)throw new TypeError("First argument to String.prototype."+q+" must not be a regular expression");return c+""};
+$jscomp.polyfill("String.prototype.startsWith",function(c){return c?c:function(l,c){var q=$jscomp.checkStringArgs(this,l,"startsWith");l+="";var y=q.length,v=l.length;c=Math.max(0,Math.min(c|0,q.length));for(var u=0;u<v&&c<y;)if(q[c++]!=l[u++])return!1;return u>=v}},"es6","es3");
+$jscomp.polyfill("Array.from",function(c){return c?c:function(l,c,r){$jscomp.initSymbolIterator();c=null!=c?c:function(c){return c};var q=[],v=l[Symbol.iterator];if("function"==typeof v)for(l=v.call(l);!(v=l.next()).done;)q.push(c.call(r,v.value));else{v=l.length;for(var u=0;u<v;u++)q.push(c.call(r,l[u]))}return q}},"es6","es3");
+$jscomp.iteratorFromArray=function(c,l){$jscomp.initSymbolIterator();c instanceof String&&(c+="");var q=0,r={next:function(){if(q<c.length){var y=q++;return{value:l(y,c[y]),done:!1}}r.next=function(){return{done:!0,value:void 0}};return r.next()}};r[Symbol.iterator]=function(){return r};return r};$jscomp.polyfill("Array.prototype.keys",function(c){return c?c:function(){return $jscomp.iteratorFromArray(this,function(c){return c})}},"es6","es3");
+$jscomp.polyfill("Math.hypot",function(c){return c?c:function(c,q,r){c=Number(c);q=Number(q);var l,v=Math.max(Math.abs(c),Math.abs(q));for(l=2;l<arguments.length;l++)v=Math.max(v,Math.abs(arguments[l]));if(1E100<v||1E-100>v){c/=v;q/=v;var u=c*c+q*q;for(l=2;l<arguments.length;l++){var t=Number(arguments[l])/v;u+=t*t}return Math.sqrt(u)*v}u=c*c+q*q;for(l=2;l<arguments.length;l++)t=Number(arguments[l]),u+=t*t;return Math.sqrt(u)}},"es6","es3");
+$jscomp.polyfill("Math.sinh",function(c){if(c)return c;var l=Math.exp;return function(c){c=Number(c);return 0===c?c:(l(c)-l(-c))/2}},"es6","es3");$jscomp.polyfill("Math.cosh",function(c){if(c)return c;var l=Math.exp;return function(c){c=Number(c);return(l(c)+l(-c))/2}},"es6","es3");$jscomp.polyfill("Math.tanh",function(c){return c?c:function(c){c=Number(c);if(0===c)return c;var l=Math.exp(-2*Math.abs(c));l=(1-l)/(1+l);return 0>c?-l:l}},"es6","es3");
+$jscomp.polyfill("Math.asinh",function(c){return c?c:function(c){c=Number(c);if(0===c)return c;var l=Math.log(Math.abs(c)+Math.sqrt(c*c+1));return 0>c?-l:l}},"es6","es3");$jscomp.polyfill("Math.acosh",function(c){return c?c:function(c){c=Number(c);return Math.log(c+Math.sqrt(c*c-1))}},"es6","es3");$jscomp.polyfill("Math.log1p",function(c){return c?c:function(c){c=Number(c);if(.25>c&&-.25<c){for(var l=c,r=1,y=c,v=0,u=1;v!=y;)l*=c,u*=-1,y=(v=y)+u*l/++r;return y}return Math.log(1+c)}},"es6","es3");
+$jscomp.polyfill("Math.atanh",function(c){if(c)return c;var l=Math.log1p;return function(c){c=Number(c);return(l(c)-l(-c))/2}},"es6","es3");$jscomp.polyfill("Math.trunc",function(c){return c?c:function(c){c=Number(c);if(isNaN(c)||Infinity===c||-Infinity===c||0===c)return c;var l=Math.floor(Math.abs(c));return 0>c?-l:l}},"es6","es3");
+function test(){function c(a){return void 0===a||null===a?!1:0<=["boolean","number"].indexOf(typeof a)?a:a.__bool__ instanceof Function?a.__bool__()?a:!1:a.__len__ instanceof Function?0!==a.__len__()?a:!1:a instanceof Function?a:0!==A(a)?a:!1}function l(a){this.iterable=a;this.index=0}function q(a){this.iterable=a;this.index=0}function r(a,b,g){void 0==b&&(b=a,a=0);void 0==g&&(g=1);if(0<g&&a>=b||0>g&&a<=b)return[];for(var h=[];0<g?a<b:a>b;a+=g)h.push(a);return h}function y(a){if(null==a||"object"==
+typeof a)return a;var b={},g;for(g in obj)a.hasOwnProperty(g)&&(b[g]=a[g]);return b}function v(a){if(null==a||"object"==typeof a)return a;var b={},g;for(g in obj)a.hasOwnProperty(g)&&(b[g]=v(a[g]));return b}function u(a){return a?Array.from(a):[]}function t(a){a=a?[].slice.apply(a):[];a.__class__=t;return a}function J(a){var b=[];if(a)for(var g=0;g<a.length;g++)b.add(a[g]);b.__class__=J;return b}function ba(a,b){if(void 0==a)return new Uint8Array(0);b=B(a);if(b==P)return new Uint8Array(a);if(b==E){b=
+new Uint8Array(A(a));for(var g=0;g<A(a);g++)b[g]=a.charCodeAt(g);return b}if(b==u||b==t)return new Uint8Array(a);throw ja;}function E(a){try{return a.__str__()}catch(b){try{return Q(a)}catch(g){return String(a)}}}function ka(){var a=[],b;for(b in this)R(b)||a.push(b);return a}function la(){var a=[],b;for(b in this)R(b)||a.push([b,this[b]]);return a}function ma(a){delete this[a]}function na(){for(var a in this)delete this[a]}function oa(a,b){a=this[a];return void 0==a?void 0==b?null:b:a}function pa(a,
+b){var g=this[a];if(void 0!=g)return g;b=void 0==b?null:b;return this[a]=b}function qa(a,b){var g=this[a];if(void 0!=g)return delete this[a],g;if(void 0===b)throw ca(a,Error());return b}function ra(){var a=Object.keys(this)[0];if(null==a)throw ca("popitem(): dictionary is empty",Error());var b=t([a,this[a]]);delete this[a];return b}function sa(a){for(var b in a)this[b]=a[b]}function ta(){var a=[],b;for(b in this)R(b)||a.push(this[b]);return a}function ua(a){return this[a]}function va(a,b){this[a]=
+b}function I(a){var b={};if(!a||a instanceof Array){if(a)for(var g=0;g<a.length;g++){var h=a[g];if(!(h instanceof Array)||2!=h.length)throw X("dict update sequence element #"+g+" has length "+h.length+"; 2 is required",Error());var c=h[0];h=h[1];!(a instanceof Array)&&a instanceof Object&&(W(a,I)||(h=I(h)));b[c]=h}}else if(W(a,I))for(h=a.py_keys(),g=0;g<h.length;g++)c=h[g],b[c]=a[c];else if(a instanceof Object)b=a;else throw X("Invalid type of object for dict creation",Error());w(b,"__class__",{value:I,
+enumerable:!1,writable:!0});w(b,"py_keys",{value:ka,enumerable:!1});w(b,"__iter__",{value:function(){new l(this.py_keys())},enumerable:!1});$jscomp.initSymbol();$jscomp.initSymbolIterator();w(b,Symbol.iterator,{value:function(){new q(this.py_keys())},enumerable:!1});w(b,"py_items",{value:la,enumerable:!1});w(b,"py_del",{value:ma,enumerable:!1});w(b,"py_clear",{value:na,enumerable:!1});w(b,"py_get",{value:oa,enumerable:!1});w(b,"py_setdefault",{value:pa,enumerable:!1});w(b,"py_pop",{value:qa,enumerable:!1});
+w(b,"py_popitem",{value:ra,enumerable:!1});w(b,"py_update",{value:sa,enumerable:!1});w(b,"py_values",{value:ta,enumerable:!1});w(b,"__getitem__",{value:ua,enumerable:!1});w(b,"__setitem__",{value:va,enumerable:!1});return b}var d={},F=function(a,b,g){if(""!=b){b=b.split(".");for(var h=b.length,c=0;c<b.length;c++){if(!a.hasOwnProperty(b[c])){h=c;break}a=a[b[c]]}for(c=h;c<b.length;c++)a[b[c]]={},a=a[b[c]]}for(var d in g)a[d]=g[d]};d.__nest__=F;var K=function(a){a.__inited__||(a.__all__.__init__(a.__all__),
+a.__inited__=!0);return a.__all__};d.__init__=K;var p=function(a,b,g){return a&&(a.hasOwnProperty("__class__")||"string"==typeof a||a instanceof String)?(g&&Object.defineProperty(a,g,{value:function(){var g=[].slice.apply(arguments);return b.apply(null,[a].concat(g))},writable:!0,enumerable:!0,configurable:!0}),function(){var g=[].slice.apply(arguments);return b.apply(null,[a].concat(g))}):b};d.__get__=p;d.__getcm__=function(a,b,g){return a.hasOwnProperty("__class__")?function(){var g=[].slice.apply(arguments);
+return b.apply(null,[a.__class__].concat(g))}:function(){var g=[].slice.apply(arguments);return b.apply(null,[a].concat(g))}};d.__getsm__=function(a,b,g){return b};var N={__name__:"type",__bases__:[],__new__:function(a,b,g,c){for(var h,d,k=function(){var a=[].slice.apply(arguments);return k.__new__(a)},M=g.length-1;0<=M;M--){var L=g[M],e;for(e in L)h=Object.getOwnPropertyDescriptor(L,e),Object.defineProperty(k,e,h);var f=$jscomp.makeIterator(Object.getOwnPropertySymbols(L));for(h=f.next();!h.done;h=
+f.next())d=h.value,h=Object.getOwnPropertyDescriptor(L,d),Object.defineProperty(k,d,h)}k.__metaclass__=a;k.__name__=b.startsWith("py_")?b.slice(3):b;k.__bases__=g;for(e in c)h=Object.getOwnPropertyDescriptor(c,e),Object.defineProperty(k,e,h);a=$jscomp.makeIterator(Object.getOwnPropertySymbols(c));for(h=a.next();!h.done;h=a.next())d=h.value,h=Object.getOwnPropertyDescriptor(c,d),Object.defineProperty(k,d,h);return k}};N.__metaclass__=N;d.py_metatype=N;var S={__init__:function(a){},__metaclass__:N,
+__name__:"object",__bases__:[],__new__:function(a){var b=Object.create(this,{__class__:{value:this,enumerable:!0}});if("__getattr__"in this||"__setattr__"in this)b=new Proxy(b,{get:function(a,b){var g=a[b];return void 0==g?a.__getattr__(b):g},set:function(a,b,c){try{a.__setattr__(b,c)}catch(H){a[b]=c}return!0}});this.__init__.apply(null,[b].concat(a));return b}};d.object=S;var x=function(a,b,g,c){void 0==c&&(c=b[0].__metaclass__);return c.__new__(c,a,b,g)};d.__class__=x;d.__pragma__=function(){};
+F(d,"org.transcrypt.__base__",{__all__:{__inited__:!1,__init__:function(a){var b=x("__Envir__",[S],{__module__:"org.transcrypt.__base__",get __init__(){return p(this,function(a){a.interpreter_name="python";a.transpiler_name="transcrypt";a.transpiler_version="3.6.66";a.target_subdir="__javascript__"},"__init__")}}),g=b();a.__Envir__=b;a.__envir__=g;a.__name__="org.transcrypt.__base__"}}});F(d,"org.transcrypt.__standard__",{__all__:{__inited__:!1,__init__:function(a){var b=x("Exception",[S],{__module__:"org.transcrypt.__standard__",
+get __init__(){return p(this,function(a){var b=I();if(arguments.length){var e=arguments.length-1;if(arguments[e]&&arguments[e].hasOwnProperty("__kwargtrans__")){var f=arguments[e--],m;for(m in f)switch(m){case "self":a=f[m];break;default:b[m]=f[m]}delete b.__kwargtrans__}e=t([].slice.apply(arguments).slice(1,e+1))}else e=t();a.__args__=e;try{a.stack=b.error.stack}catch(Ba){a.stack="No stack trace available"}},"__init__")},get __repr__(){return p(this,function(a){return A(a.__args__)?"{}{}".format(a.__class__.__name__,
+Q(t(a.__args__))):"{}()".format(a.__class__.__name__)},"__repr__")},get __str__(){return p(this,function(a){return 1<A(a.__args__)?E(t(a.__args__)):A(a.__args__)?E(a.__args__[0]):""},"__str__")}}),g=x("IterableError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e){b.__init__(a,"Can't iterate over non-iterable",D({error:e}))},"__init__")}}),c=x("StopIteration",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e){b.__init__(a,
+"Iterator exhausted",D({error:e}))},"__init__")}}),d=x("ValueError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e,f){b.__init__(a,e,D({error:f}))},"__init__")}}),H=x("KeyError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e,f){b.__init__(a,e,D({error:f}))},"__init__")}}),k=x("AssertionError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e,f){e?b.__init__(a,e,D({error:f})):b.__init__(a,
+D({error:f}))},"__init__")}}),M=x("NotImplementedError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e,f){b.__init__(a,e,D({error:f}))},"__init__")}}),L=x("IndexError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e,f){b.__init__(a,e,D({error:f}))},"__init__")}}),e=x("AttributeError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e,f){b.__init__(a,e,D({error:f}))},"__init__")}}),
+f=x("py_TypeError",[b],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,e,f){b.__init__(a,e,D({error:f}))},"__init__")}}),n=x("Warning",[b],{__module__:"org.transcrypt.__standard__"}),m=x("UserWarning",[n],{__module__:"org.transcrypt.__standard__"}),C=x("DeprecationWarning",[n],{__module__:"org.transcrypt.__standard__"}),G=x("RuntimeWarning",[n],{__module__:"org.transcrypt.__standard__"}),Y=function(a,b,e){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=
+null;if("undefined"==typeof e||null!=e&&e.hasOwnProperty("__kwargtrans__"))e=!1;if(arguments.length){var f=arguments.length-1;if(arguments[f]&&arguments[f].hasOwnProperty("__kwargtrans__")){f=arguments[f--];for(var m in f)switch(m){case "iterable":a=f[m];break;case "key":b=f[m];break;case "reverse":e=f[m]}}}b?a.sort(function(a,e){if(arguments.length){var f=arguments.length-1;if(arguments[f]&&arguments[f].hasOwnProperty("__kwargtrans__")){f=arguments[f--];for(var m in f)switch(m){case "a":a=f[m];break;
+case "b":e=f[m]}}}return b(a)>b(e)?1:-1}):a.sort();e&&a.reverse()},z=x("complex",[S],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a,b,e){if("undefined"==typeof e||null!=e&&e.hasOwnProperty("__kwargtrans__"))e=null;null==e?B(b)==z?(a.real=b.real,a.imag=b.imag):(a.real=b,a.imag=0):(a.real=b,a.imag=e)},"__init__")},get __neg__(){return p(this,function(a){return z(-a.real,-a.imag)},"__neg__")},get __exp__(){return p(this,function(a){var b=Math.exp(a.real);return z(b*
+Math.cos(a.imag),b*Math.sin(a.imag))},"__exp__")},get __log__(){return p(this,function(a){return z(Math.log(Math.sqrt(a.real*a.real+a.imag*a.imag)),Math.atan2(a.imag,a.real))},"__log__")},get __pow__(){return p(this,function(a,b){return a.__log__().__mul__(b).__exp__()},"__pow__")},get __rpow__(){return p(this,function(a,b){return a.__mul__(Math.log(b)).__exp__()},"__rpow__")},get __mul__(){return p(this,function(a,b){return"number"===typeof b?z(a.real*b,a.imag*b):z(a.real*b.real-a.imag*b.imag,a.real*
+b.imag+a.imag*b.real)},"__mul__")},get __rmul__(){return p(this,function(a,b){return z(a.real*b,a.imag*b)},"__rmul__")},get __div__(){return p(this,function(a,b){if("number"===typeof b)return z(a.real/b,a.imag/b);var e=b.real*b.real+b.imag*b.imag;return z((a.real*b.real+a.imag*b.imag)/e,(a.imag*b.real-a.real*b.imag)/e)},"__div__")},get __rdiv__(){return p(this,function(a,b){var e=a.real*a.real;return z(b*a.real/e,b*a.imag/e)},"__rdiv__")},get __add__(){return p(this,function(a,b){return"number"===
+typeof b?z(a.real+b,a.imag):z(a.real+b.real,a.imag+b.imag)},"__add__")},get __radd__(){return p(this,function(a,b){return z(a.real+b,a.imag)},"__radd__")},get __sub__(){return p(this,function(a,b){return"number"===typeof b?z(a.real-b,a.imag):z(a.real-b.real,a.imag-b.imag)},"__sub__")},get __rsub__(){return p(this,function(a,b){return z(b-a.real,-a.imag)},"__rsub__")},get __repr__(){return p(this,function(a){return"({}{}{}j)".format(a.real,0<=a.imag?"+":"",a.imag)},"__repr__")},get __str__(){return p(this,
+function(a){return __repr__(a).__getslice__(1,-1,1)},"__str__")}}),l=x("__Terminal__",[S],{__module__:"org.transcrypt.__standard__",get __init__(){return p(this,function(a){a.buffer="";try{a.element=document.getElementById("__terminal__")}catch(Aa){a.element=null}a.element&&(a.element.style.overflowX="auto",a.element.style.boxSizing="border-box",a.element.style.padding="5px",a.element.innerHTML="_")},"__init__")},get print(){return p(this,function(a){var b=" ";var e="\n";if(arguments.length){var f=
+arguments.length-1;if(arguments[f]&&arguments[f].hasOwnProperty("__kwargtrans__")){var m=arguments[f--],n;for(n in m)switch(n){case "self":a=m[n];break;case "sep":b=m[n];break;case "end":e=m[n]}}var k=t([].slice.apply(arguments).slice(1,f+1))}else k=t();a.buffer="{}{}{}".format(a.buffer,b.join(function(){for(var a=[],b=$jscomp.makeIterator(k),e=b.next();!e.done;e=b.next())a.append(E(e.value));return a}()),e).__getslice__(-4096,null,1);a.element?(a.element.innerHTML=a.buffer.py_replace("\n","<br>").py_replace(" ",
+"&nbsp"),a.element.scrollTop=a.element.scrollHeight):console.log(b.join(function(){for(var a=[],b=$jscomp.makeIterator(k),e=b.next();!e.done;e=b.next())a.append(E(e.value));return a}()))},"print")},get input(){return p(this,function(a,b){if(arguments.length){var e=arguments.length-1;if(arguments[e]&&arguments[e].hasOwnProperty("__kwargtrans__")){e=arguments[e--];for(var f in e)switch(f){case "self":a=e[f];break;case "question":b=e[f]}}}a.print("{}".format(b),D({end:""}));f=window.prompt("\n".join(a.buffer.py_split("\n").__getslice__(-16,
+null,1)));a.print(f);return f},"input")}}),r=l();a.AssertionError=k;a.AttributeError=e;a.DeprecationWarning=C;a.Exception=b;a.IndexError=L;a.IterableError=g;a.KeyError=H;a.NotImplementedError=M;a.RuntimeWarning=G;a.StopIteration=c;a.py_TypeError=f;a.UserWarning=m;a.ValueError=d;a.Warning=n;a.__Terminal__=l;a.__name__="org.transcrypt.__standard__";a.__sort__=Y;a.__terminal__=r;a.complex=z;a.filter=function(a,b){null==a&&(a=O);var e=[];b=$jscomp.makeIterator(b);for(var f=b.next();!f.done;f=b.next())f=
+f.value,a(f)&&e.append(f);return e};a.map=function(a,b){var e=[];b=$jscomp.makeIterator(b);for(var f=b.next();!f.done;f=b.next())e.append(a(f.value));return e};a.sorted=function(a,b,e){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=null;if("undefined"==typeof e||null!=e&&e.hasOwnProperty("__kwargtrans__"))e=!1;if(arguments.length){var f=arguments.length-1;if(arguments[f]&&arguments[f].hasOwnProperty("__kwargtrans__"))for(m in f=arguments[f--],f)switch(m){case "iterable":a=
+f[m];break;case "key":b=f[m];break;case "reverse":e=f[m]}}var m=B(a)==I?y(a.py_keys()):y(a);Y(m,b,e);return m}}}});d.__call__=function(){var a=[].slice.apply(arguments);return"object"==typeof a[0]&&"__call__"in a[0]?a[0].__call__.apply(a[1],a.slice(2)):a[0].apply(a[1],a.slice(2))};F(d,"",K(d.org.transcrypt.__base__));N=d.__envir__;F(d,"",K(d.org.transcrypt.__standard__));var wa=d.Exception,xa=d.StopIteration,X=d.ValueError,ca=d.KeyError,ya=d.AssertionError,ja=d.py_TypeError,za=d.__sort__,T=d.complex;
+d.print=d.__terminal__.print;d.input=d.__terminal__.input;N.executor_name=N.transpiler_name;d.main={__file__:""};d.__except__=null;var D=function(a){a.__kwargtrans__=null;a.constructor=Object;return a};d.__kwargtrans__=D;d.__globals__=function(a){return W(a,I)?a:I(a)};d.__super__=function(a,b){a=$jscomp.makeIterator(a.__bases__);for(var g=a.next();!g.done;g=a.next())if(g=g.value,b in g)return g[b];throw new wa("Superclass method not found");};d.property=function(a,b){b||(b=function(){});return{get:function(){return a(this)},
+set:function(a){b(this,a)},enumerable:!0}};var w=function(a,b,g){a.hasOwnProperty(b)||Object.defineProperty(a,b,g)};d.__setProperty__=w;d.assert=function(a,b){if(!a)throw ya(b,Error());};d.__merge__=function(a,b){var g={},c;for(c in a)g[c]=a[c];for(c in b)g[c]=b[c];return g};d.dir=function(a){var b=[],c;for(c in a)b.push(c);b.sort();return b};d.setattr=function(a,b,c){a[b]=c};d.getattr=function(a,b){return a[b]};d.hasattr=function(a,b){try{return b in a}catch(g){return!1}};d.delattr=function(a,b){delete a[b]};
+var da=function(a,b){return B(b)==I?b.hasOwnProperty(a):b.indexOf?-1<b.indexOf(a):b.hasOwnProperty(a)};d.__in__=da;var R=function(a){return a.startswith("__")&&a.endswith("__")||"constructor"==a||a.startswith("py_")};d.__specialattrib__=R;var A=function(a){if(void 0===a||null===a)return 0;if(a.__len__ instanceof Function)return a.__len__();if(void 0!==a.length)return a.length;var b=0,c;for(c in a)R(c)||b++;return b};d.len=A;d.__t__=c;var O=function(a){return!!c(a)};O.__name__="bool";d.bool=O;var Z=
+function(a){if("inf"==a)return Infinity;if("-inf"==a)return-Infinity;if(isNaN(parseFloat(a))){if(!1===a)return 0;if(!0===a)return 1;throw X("could not convert string to float: '"+E(a)+"'",Error());}return+a};Z.__name__="float";d.float=Z;var P=function(a){return Z(a)|0};P.__name__="int";d.int=P;var B=function(a){var b=typeof a;if("object"==b)try{return a.__class__}catch(g){return b}else return"boolean"==b?O:"string"==b?E:"number"==b?0==a%1?P:Z:null};d.py_typeof=B;var W=function(a,b){function c(a){if(a==
+b)return!0;for(var k=0;k<a.__bases__.length;k++)if(c(a.__bases__[k],b))return!0;return!1}if(b instanceof Array){for(var h=$jscomp.makeIterator(b),d=h.next();!d.done;d=h.next())if(W(a,d.value))return!0;return!1}try{return"__class__"in a?c(a.__class__):a instanceof b}catch(H){return a=B(a),a==b||a==O&&b==P}};d.isinstance=W;d.callable=function(a){return"object"==typeof a&&"__call__"in a?!0:"function"===typeof a};var Q=function(a){try{return a.__repr__()}catch(H){try{return a.__str__()}catch(k){try{if(null==
+a)return"None";if(a.constructor==Object){var b="{",c=!1,h;for(h in a)if(!R(h)){var d=h.isnumeric()?h:"'"+h+"'";c?b+=", ":c=!0;b+=d+": "+Q(a[h])}return b+"}"}return"boolean"==typeof a?a.toString().capitalize():a.toString()}catch(M){return"<object of type: "+typeof a+">"}}}};d.repr=Q;d.chr=function(a){return String.fromCharCode(a)};d.ord=function(a){return a.charCodeAt(0)};d.max=Math.max;d.min=Math.min;d.round=function(a,b){if(b){var c=Math.pow(10,b);a*=c}var h=Math.round(a);.5==h-a&&h%2&&--h;b&&(h/=
+c);return h};l.prototype.__next__=function(){if(this.index<this.iterable.length)return this.iterable[this.index++];throw xa(Error());};q.prototype.next=function(){return this.index<this.iterable.py_keys.length?{value:this.index++,done:!1}:{value:void 0,done:!0}};d.py_reversed=function(a){a=a.slice();a.reverse();return a};var aa=function(){for(var a=[].slice.call(arguments),b=0;b<a.length;b++)"string"==typeof a[b]?a[b]=a[b].split(""):Array.isArray(a[b])||(a[b]=Array.from(a[b]));return(0==a.length?
+[]:a.reduce(function(a,b){return a.length<b.length?a:b})).map(function(b,c){return a.map(function(a){return a[c]})})};d.zip=aa;d.range=r;d.any=function(a){a=$jscomp.makeIterator(a);for(var b=a.next();!b.done;b=a.next())if(O(b.value))return!0;return!1};d.all=function(a){a=$jscomp.makeIterator(a);for(var b=a.next();!b.done;b=a.next())if(!O(b.value))return!1;return!0};d.sum=function(a){var b=0;a=$jscomp.makeIterator(a);for(var c=a.next();!c.done;c=a.next())b+=c.value;return b};d.enumerate=function(a){return aa(r(A(a)),
+a)};d.copy=y;d.deepcopy=v;d.list=u;Array.prototype.__class__=u;u.__name__="list";Array.prototype.__iter__=function(){return new l(this)};Array.prototype.__getslice__=function(a,b,c){0>a&&(a=this.length+a);null==b?b=this.length:0>b?b=this.length+b:b>this.length&&(b=this.length);for(var g=u([]);a<b;a+=c)g.push(this[a]);return g};Array.prototype.__setslice__=function(a,b,c,d){0>a&&(a=this.length+a);null==b?b=this.length:0>b&&(b=this.length+b);if(null==c)Array.prototype.splice.apply(this,[a,b-a].concat(d));
+else for(var g=0;a<b;a+=c)this[a]=d[g++]};Array.prototype.__repr__=function(){if(this.__class__==J&&!this.length)return"set()";for(var a=this.__class__&&this.__class__!=u?this.__class__==t?"(":"{":"[",b=0;b<this.length;b++)b&&(a+=", "),a+=Q(this[b]);this.__class__==t&&1==this.length&&(a+=",");return a+=this.__class__&&this.__class__!=u?this.__class__==t?")":"}":"]"};Array.prototype.__str__=Array.prototype.__repr__;Array.prototype.append=function(a){this.push(a)};Array.prototype.py_clear=function(){this.length=
+0};Array.prototype.extend=function(a){this.push.apply(this,a)};Array.prototype.insert=function(a,b){this.splice(a,0,b)};Array.prototype.remove=function(a){a=this.indexOf(a);if(-1==a)throw X("list.remove(x): x not in list",Error());this.splice(a,1)};Array.prototype.index=function(a){return this.indexOf(a)};Array.prototype.py_pop=function(a){return void 0==a?this.pop():this.splice(a,1)[0]};Array.prototype.py_sort=function(){za.apply(null,[this].concat([].slice.apply(arguments)))};Array.prototype.__add__=
+function(a){return u(this.concat(a))};Array.prototype.__mul__=function(a){for(var b=this,c=1;c<a;c++)b=b.concat(this);return b};Array.prototype.__rmul__=Array.prototype.__mul__;d.tuple=t;t.__name__="tuple";d.set=J;J.__name__="set";Array.prototype.__bindexOf__=function(a){a+="";for(var b=0,c=this.length-1;b<=c;){var d=(b+c)/2|0,V=this[d]+"";if(V<a)b=d+1;else if(V>a)c=d-1;else return d}return-1};Array.prototype.add=function(a){-1==this.indexOf(a)&&this.push(a)};Array.prototype.discard=function(a){a=
+this.indexOf(a);-1!=a&&this.splice(a,1)};Array.prototype.isdisjoint=function(a){this.sort();for(var b=0;b<a.length;b++)if(-1!=this.__bindexOf__(a[b]))return!1;return!0};Array.prototype.issuperset=function(a){this.sort();for(var b=0;b<a.length;b++)if(-1==this.__bindexOf__(a[b]))return!1;return!0};Array.prototype.issubset=function(a){return J(a.slice()).issuperset(this)};Array.prototype.union=function(a){for(var b=J(this.slice().sort()),c=0;c<a.length;c++)-1==b.__bindexOf__(a[c])&&b.push(a[c]);return b};
+Array.prototype.intersection=function(a){this.sort();for(var b=J(),c=0;c<a.length;c++)-1!=this.__bindexOf__(a[c])&&b.push(a[c]);return b};Array.prototype.difference=function(a){a=J(a.slice().sort());for(var b=J(),c=0;c<this.length;c++)-1==a.__bindexOf__(this[c])&&b.push(this[c]);return b};Array.prototype.symmetric_difference=function(a){return this.union(a).difference(this.intersection(a))};Array.prototype.py_update=function(){var a=[].concat.apply(this.slice(),arguments).sort();this.py_clear();for(var b=
+0;b<a.length;b++)a[b]!=a[b-1]&&this.push(a[b])};Array.prototype.__eq__=function(a){if(this.length!=a.length)return!1;this.__class__==J&&(this.sort(),a.sort());for(var b=0;b<this.length;b++)if(this[b]!=a[b])return!1;return!0};Array.prototype.__ne__=function(a){return!this.__eq__(a)};Array.prototype.__le__=function(a){return this.issubset(a)};Array.prototype.__ge__=function(a){return this.issuperset(a)};Array.prototype.__lt__=function(a){return this.issubset(a)&&!this.issuperset(a)};Array.prototype.__gt__=
+function(a){return this.issuperset(a)&&!this.issubset(a)};d.bytearray=ba;d.bytes=ba;Uint8Array.prototype.__add__=function(a){var b=new Uint8Array(this.length+a.length);b.set(this);b.set(a,this.length);return b};Uint8Array.prototype.__mul__=function(a){for(var b=new Uint8Array(a*this.length),c=0;c<a;c++)b.set(this,c*this.length);return b};Uint8Array.prototype.__rmul__=Uint8Array.prototype.__mul__;d.str=E;String.prototype.__class__=E;E.__name__="str";String.prototype.__iter__=function(){new l(this)};
+String.prototype.__repr__=function(){return(-1==this.indexOf("'")?"'"+this+"'":'"'+this+'"').py_replace("\t","\\t").py_replace("\n","\\n")};String.prototype.__str__=function(){return this};String.prototype.capitalize=function(){return this.charAt(0).toUpperCase()+this.slice(1)};String.prototype.endswith=function(a){return""==a||this.slice(-a.length)==a};String.prototype.find=function(a,b){return this.indexOf(a,b)};String.prototype.__getslice__=function(a,b,c){0>a&&(a=this.length+a);null==b?b=this.length:
+0>b&&(b=this.length+b);var d="";if(1==c)d=this.substring(a,b);else for(;a<b;a+=c)d=d.concat(this.charAt(a));return d};w(String.prototype,"format",{get:function(){return p(this,function(a){var b=t([].slice.apply(arguments).slice(1)),c=0;return a.replace(/\{(\w*)\}/g,function(a,d){""==d&&(d=c++);if(d==+d)return void 0==b[d]?a:E(b[d]);for(var g=0;g<b.length;g++)if("object"==typeof b[g]&&void 0!=b[g][d])return E(b[g][d]);return a})})},enumerable:!0});String.prototype.isalnum=function(){return/^[0-9a-zA-Z]{1,}$/.test(this)};
+String.prototype.isalpha=function(){return/^[a-zA-Z]{1,}$/.test(this)};String.prototype.isdecimal=function(){return/^[0-9]{1,}$/.test(this)};String.prototype.isdigit=function(){return this.isdecimal()};String.prototype.islower=function(){return/^[a-z]{1,}$/.test(this)};String.prototype.isupper=function(){return/^[A-Z]{1,}$/.test(this)};String.prototype.isspace=function(){return/^[\s]{1,}$/.test(this)};String.prototype.isnumeric=function(){return!isNaN(parseFloat(this))&&isFinite(this)};String.prototype.join=
+function(a){a=Array.from(a);return a.join(this)};String.prototype.lower=function(){return this.toLowerCase()};String.prototype.py_replace=function(a,b,c){return this.split(a,c).join(b)};String.prototype.lstrip=function(){return this.replace(/^\s*/g,"")};String.prototype.rfind=function(a,b){return this.lastIndexOf(a,b)};String.prototype.rsplit=function(a,b){if(void 0==a||null==a){a=/\s+/;var c=this.strip()}else c=this;if(void 0==b||-1==b)return c.split(a);c=c.split(a);return b<c.length?(b=c.length-
+b,[c.slice(0,b).join(a)].concat(c.slice(b))):c};String.prototype.rstrip=function(){return this.replace(/\s*$/g,"")};String.prototype.py_split=function(a,b){if(void 0==a||null==a){a=/\s+/;var c=this.strip()}else c=this;if(void 0==b||-1==b)return c.split(a);c=c.split(a);return b<c.length?c.slice(0,b).concat([c.slice(b).join(a)]):c};String.prototype.startswith=function(a){return 0==this.indexOf(a)};String.prototype.strip=function(){return this.trim()};String.prototype.upper=function(){return this.toUpperCase()};
+String.prototype.__mul__=function(a){for(var b=this,c=1;c<a;c++)b+=this;return b};String.prototype.__rmul__=String.prototype.__mul__;d.dict=I;I.__name__="dict";w(Function.prototype,"__setdoc__",{value:function(a){this.__doc__=a;return this},enumerable:!1});d.__neg__=function(a){return"object"==typeof a&&"__neg__"in a?a.__neg__():-a};d.__matmul__=function(a,b){return a.__matmul__(b)};d.pow=function(a,b){return"object"==typeof a&&"__pow__"in a?a.__pow__(b):"object"==typeof b&&"__rpow__"in b?b.__rpow__(a):
+Math.pow(a,b)};d.__jsmod__=function(a,b){return"object"==typeof a&&"__mod__"in a?a.__mod__(b):"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):a%b};var U=function(a,b){return"object"==typeof a&&"__mod__"in a?a.__mod__(b):"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):(a%b+b)%b};d.mod=U;var ea=function(a,b){return"object"==typeof a&&"__mul__"in a?a.__mul__(b):"object"==typeof b&&"__rmul__"in b?b.__rmul__(a):"string"==typeof a?a.__mul__(b):"string"==typeof b?b.__rmul__(a):a*b};d.__mul__=ea;var fa=
+function(a,b){return"object"==typeof a&&"__truediv__"in a?a.__truediv__(b):"object"==typeof b&&"__rtruediv__"in b?b.__rtruediv__(a):"object"==typeof a&&"__div__"in a?a.__div__(b):"object"==typeof b&&"__rdiv__"in b?b.__rdiv__(a):a/b};d.__truediv__=fa;d.__floordiv__=function(a,b){return"object"==typeof a&&"__floordiv__"in a?a.__floordiv__(b):"object"==typeof b&&"__rfloordiv__"in b?b.__rfloordiv__(a):"object"==typeof a&&"__div__"in a?a.__div__(b):"object"==typeof b&&"__rdiv__"in b?b.__rdiv__(a):Math.floor(a/
+b)};var ha=function(a,b){return"object"==typeof a&&"__add__"in a?a.__add__(b):"object"==typeof b&&"__radd__"in b?b.__radd__(a):a+b};d.__add__=ha;var ia=function(a,b){return"object"==typeof a&&"__sub__"in a?a.__sub__(b):"object"==typeof b&&"__rsub__"in b?b.__rsub__(a):a-b};d.__sub__=ia;d.__lshift__=function(a,b){return"object"==typeof a&&"__lshift__"in a?a.__lshift__(b):"object"==typeof b&&"__rlshift__"in b?b.__rlshift__(a):a<<b};d.__rshift__=function(a,b){return"object"==typeof a&&"__rshift__"in a?
+a.__rshift__(b):"object"==typeof b&&"__rrshift__"in b?b.__rrshift__(a):a>>b};d.__or__=function(a,b){return"object"==typeof a&&"__or__"in a?a.__or__(b):"object"==typeof b&&"__ror__"in b?b.__ror__(a):a|b};d.__xor__=function(a,b){return"object"==typeof a&&"__xor__"in a?a.__xor__(b):"object"==typeof b&&"__rxor__"in b?b.__rxor__(a):a^b};d.__and__=function(a,b){return"object"==typeof a&&"__and__"in a?a.__and__(b):"object"==typeof b&&"__rand__"in b?b.__rand__(a):a&b};d.__eq__=function(a,b){return"object"==
+typeof a&&"__eq__"in a?a.__eq__(b):a==b};d.__ne__=function(a,b){return"object"==typeof a&&"__ne__"in a?a.__ne__(b):a!=b};d.__lt__=function(a,b){return"object"==typeof a&&"__lt__"in a?a.__lt__(b):a<b};d.__le__=function(a,b){return"object"==typeof a&&"__le__"in a?a.__le__(b):a<=b};d.__gt__=function(a,b){return"object"==typeof a&&"__gt__"in a?a.__gt__(b):a>b};d.__ge__=function(a,b){return"object"==typeof a&&"__ge__"in a?a.__ge__(b):a>=b};d.__imatmul__=function(a,b){return"__imatmul__"in a?a.__imatmul__(b):
+a.__matmul__(b)};d.ipow=function(a,b){return"object"==typeof a&&"__pow__"in a?a.__ipow__(b):"object"==typeof a&&"__ipow__"in a?a.__pow__(b):"object"==typeof b&&"__rpow__"in b?b.__rpow__(a):Math.pow(a,b)};d.ijsmod__=function(a,b){return"object"==typeof a&&"__imod__"in a?a.__ismod__(b):"object"==typeof a&&"__mod__"in a?a.__mod__(b):"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):a%b};d.imod=function(a,b){return"object"==typeof a&&"__imod__"in a?a.__imod__(b):"object"==typeof a&&"__mod__"in a?a.__mod__(b):
+"object"==typeof b&&"__rpow__"in b?b.__rmod__(a):(a%b+b)%b};d.__imul__=function(a,b){return"object"==typeof a&&"__imul__"in a?a.__imul__(b):"object"==typeof a&&"__mul__"in a?a.__mul__(b):"object"==typeof b&&"__rmul__"in b?b.__rmul__(a):"string"==typeof a?a.__mul__(b):"string"==typeof b?b.__rmul__(a):a*b};d.__idiv__=function(a,b){return"object"==typeof a&&"__idiv__"in a?a.__idiv__(b):"object"==typeof a&&"__div__"in a?a.__div__(b):"object"==typeof b&&"__rdiv__"in b?b.__rdiv__(a):a/b};d.__iadd__=function(a,
+b){return"object"==typeof a&&"__iadd__"in a?a.__iadd__(b):"object"==typeof a&&"__add__"in a?a.__add__(b):"object"==typeof b&&"__radd__"in b?b.__radd__(a):a+b};d.__isub__=function(a,b){return"object"==typeof a&&"__isub__"in a?a.__isub__(b):"object"==typeof a&&"__sub__"in a?a.__sub__(b):"object"==typeof b&&"__rsub__"in b?b.__rsub__(a):a-b};d.__ilshift__=function(a,b){return"object"==typeof a&&"__ilshift__"in a?a.__ilshift__(b):"object"==typeof a&&"__lshift__"in a?a.__lshift__(b):"object"==typeof b&&
+"__rlshift__"in b?b.__rlshift__(a):a<<b};d.__irshift__=function(a,b){return"object"==typeof a&&"__irshift__"in a?a.__irshift__(b):"object"==typeof a&&"__rshift__"in a?a.__rshift__(b):"object"==typeof b&&"__rrshift__"in b?b.__rrshift__(a):a>>b};d.__ior__=function(a,b){return"object"==typeof a&&"__ior__"in a?a.__ior__(b):"object"==typeof a&&"__or__"in a?a.__or__(b):"object"==typeof b&&"__ror__"in b?b.__ror__(a):a|b};d.__ixor__=function(a,b){return"object"==typeof a&&"__ixor__"in a?a.__ixor__(b):"object"==
+typeof a&&"__xor__"in a?a.__xor__(b):"object"==typeof b&&"__rxor__"in b?b.__rxor__(a):a^b};d.__iand__=function(a,b){return"object"==typeof a&&"__iand__"in a?a.__iand__(b):"object"==typeof a&&"__and__"in a?a.__and__(b):"object"==typeof b&&"__rand__"in b?b.__rand__(a):a&b};d.__getitem__=function(a,b){return"object"==typeof a&&"__getitem__"in a?a.__getitem__(b):a[b]};d.__setitem__=function(a,b,c){"object"==typeof a&&"__setitem__"in a?a.__setitem__(b,c):a[b]=c};d.__getslice__=function(a,b,c,d){return"object"==
+typeof a&&"__getitem__"in a?a.__getitem__([b,c,d]):a.__getslice__(b,c,d)};d.__setslice__=function(a,b,c,d,V){"object"==typeof a&&"__setitem__"in a?a.__setitem__([b,c,d],V):a.__setslice__(b,c,d,V)};F(d,"itertools",{__all__:{__inited__:!1,__init__:function(a){var b=function(){function a(a,C){for(;;)switch(b){case 0:n=[].slice.apply(m),f=$jscomp.makeIterator(n),e=f.next();case 1:if(e.done){b=3;break}g=e.value;d=$jscomp.makeIterator(g);k=d.next();case 4:if(k.done){b=6;break}c=k.value;b=7;return{value:c,
+done:!1};case 7:if(void 0===C){b=8;break}b=-1;throw C;case 8:case 5:k=d.next();b=4;break;case 6:case 2:e=f.next();b=1;break;case 3:b=-1;default:return{value:void 0,done:!0}}}var b=0,c,k,d,g,e,f,n,m=arguments,C={next:function(b){return a(b,void 0)},throw:function(b){return a(void 0,b)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();C[Symbol.iterator]=function(){return this};return C};b.from_iterable=function(a){function b(b,m){for(;;)switch(c){case 0:n=$jscomp.makeIterator(a),
+f=n.next();case 1:if(f.done){c=3;break}e=f.value;g=$jscomp.makeIterator(e);d=g.next();case 4:if(d.done){c=6;break}k=d.value;c=7;return{value:k,done:!1};case 7:if(void 0===m){c=8;break}c=-1;throw m;case 8:case 5:d=g.next();c=4;break;case 6:case 2:f=n.next();c=1;break;case 3:c=-1;default:return{value:void 0,done:!0}}}var c=0,k,d,g,e,f,n,m={next:function(a){return b(a,void 0)},throw:function(a){return b(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();
+m[Symbol.iterator]=function(){return this};return m};var c=function(){var a=[].slice.apply(arguments);var b=a.length&&a[a.length-1].hasOwnProperty("__kwargtrans__")?a.pop().repeat:1;for(var c=[t([])],k=0;k<b;k++)for(var d=$jscomp.makeIterator(a),g=d.next();!g.done;g=d.next()){g=g.value;var e=[];c=$jscomp.makeIterator(c);for(var f=c.next();!f.done;f=c.next()){f=f.value;for(var n=$jscomp.makeIterator(g),m=n.next();!m.done;m=n.next())e.append(t(f.concat(m.value)))}c=e}return u(c)};a.count=function(a,
+b){function c(c,e){for(;;)switch(k){case 0:void 0==a&&(a=0),void 0==b&&(b=1);case 1:return k=3,{value:a,done:!1};case 3:if(void 0===e){k=4;break}k=-1;throw e;case 4:a+=b;k=1;break;case 2:k=-1;default:return{value:void 0,done:!0}}}var k=0,d={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();d[Symbol.iterator]=function(){return this};return d};a.cycle=function(a){function b(b,f){for(;;)switch(c){case 0:e=
+Array.from(a);case 1:g=$jscomp.makeIterator(e),d=g.next();case 3:if(d.done){c=5;break}k=d.value;c=6;return{value:k,done:!1};case 6:if(void 0===f){c=7;break}c=-1;throw f;case 7:case 4:d=g.next();c=3;break;case 5:c=1;break;case 2:c=-1;default:return{value:void 0,done:!0}}}var c=0,k,d,g,e,f={next:function(a){return b(a,void 0)},throw:function(a){return b(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();f[Symbol.iterator]=function(){return this};return f};
+a.repeat=function(a,b){function c(e,f){for(;;)switch(k){case 0:if("undefined"!=typeof b){k=1;break}case 3:return k=5,{value:a,done:!1};case 5:if(void 0===f){k=6;break}k=-1;throw f;case 6:k=3;break;case 4:k=2;break;case 1:d=0;case 7:if(!(d<b)){k=9;break}k=10;return{value:a,done:!1};case 10:if(void 0===f){k=11;break}k=-1;throw f;case 11:case 8:d++;k=7;break;case 9:case 2:k=-1;default:return{value:void 0,done:!0}}}var k=0,d,g={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,a)},
+return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();g[Symbol.iterator]=function(){return this};return g};a.accumulate=function(a,b){function c(c,G){for(;;)switch(k){case 0:m=!0;if(!b){k=1;break}n=$jscomp.makeIterator(a);g=n.next();case 3:if(g.done){k=5;break}f=g.value;m?(C=f,m=!1):C=b(C,f);k=6;return{value:C,done:!1};case 6:if(void 0===G){k=7;break}k=-1;throw G;case 7:case 4:g=n.next();k=3;break;case 5:k=2;break;case 1:e=$jscomp.makeIterator(a),g=e.next();case 8:if(g.done){k=
+10;break}d=g.value;m?(C=d,m=!1):C+=d;k=11;return{value:C,done:!1};case 11:if(void 0===G){k=12;break}k=-1;throw G;case 12:case 9:g=e.next();k=8;break;case 10:case 2:k=-1;default:return{value:void 0,done:!0}}}var k=0,d,g,e,f,n,m,C,G={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();G[Symbol.iterator]=function(){return this};return G};a.chain=b;a.compress=function(a,b){function c(m,c){for(;;)switch(k){case 0:$jscomp.initSymbol(),
+$jscomp.initSymbolIterator(),f=a[Symbol.iterator].call(a),$jscomp.initSymbol(),$jscomp.initSymbolIterator(),e=b[Symbol.iterator]();case 1:g=f.next();d=e.next();if(!g.done&&!d.done){k=3;break}k=2;break;case 3:if(!d.value){k=5;break}k=6;return{value:g.value,done:!1};case 6:if(void 0===c){k=7;break}k=-1;throw c;case 7:case 5:case 4:k=1;break;case 2:k=-1;default:return{value:void 0,done:!0}}}var k=0,d,g,e,f,n={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,a)},return:function(a){throw Error("Not yet implemented");
+}};$jscomp.initSymbolIterator();n[Symbol.iterator]=function(){return this};return n};a.dropwhile=function(a,b){function c(m,c){for(;;)switch(d){case 0:f=!1,e=$jscomp.makeIterator(b),h=e.next();case 1:if(h.done){d=3;break}g=h.value;if(!f){d=4;break}d=6;return{value:g,done:!1};case 6:if(void 0===c){d=7;break}d=-1;throw c;case 7:d=5;break;case 4:if(a(g)){d=8;break}f=!0;d=9;return{value:g,done:!1};case 9:if(void 0===c){d=10;break}d=-1;throw c;case 10:case 8:case 5:case 2:h=e.next();d=1;break;case 3:d=
+-1;default:return{value:void 0,done:!0}}}var d=0,g,h,e,f,n={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();n[Symbol.iterator]=function(){return this};return n};a.filterfalse=function(a,b){function c(f,m){for(;;)switch(d){case 0:e=$jscomp.makeIterator(b),h=e.next();case 1:if(h.done){d=3;break}g=h.value;if(a(g)){d=4;break}d=5;return{value:g,done:!1};case 5:if(void 0===m){d=6;break}d=-1;
+throw m;case 6:case 4:case 2:h=e.next();d=1;break;case 3:d=-1;default:return{value:void 0,done:!0}}}var d=0,g,h,e,f={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();f[Symbol.iterator]=function(){return this};return f};a.groupby=function(a,b){function c(){function a(a,d){for(;;)switch(m){case 0:case 1:return m=3,{value:f.value,done:!1};case 3:if(void 0===d){m=4;break}m=-1;throw d;case 4:f=
+n.next();if(!f.done){m=5;break}h=!1;m=-1;return{value:void 0,done:!0};case 5:c=b(f.value);if(c==e){m=6;break}e=c;m=-1;return{value:void 0,done:!0};case 6:m=1;break;case 2:m=-1;default:return{value:void 0,done:!0}}}var m=0,c,d={next:function(b){return a(b,void 0)},throw:function(b){return a(void 0,b)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();d[Symbol.iterator]=function(){return this};return d}function d(m,d){for(;;)switch(g){case 0:$jscomp.initSymbol();
+$jscomp.initSymbolIterator();n=a[Symbol.iterator]();f=n.next();if(!f.done){g=1;break}g=-1;return{value:void 0,done:!0};case 1:e=b(f.value),h=!0;case 2:if(!h){g=3;break}g=4;return{value:t([e,c()]),done:!1};case 4:if(void 0===d){g=5;break}g=-1;throw d;case 5:g=2;break;case 3:g=-1;default:return{value:void 0,done:!0}}}var g=0,h,e,f,n,m={next:function(a){return d(a,void 0)},throw:function(a){return d(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();m[Symbol.iterator]=
+function(){return this};return m};a.islice=function(){function a(a,k){for(;;)switch(b){case 0:e=[].slice.apply(C),$jscomp.initSymbol(),$jscomp.initSymbolIterator(),l=e[0][Symbol.iterator](),2==e.length?(n=e[1],m=0,f=1):(m=e[1],n=e[2],f=4==e.length?e[3]:1),g=0;case 1:if(!(g<m)){b=3;break}if(!l.next().done){b=4;break}b=-1;return{value:void 0,done:!0};case 4:case 2:g++;b=1;break;case 3:d=0;case 5:if(!(d<n-m)){b=7;break}c=l.next();if(!c.done){b=8;break}b=-1;return{value:void 0,done:!0};case 8:if(0!=d%
+f){b=9;break}b=10;return{value:c.value,done:!1};case 10:if(void 0===k){b=11;break}b=-1;throw k;case 11:case 9:case 6:d++;b=5;break;case 7:b=-1;default:return{value:void 0,done:!0}}}var b=0,c,d,g,l,e,f,n,m,C=arguments,G={next:function(b){return a(b,void 0)},throw:function(b){return a(void 0,b)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();G[Symbol.iterator]=function(){return this};return G};a.starmap=function(a,b){function c(e,c){for(;;)switch(d){case 0:$jscomp.initSymbol(),
+$jscomp.initSymbolIterator(),h=b[Symbol.iterator]();case 1:g=h.next();if(!g.done){d=3;break}d=-1;return{value:void 0,done:!0};case 3:return d=5,{value:a.apply(null,[].concat($jscomp.arrayFromIterable(g.value))),done:!1};case 5:if(void 0===c){d=6;break}d=-1;throw c;case 6:case 4:d=1;break;case 2:d=-1;default:return{value:void 0,done:!0}}}var d=0,g,h,e={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();
+e[Symbol.iterator]=function(){return this};return e};a.takewhile=function(a,b){function c(f,m){for(;;)switch(d){case 0:e=$jscomp.makeIterator(b),h=e.next();case 1:if(h.done){d=3;break}g=h.value;if(!a(g)){d=4;break}d=6;return{value:g,done:!1};case 6:if(void 0===m){d=7;break}d=-1;throw m;case 7:d=5;break;case 4:return d=-1,{value:void 0,done:!0};case 5:case 2:h=e.next();d=1;break;case 3:d=-1;default:return{value:void 0,done:!0}}}var d=0,g,h,e,f={next:function(a){return c(a,void 0)},throw:function(a){return c(void 0,
+a)},return:function(a){throw Error("Not yet implemented");}};$jscomp.initSymbolIterator();f[Symbol.iterator]=function(){return this};return f};a.tee=function(a,b){void 0==b&&(b=2);var c=[];a=u(a);for(var d=0;d<b;d++)$jscomp.initSymbol(),$jscomp.initSymbolIterator(),c.append(a[Symbol.iterator]());return u(c)};a.product=c;a.permutations=function(a,b){if(void 0==b)try{b=A(a)}catch(M){b=A(u(a))}var d=c(a,D({repeat:b}));a=[];d=$jscomp.makeIterator(d);for(var g=d.next();!g.done;g=d.next())g=g.value,A(J(g))==
+b&&a.append(g);return u(a)};a.combinations=function(a,b){function c(a,b,e){for(var f=0;f<A(a)-e;f++){var n=b.concat(a.slice(f,f+1));e?c(a.slice(f+1),n,e-1):d.append(t(n))}}a=u(a);var d=[];c(a,a.slice(0,0),b-1);return u(d)};a.combinations_with_replacement=function(a,b){function c(a,b,e){for(var f=0;f<A(a);f++){var n=b.concat(a.slice(f,f+1));e?c(a.slice(f),n,e-1):d.append(t(n))}}a=u(a);var d=[];c(a,a.slice(0,0),b-1);return u(d)}}}});F(d,"math",{__all__:{__inited__:!1,__init__:function(a){var b=Math.PI,
+c=Math.E,d=Math.exp,l=Math.pow,p=Math.sqrt,k=Math.sin,t=Math.cos,r=Math.tan,e=Math.asin,f=Math.acos,n=Math.atan,m=Math.atan2,C=Math.hypot,G=Math.sinh,Y=Math.cosh,z=Math.tanh,q=Math.asinh,u=Math.acosh,v=Math.atanh,x=Math.floor,w=Math.ceil,y=Math.trunc,A=isNaN;a.__name__="math";a.acos=f;a.acosh=u;a.asin=e;a.asinh=q;a.atan=n;a.atan2=m;a.atanh=v;a.ceil=w;a.cos=t;a.cosh=Y;a.degrees=function(a){return 180*a/Math.PI};a.e=c;a.exp=d;a.expm1=function(a){return Math.exp(a)-1};a.floor=x;a.hypot=C;a.inf=Infinity;
+a.isnan=A;a.log=function(a,b){return void 0===b?Math.log(a):Math.log(a)/Math.log(b)};a.log10=function(a){return Math.log(a)/Math.LN10};a.log1p=function(a){return Math.log(a+1)};a.log2=function(a){return Math.log(a)/Math.LN2};a.nan=NaN;a.pi=b;a.pow=l;a.radians=function(a){return a*Math.PI/180};a.sin=k;a.sinh=G;a.sqrt=p;a.tan=r;a.tanh=z;a.trunc=y}}});F(d,"numscrypt",{__all__:{__inited__:!1,__init__:function(a){F({},"",K(d.itertools));var b=I({int32:Int32Array,float32:Float32Array,float64:Float64Array}),
+c=function(a){return da(a,t(["complex64","complex128"]))},h=function(a){return"complex64"==a?"float32":"complex128"==a?"float64":a},l=function(a,f,n){return!a||c(f)?new (b[h(f)])(n):null},H=x("ndarray",[S],{__module__:"numscrypt",get __init__(){return p(this,function(a,b,n,m,d){if("undefined"==typeof m||null!=m&&m.hasOwnProperty("__kwargtrans__"))m=null;if("undefined"==typeof d||null!=d&&d.hasOwnProperty("__kwargtrans__"))d=null;a.dtype=n;a.ns_complex=c(n);a.realbuf=m;a.ns_complex&&(a.imagbuf=d);
+a.setshape(b)},"__init__")},get setshape(){return p(this,function(a,b){a.shape=b;a.ndim=b.length;a.ns_nrows=b[0];1==a.ndim?a.size=a.ns_nrows:(a.ns_ncols=b[1],a.size=a.ns_nrows*a.ns_ncols)},"setshape")},get astype(){return p(this,function(a,b){b=k(a.shape,b);b.realbuf.set(a.realbuf);a.ns_complex&&b.imagbuf.set(a.imagbuf);return b},"astype")},get tolist(){return p(this,function(a){var b=a.ns_complex?function(){for(var b=[],e=$jscomp.makeIterator(aa(u(a.realbuf),u(a.imagbuf))),f=e.next();!f.done;f=e.next()){var c=
+$jscomp.makeIterator(f.value);f=c.next().value;c=c.next().value;b.append(T(f,c))}return b}():a.realbuf;return 1==a.ndim?u(b):function(){for(var e=[],f=0;f<a.ns_nrows;f++)e.append(function(){for(var e=[],c=0;c<a.ns_ncols;c++)e.append(b[a.ns_ncols*f+c]);return e}());return e}()},"tolist")},get __repr__(){return p(this,function(a){return"array({})".format(Q(a.tolist()))},"__repr__")},get __str__(){return p(this,function(a){return 1==a.ndim?E(a.tolist()):"[\n\t{}\n]\n".format("\n\t".join(function(){for(var b=
+[],e=$jscomp.makeIterator(a.tolist()),c=e.next();!c.done;c=e.next())b.append(E(c.value));return b}()))},"__str__")},get reshape(){return p(this,function(a,b){if(1==a.ndim)return t([q(a,a.dtype)]);b=q(a,a.dtype);b.setshape(a.ns_ncols,a.ns_nrows);return b},"reshape")},get transpose(){return p(this,function(a){if(1==a.ndim)var b=q(a,dtype);else{b=k(t([a.ns_ncols,a.ns_nrows]),a.dtype);var e=0;if(a.ns_complex)for(var c=0;c<a.ns_ncols;c++)for(var d=0;d<a.ns_nrows;d++){var g=a.ns_ncols*d+c;b.imagbuf[e]=
+a.imagbuf[g];b.realbuf[e++]=a.realbuf[g]}else for(c=0;c<a.ns_ncols;c++)for(g=c,d=0;d<a.ns_nrows;d++)b.realbuf[e++]=a.realbuf[g],g+=a.ns_ncols}return b},"transpose")},get __getitem__(){return p(this,function(a,b){var e;if(1==a.ndim){if(B(b)==t){null==b[1]?b[1]=a.size:0>b[1]&&(b[1]+=a.size);var f=k(u([(b[1]-b[0])/b[2]]),a.dtype);b=0;if(a.ns_complex){var c=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(a.shape))));for(e=c.next();!e.done;e=c.next()){var d=e.value;f.realbuf[b]=a.realbuf[d];
+f.imagbuf[b++]=a.imagbuf[d]}}else for(c=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(a.shape)))),e=c.next();!e.done;e=c.next())d=e.value,f.realbuf[b++]=a.realbuf[d];return f}return a.ns_complex?T(a.realbuf[b],a.imagbuf[b]):a.realbuf[b]}e=b[0];c=b[1];f=B(e)==t;d=B(c)==t;f&&(null==e[1]?e[1]=a.ns_nrows:0>e[1]&&(e[1]+=a.ns_nrows));d&&(null==c[1]?c[1]=a.ns_ncols:0>c[1]&&(c[1]+=a.ns_ncols));if(f||d){if(f)if(d)if(f=k(t([(b[0][1]-b[0][0])/b[0][2],(b[1][1]-b[1][0])/b[1][2]]),a.dtype),
+b=0,a.ns_complex){var g=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(e))));for(e=g.next();!e.done;e=g.next()){e=e.value;var h=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(c))));for(d=h.next();!d.done;d=h.next())d=d.value,d=a.ns_ncols*e+d,f.realbuf[b]=a.realbuf[d],f.imagbuf[b++]=a.imagbuf[d]}}else for(g=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(e)))),e=g.next();!e.done;e=g.next())for(e=e.value,h=$jscomp.makeIterator(r.apply(null,
+[].concat($jscomp.arrayFromIterable(c)))),d=h.next();!d.done;d=h.next())d=d.value,f.realbuf[b++]=a.realbuf[a.ns_ncols*e+d];else if(f=k(t([(e[1]-e[0])/e[2]]),a.dtype),b=0,a.ns_complex)for(g=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(e)))),e=g.next();!e.done;e=g.next())e=e.value,d=a.ns_ncols*e+c,f.realbuf[b]=a.realbuf[d],f.imagbuf[b++]=a.imagbuf[d];else for(d=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(e)))),e=d.next();!e.done;e=d.next())e=e.value,
+f.realbuf[b++]=a.realbuf[a.ns_ncols*e+c];else if(f=k(t([(c[1]-c[0])/c[2]]),a.dtype),b=0,a.ns_complex)for(c=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(c)))),d=c.next();!d.done;d=c.next())d=d.value,d=a.ns_ncols*e+d,f.realbuf[b]=a.realbuf[d],f.imagbuf[b++]=a.imagbuf[d];else for(c=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(c)))),d=c.next();!d.done;d=c.next())d=d.value,f.realbuf[b++]=a.realbuf[a.ns_ncols*e+d];return f}return a.ns_complex?(d=a.ns_ncols*
+b[0]+b[1],T(a.realbuf[d],a.imagbuf[d])):a.realbuf[a.ns_ncols*b[0]+b[1]]},"__getitem__")},get __setitem__(){return p(this,function(a,b,c){var e;if(1==a.ndim){if(B(b)==t){null==b[1]?b[1]=a.size:0>b[1]&&(b[1]+=a.size);b=0;if(a.ns_complex){var f=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(a.shape))));for(e=f.next();!e.done;e=f.next()){var d=e.value;a.realbuf[d]=c.realbuf[b];a.imagbuf[d]=c.imagbuf[b++]}}else for(f=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(a.shape)))),
+e=f.next();!e.done;e=f.next())d=e.value,a.realbuf[d]=c.realbuf[b++];return result}a.ns_complex?(a.realbuf[b]=c.real,a.imagbuf[b]=c.imag):a.realbuf[b]=c}else{var n=b[0];f=b[1];var g=B(n)==t,k=B(f)==t;g&&(null==n[1]?n[1]=a.ns_nrows:0>n[1]&&(n[1]+=a.ns_nrows));k&&(null==f[1]?f[1]=a.ns_ncols:0>f[1]&&(f[1]+=a.ns_ncols));if(g||k)if(g)if(k)if(b=0,a.ns_complex)for(n=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(n)))),e=n.next();!e.done;e=n.next())for(e=e.value,g=$jscomp.makeIterator(r.apply(null,
+[].concat($jscomp.arrayFromIterable(f)))),d=g.next();!d.done;d=g.next())d=d.value,d=a.ns_ncols*e+d,a.realbuf[d]=c.realbuf[b],a.imagbuf[d]=c.imagbuf[b++];else for(n=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(n)))),g=n.next();!g.done;g=n.next())for(g=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(f)))),k=g.next();!k.done;k=g.next())a.realbuf[a.ns_ncols*e+d]=c.realbuf[b++];else if(b=0,a.ns_complex)for(n=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(n)))),
+e=n.next();!e.done;e=n.next())e=e.value,d=a.ns_ncols*e+f,a.realbuf[d]=c.realbuf[b],a.imagbuf[d]=c.imagbuf[b++];else for(e=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(n)))),g=e.next();!g.done;g=e.next())d=g.value,a.realbuf[a.ns_ncols*d+f]=c[b++];else if(b=0,a.ns_complex)for(f=$jscomp.makeIterator(r.apply(null,[].concat($jscomp.arrayFromIterable(f)))),d=f.next();!d.done;d=f.next())d=d.value,d=a.ns_ncols*n+d,a.realbuf[d]=c.realbuf[b],a.imagbuf[d]=c.imagbuf[b++];else for(c=$jscomp.makeIterator(r.apply(null,
+[].concat($jscomp.arrayFromIterable(f)))),d=c.next();!d.done;d=c.next())d=d.value,result.realbuf[a.ns_ncols*n+d]=a.realbuf[b++];else a.ns_complex?(d=a.ns_ncols*b[0]+b[1],a.realbuf[d]=c.real,a.imagbuf[d]=c.imag):a.realbuf[a.ns_ncols*b[0]+b[1]]=c}},"__setitem__")},get real(){return p(this,function(a){return H(a.shape,h(a.dtype),a.realbuf)},"real")},get imag(){return p(this,function(a){return H(a.shape,h(a.dtype),a.imagbuf)},"imag")},get __neg__(){return p(this,function(a){var b=k(a.shape,a.dtype);if(a.ns_complex)for(var e=
+0;e<a.size;e++)b.realbuf[e]=-a.realbuf[e],b.imagbuf[e]=-a.imagbuf[e];else for(e=0;e<a.size;e++)b.realbuf[e]=-a.realbuf[e];return b},"__neg__")},get __ns_inv__(){return p(this,function(a){var b=k(a.shape,a.dtype);if(a.ns_complex)for(var e=0;e<a.size;e++){var c=a.realbuf[e],d=a.imagbuf[e],g=c*c+d*d;b.realbuf[e]=c/g;b.imagbuf[e]=-d/g}else for(e=0;e<a.size;e++)b.realbuf[e]=1/a.realbuf[e];return b},"__ns_inv__")},get __add__(){return p(this,function(a,b){var e=k(a.shape,a.dtype);if(B(b)==H)if(a.ns_complex)for(var c=
+0;c<a.size;c++)e.realbuf[c]=a.realbuf[c]+b.realbuf[c],e.imagbuf[c]=a.imagbuf[c]+b.imagbuf[c];else for(c=0;c<a.size;c++)e.realbuf[c]=a.realbuf[c]+b.realbuf[c];else if(a.ns_complex)for(c=0;c<a.size;c++)e.realbuf[c]=a.realbuf[c]+b.real,e.imagbuf[c]=a.imagbuf[c]+b.imag;else for(c=0;c<a.size;c++)e.realbuf[c]=a.realbuf[c]+b;return e},"__add__")},get __radd__(){return p(this,function(a,b){return a.__add__(b)},"__radd__")},get __sub__(){return p(this,function(a,b){var c=k(a.shape,a.dtype);if(B(b)==H)if(a.ns_complex)for(var e=
+0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]-b.realbuf[e],c.imagbuf[e]=a.imagbuf[e]-b.imagbuf[e];else for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]-b.realbuf[e];else if(a.ns_complex)for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]-b.real,c.imagbuf[e]=a.imagbuf[e]-b.imag;else for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]-b;return c},"__sub__")},get __rsub__(){return p(this,function(a,b){return a.__neg__().__add__(b)},"__rsub__")},get __mul__(){return p(this,function(a,b){var c=k(a.shape,a.dtype);if(B(b)==
+H)if(a.ns_complex)for(var e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]*b.realbuf[e]-a.imagbuf[e]*b.imagbuf[e],c.imagbuf[e]=a.realbuf[e]*b.imagbuf[e]+a.imagbuf[e]*b.realbuf[e];else for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]*b.realbuf[e];else if(a.ns_complex)for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]*b.real-a.imagbuf[e]*b.imag,c.imagbuf[e]=a.realbuf[e]*b.imag+a.imagbuf[e]*b.real;else for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]*b;return c},"__mul__")},get __rmul__(){return p(this,function(a,
+b){return a.__mul__(b)},"__rmul__")},get __div__(){return p(this,function(a,b){var c=k(a.shape,a.dtype);if(B(b)==H)if(a.ns_complex)for(var e=0;e<a.size;e++){var f=b.realbuf[e];var d=b.imagbuf[e];var g=f*f+d*d;c.realbuf[e]=(a.realbuf[e]*f+a.imagbuf[e]*d)/g;c.imagbuf[e]=(a.imagbuf[e]*f-a.realbuf[e]*d)/g}else for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]/b.realbuf[e];else if(a.ns_complex)for(f=b.real,d=b.imag,g=f*f+d*d,e=0;e<a.size;e++)c.realbuf[e]=(a.realbuf[e]*f+a.imagbuf[e]*d)/g,c.imagbuf[e]=(a.imagbuf[e]*
+f-a.realbuf[e]*d)/g;else for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e]/b;return c},"__div__")},get __rdiv__(){return p(this,function(a,b){return a.__ns_inv__().__mul__(b)},"__rdiv__")},get __matmul__(){return p(this,function(a,b){var c,e=k(t([a.ns_nrows,b.ns_ncols]),a.dtype);if(a.ns_complex)for(var d=c=0;d<a.ns_nrows;d++)for(var f=0;f<b.ns_ncols;f++){e.realbuf[c]=0;e.imagbuf[c]=0;var g=a.ns_ncols*d;var h=f;for(var l=0;l<a.ns_ncols;l++)e.realbuf[c]+=a.realbuf[g]*b.realbuf[h]-a.imagbuf[g]*b.imagbuf[h],
+e.imagbuf[c]+=a.realbuf[g]*b.imagbuf[h]+a.imagbuf[g++]*b.realbuf[h],h+=b.ns_ncols;c++}else for(d=c=0;d<a.ns_nrows;d++)for(f=0;f<b.ns_ncols;f++){e.realbuf[c]=0;g=a.ns_ncols*d;h=f;for(l=0;l<a.ns_ncols;l++)e.realbuf[c]+=a.realbuf[g++]*b.realbuf[h],h+=b.ns_ncols;c++}return e},"__matmul__")}}),k=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";a=H(a,b);a.realbuf=l(!1,b,a.size);a.imagbuf=l(!0,b,a.size);return a},q=function(a,b){if("undefined"==typeof b||null!=
+b&&b.hasOwnProperty("__kwargtrans__"))b="float64";if(Array.isArray(a))if(A(a))if(Array.isArray(a[0])){b=k(t([a.length,a[0].length]),b);var c=0;if(b.ns_complex)for(var e=0;e<b.ns_nrows;e++)for(var d=0;d<b.ns_ncols;d++){var f=T(a[e][d]);b.realbuf[c]=f.real;b.imagbuf[c++]=f.imag}else for(e=0;e<b.ns_nrows;e++)for(d=0;d<b.ns_ncols;d++)b.realbuf[c++]=a[e][d]}else if(b=k(t([a.length]),b),b.ns_complex)for(c=0;c<b.size;c++)f=T(a[c]),b.realbuf[c]=f.real,b.imagbuf[c]=f.imag;else for(c=0;c<b.size;c++)b.realbuf[c]=
+a[c];else b=k(t([0]),b);else b=k(a.shape,b),b.realbuf.set(a.realbuf),a.ns_complex&&b.imagbuf.set(a.imagbuf);return b},L=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";a=k(a,b);if(a.ns_complex)for(b=0;b<a.size;b++)a.realbuf[b]=0,a.imagbuf[b]=0;else for(b=0;b<a.size;b++)a.realbuf[b]=0;return a};a.__name__="numscrypt";a.array=q;a.copy=function(a){return q(a,a.dtype)};a.empty=k;a.hsplit=function(a,b){for(var c,e,d=[],f=0;f<b;f++)d.append(k(t([a.ns_nrows,
+a.ns_ncols/b]),a.dtype));b=0;if(a.ns_complex)for(f=0;f<a.ns_nrows;f++){var g=$jscomp.makeIterator(d);for(c=g.next();!c.done;c=g.next()){e=c.value;c=e.ns_ncols*f;for(var h=0;h<e.ns_ncols;h++)e.realbuf[c]=a.realbuf[b],e.imagbuf[c++]=a.imagbuf[b++]}}else for(f=0;f<a.ns_nrows;f++)for(g=$jscomp.makeIterator(d),c=g.next();!c.done;c=g.next())for(e=c.value,c=e.ns_ncols*f,h=0;h<e.ns_ncols;h++)e.realbuf[c++]=a.realbuf[b++];return d};a.hstack=function(a){var b,c=0,e=$jscomp.makeIterator(a);for(b=e.next();!b.done;b=
+e.next())b=b.value,c+=b.ns_ncols;c=k(t([a[0].ns_nrows,c]),a[0].dtype);e=0;if(c.ns_complex)for(var d=0;d<c.ns_nrows;d++){var g=$jscomp.makeIterator(a);for(b=g.next();!b.done;b=g.next()){b=b.value;var h=b.ns_ncols*d;for(var l=0;l<b.ns_ncols;l++)c.realbuf[e]=b.realbuf[h],c.imagbuf[e++]=b.imagbuf[h++]}}else for(d=0;d<c.ns_nrows;d++)for(g=$jscomp.makeIterator(a),b=g.next();!b.done;b=g.next())for(b=b.value,h=b.ns_ncols*d,l=0;l<b.ns_ncols;l++)c.realbuf[e++]=b.realbuf[h++];return c};a.identity=function(a,
+b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";b=L(t([a,a]),b);for(var c=0,e=a+1,d=0;d<a;d++)b.realbuf[c]=1,c+=e;return b};a.ndarray=H;a.ns_buffertype=h;a.ns_complex=c;a.ns_complextype=function(a){return"float32"==a?"complex64":"float64"==a?"complex128":null};a.ns_createbuf=l;a.ns_ctors=b;a.ones=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b="float64";a=k(a,b);if(a.ns_complex)for(b=0;b<a.size;b++)a.realbuf[b]=1,a.imagbuf[b]=
+0;else for(b=0;b<a.size;b++)a.realbuf[b]=1;return a};a.round=function(a,b){if("undefined"==typeof b||null!=b&&b.hasOwnProperty("__kwargtrans__"))b=0;var c=k(a.shape,a.dtype);if(a.ns_complex)for(var e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e].toFixed(b),c.imagbuf[e]=a.imagbuf[e].toFixed(b);else for(e=0;e<a.size;e++)c.realbuf[e]=a.realbuf[e].toFixed(b);return c};a.vsplit=function(a,b){var c,e=[];for(c=0;c<b;c++)e.append(k(t([a.ns_nrows/b,a.ns_ncols]),q.dtype));b=0;if(a.ns_complex){var d=$jscomp.makeIterator(e);
+for(c=d.next();!c.done;c=d.next()){c=c.value;for(var f=0;f<c.size;f++)c.realbuf[f]=a.realbuf[b],c.imagbuf[f]=a.imagbuf[b++]}}else for(d=$jscomp.makeIterator(e),c=d.next();!c.done;c=d.next())for(c=c.value,f=0;f<c.size;f++)c.realbuf[f]=a.realbuf[b++];return e};a.vstack=function(a){var b,c=0,e=$jscomp.makeIterator(a);for(b=e.next();!b.done;b=e.next())b=b.value,c+=b.ns_nrows;c=k(t([c,a[0].ns_ncols]),a[0].dtype);e=0;if(c.ns_complex)for(a=$jscomp.makeIterator(a),b=a.next();!b.done;b=a.next()){b=b.value;
+for(var d=0;d<b.size;d++)c.realbuf[e]=b.realbuf[d],c.imagbuf[e++]=b.imagbuf[d]}else for(a=$jscomp.makeIterator(a),b=a.next();!b.done;b=a.next())for(b=b.value,d=0;d<b.size;d++)c.realbuf[e++]=b.realbuf[d];return c};a.zeros=L}}});F(d,"numscrypt.linalg",{__all__:{__inited__:!1,__init__:function(a){var b=K(d.numscrypt),c=function(a){a=b.hstack(t([a,b.identity(a.shape[0],a.dtype)]));var c=a.realbuf,d=a.shape,g=d[0];d=d[1];for(var h=0;h<g;h++){if(!c[h*d+h])for(var e=h+1;e<g;e++)if(c[e*d+h]){for(var f=0;f<
+d;f++){var l=c[e*d+f];c[e*d+f]=a[h*d+f];c[h*d+f]=l}break}e=c[h*d+h];for(f=h;f<d;f++)c[h*d+f]/=e;for(e=0;e<g;e++)if(e!=h)for(l=c[e*d+h],f=0;f<d;f++)c[e*d+f]-=l*c[h*d+f]}return b.hsplit(a,2)[1]},h=function(a){a=b.hstack(t([a,b.identity(a.shape[0],a.dtype)]));var c=a.realbuf,d=a.imagbuf,g=a.shape,h=g[0];g=g[1];for(var e=0;e<h;e++){var f=e*g+e;if(!c[f]&&!d[f])for(var l=e+1;l<h;l++){var m=l*g+e;if(c[m]||d[m]){for(m=0;m<g;m++){var p=l*g+m;var q=e*g+m;var r=c[p];c[p]=c[q];c[q]=r;r=d[isource_flat];d[p]=d[q];
+d[q]=r}break}}l=c[f];q=d[f];r=l*l+q*q;for(m=e;m<g;m++){var u=e*g+m;f=c[u];p=d[u];c[u]=(f*l+p*q)/r;d[u]=(p*l-f*q)/r}for(l=0;l<h;l++)if(l!=e)for(m=l*g+e,r=c[m],u=d[m],m=0;m<g;m++)q=l*g+m,p=e*g+m,f=c[p],p=d[p],c[q]-=r*f-u*p,d[q]-=r*p+u*f}return b.hsplit(a,2)[1]};a.__name__="numscrypt.linalg";a.cinv=h;a.inv=function(a){return a.ns_complex?h(a):c(a)};a.rinv=c}}});F(d,"numscrypt.random",{__all__:{__inited__:!1,__init__:function(a){var b=K(d.numscrypt);a.__name__="numscrypt.random";a.rand=function(){var a=
+t([].slice.apply(arguments).slice(0));a=b.empty(a,"float64");for(var c=0;c<a.size;c++)a.realbuf[c]=Math.random();return a}}}});F(d,"random",{__all__:{__inited__:!1,__init__:function(a){var b={};F(b,"",K(d.math));var c=function(){for(var a=[],b=0;624>b;b++)a.append(0);return a}(),h=0,l=Math.pow(2,32)-1,p=Math.pow(2,31),k=Math.pow(2,31)-1,q=function(){for(var a=0;624>a;a++){var b=(c[a]&p)+(c[U(a+1,624)]&k);c[a]=c[U(a+397,624)]^b>>1;0!=U(b,2)&&(c[a]^=2567483615)}},r=function(){0==h&&q();var a=c[h];a^=
+a>>11;a^=a<<7&2636928640;a^=a<<15&4022730752;a^=a>>18;h=U(h+1,624);return a},e=function(a){if("undefined"==typeof a||null!=a&&a.hasOwnProperty("__kwargtrans__"))a=P(k*Math.random());c[0]=a;for(a=1;624>a;a++)c[a]=(1812433253*c[a-1]^(c[a-1]>>30)+a)&l},f=function(a,b){return a+U(r(),b-a+1)},n=function(){return r()/k};e();a.__name__="random";a._array=c;a._bitmask1=l;a._bitmask2=p;a._bitmask3=k;a._fill_array=q;a._index=h;a._random_integer=r;a.choice=function(a){return a[f(0,A(a)-1)]};a.randint=f;a.random=
+n;a.seed=e;a.shuffle=function(a){for(var c=A(a)-1;0<c;c--){var d=b.floor(n()*(c+1)),e=a[c];a[c]=a[d];a[d]=e}}}}});(function(){var a={},b=K(d.numscrypt),c=K(d.numscrypt.random),h=K(d.numscrypt.linalg);F(a,"",K(d.random));for(var l="",p=$jscomp.makeIterator(t([!1,!0])),k=p.next();!k.done;k=p.next()){var q=k.value;k=$jscomp.makeIterator(t([!1,!0]));for(var r=k.next();!r.done;r=k.next()){var e=r.value;var f=q?b.array(function(){for(var b=[],c=0;30>c;c++)b.append(function(){for(var b=[],c=0;30>c;c++)b.append(T(a.random(),
+a.random()));return b}());return b}(),"complex128"):c.rand(30,30);var n=new Date;e&&(f=f.transpose());var m=new Date;var u=h.inv(f);var v=new Date;var x=f.__matmul__(u);var z=new Date;var w=ea(f,f);var y=new Date;w=fa(f,f);var A=new Date;w=ha(f,f);var B=new Date;w=ia(f,f);var D=new Date;l+="\n<pre>\na @ ai [0:5, 0:5] =\n\n{}\n".format(E(b.round(x.__getitem__([t([0,5,1]),t([0,5,1])]),2)).py_replace(" ","\t"));e&&(l+="\nTranspose took: {} ms".format(m-n));l+="\nInverse took: {} ms\nMatrix product (@) took: {} ms\nElementwise product (*) took: {} ms\nDivision took: {} ms\nAddition took: {} ms\nSubtraction took: {} ms\n</pre>\n".format(v-
+m,z-v,y-z,A-y,B-A,D-B)}}document.getElementById("result").innerHTML=l;d.__name__="__main__";d.a=f;d.ai=u;d.id=x;d.result=l;d.sp=w;d.timeEnd=D;d.timeStartAdd=A;d.timeStartDiv=y;d.timeStartInv=m;d.timeStartMul=v;d.timeStartScalp=z;d.timeStartSub=B;d.timeStartTranspose=n;d.transpose=e;d.useComplex=q})();return d}window.test=test();
diff --git a/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.mod.js b/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.mod.js
new file mode 100644
index 0000000..f3b8296
--- /dev/null
+++ b/numscrypt/development/manual_tests/slicing_optimization/__javascript__/test.mod.js
@@ -0,0 +1,78 @@
+	(function () {
+		var random = {};
+		var __name__ = '__main__';
+		var num =  __init__ (__world__.numscrypt);
+		var num_rand =  __init__ (__world__.numscrypt.random);
+		var linalg =  __init__ (__world__.numscrypt.linalg);
+		__nest__ (random, '', __init__ (__world__.random));
+		var result = '';
+		for (var useComplex of tuple ([false, true])) {
+			for (var transpose of tuple ([false, true])) {
+				if (useComplex) {
+					var a = num.array ((function () {
+						var __accu0__ = [];
+						for (var iRow = 0; iRow < 30; iRow++) {
+							__accu0__.append ((function () {
+								var __accu1__ = [];
+								for (var iCol = 0; iCol < 30; iCol++) {
+									__accu1__.append (complex (random.random (), random.random ()));
+								}
+								return __accu1__;
+							}) ());
+						}
+						return __accu0__;
+					}) (), 'complex128');
+				}
+				else {
+					var a = num_rand.rand (30, 30);
+				}
+				var timeStartTranspose = new Date ();
+				if (transpose) {
+					var a = a.transpose ();
+				}
+				var timeStartInv = new Date ();
+				var ai = linalg.inv (a);
+				var timeStartMul = new Date ();
+				var id = __matmul__ (a, ai);
+				var timeStartScalp = new Date ();
+				var sp = __mul__ (a, a);
+				var timeStartDiv = new Date ();
+				var sp = __truediv__ (a, a);
+				var timeStartAdd = new Date ();
+				var sp = __add__ (a, a);
+				var timeStartSub = new Date ();
+				var sp = __sub__ (a, a);
+				var timeEnd = new Date ();
+				result += '\n<pre>\na @ ai [0:5, 0:5] =\n\n{}\n'.format (str (num.round (id.__getitem__ ([tuple ([0, 5, 1]), tuple ([0, 5, 1])]), 2)).py_replace (' ', '\t'));
+				if (transpose) {
+					result += '\nTranspose took: {} ms'.format (timeStartInv - timeStartTranspose);
+				}
+				result += '\nInverse took: {} ms\nMatrix product (@) took: {} ms\nElementwise product (*) took: {} ms\nDivision took: {} ms\nAddition took: {} ms\nSubtraction took: {} ms\n</pre>\n'.format (timeStartMul - timeStartInv, timeStartScalp - timeStartMul, timeStartDiv - timeStartScalp, timeStartAdd - timeStartDiv, timeStartSub - timeStartAdd, timeEnd - timeStartSub);
+			}
+		}
+		document.getElementById ('result').innerHTML = result;
+		__pragma__ ('<use>' +
+			'numscrypt' +
+			'numscrypt.linalg' +
+			'numscrypt.random' +
+			'random' +
+		'</use>')
+		__pragma__ ('<all>')
+			__all__.__name__ = __name__;
+			__all__.a = a;
+			__all__.ai = ai;
+			__all__.id = id;
+			__all__.result = result;
+			__all__.sp = sp;
+			__all__.timeEnd = timeEnd;
+			__all__.timeStartAdd = timeStartAdd;
+			__all__.timeStartDiv = timeStartDiv;
+			__all__.timeStartInv = timeStartInv;
+			__all__.timeStartMul = timeStartMul;
+			__all__.timeStartScalp = timeStartScalp;
+			__all__.timeStartSub = timeStartSub;
+			__all__.timeStartTranspose = timeStartTranspose;
+			__all__.transpose = transpose;
+			__all__.useComplex = useComplex;
+		__pragma__ ('</all>')
+	}) ();
diff --git a/numscrypt/docs/sphinx/_build/doctrees/environment.pickle b/numscrypt/docs/sphinx/_build/doctrees/environment.pickle
index e616f02d56c86991c066457115cd8106f6bc37de..c3321a174c0c8b61b2d741fbbb295f14e7cc57bd 100644
GIT binary patch
literal 10108
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

literal 10298
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

diff --git a/numscrypt/docs/sphinx/_build/doctrees/index.doctree b/numscrypt/docs/sphinx/_build/doctrees/index.doctree
index 532a58f5ef36b717cfb62cb960a56e3235058c90..6c466bd8c6c4705d0081e5ff67a24fc654e2c62e 100644
GIT binary patch
literal 2927
zcma)8U2hvj6iu2q&X=7JC=YF;8q`84a?;Y4LLLxOd5dZxgy1D*8SjogqwMZ1^AXz*
zNbo?_O7q6@H~3rp4bGkQ+Odlekv6txXXf5}?z!jQU)TRkc2>flZzn2tR;K18R|z+z
z-=u|%=eGQ#{P?%>m-5)}#!hRjM5)Yq+4Jp!X~Uz88^eY;^Ae{tFO;@i<MmB5$@(gd
z21?mnSsoe7v@Oq9{C2`)rJ0o~$G)vt+VDNxu%+3^D5qmy`jyh}%RG^q$2P*@A-A+g
ztco?iq4_{229Ehnnbdc$`a|RT#!8D|R37CF-qD^`Z6w0Eu(DR2KK2Ke^;6zegKn&H
zi}*|_R(#XIC^=Y%PgX@swEYIcCS1gw3YYqYxC^(onYCK>oegG>0i!D_CkUNBi!XzH
z{0R2(d2htiSY^CxRX2B;iS?wgUDK`cuV7-nF}vpe^hC$1&g{fTrn7M3{gU}+oHAoV
zW}M%sQT_7kvkQjUt|F_9xEOL~d3-Uu=-M}2Xf8}4WInz?9{Bh~8(aGIkpJ@=elr#_
zO#lXxatzEGz&+(li23_JQ~{E^y*j|R-35Fd@d0=y?jgk=;yK3i37(Uer4tXuBk?J0
zHZ2<x5~X-59^>VTU;mDeiKYM7(C=lSGweM>KEH5%=KA7@i?76Oe0j@*Ta29Whk+#>
zHR#kVIV;(9*Ba!`vH0vdDg5Dg#4S4Ye9En}5{8f7HnS9H1MXA-KL6KC=0SXeAik}F
zSV2ZqRw$PzOGyyz|Fr7&tctDXygSmYC{Vs^ig=Hr@_Q8tPFRvm<)Jw}Ft>x!fQ_F*
zWPU@)Bmpnpghbx;jX<B$@5($*U4qh011(V?Bf)Gm5|dEtkcc!5jE|gw0=#Qn5d<ZP
z0K2i;#VAisxcl{Cs`}*{za3a-RGv=otBKOovbww{+^e!DuIS(B6^?;felug^gcnwn
z#9+|A&oxiV7k{t$*3`S&c@z*UDwV3qSQD{{{9F<?KptOzbp4t@4@AddW!1N9xttbW
z&u<!Tt;~mz*8?inptl1Zn30rz<9n7mcwQ@x-{<2(L186iN#`szP|H2#Y~gIg^H?Rg
ztMm<L2i?z0e;e?~BH}40**4KgS`pO>(DU1ZrI2oZ#nbY<;oEu;lNKWQJcdzhsQiqa
zPJ!3cp5HYY1UvfKLA(v1Z6v(!hS=FAOOWI%X{1%8_3gxE#e$!Qq@U2@kep~dP&&gE
zt(4_Mhi-v%Cdls%aKyJ|z8KL~h^T8Mq6@YPY|lbeWQ#egB4~a=EntjGB*1Hrn9hL*
zI)Uaa!@ipZFCrouMHE?{6<`)@ZeqQA|KSrH+9eSB3=mV${*JJ=FlVQyRw;Bs$?f1o
z>EWrcS$c{d5`vuNu;=&9B)4oF2{{xgo}i72a&j|H6}yah#$+0yYBYKzFnkS*p+VMp
zxZw|H?U9-Tl=ae-=d1qCA|?^nTIoozJV{ZV5c7}$xLm!c*|5BCpDs1%0s?kZMoo2>
zV426<sbe0EMkmF@3YCYL6Ml7yohHPsVwn%rG>h=AMaf0!%vW|JOby`ntf@mT!N7#d
zY}4<cse`ekg$YI1jHWdq9{Kk|iezrM4lTRh_S)}E2}z((-WNj!@#Esj<7WT^(l7v5
zu!Uk<AoV^+ebaa_f#3+vEl9XE<T=Oq5tw@fAhY?5GCLfZg5Y}NkCqB<31ab=-wV7b
z40j1I%1}N2fRCl6p~N~<=ehydLWRz2axY4xAyi1+st{TbR-~t<f^U$XK^$p7Tdbum
ztKlJS1+U)0jHGmeEEF7_I*&;Lp%%e4Y|IT+AT6!&{0bkfsmV|w)#NoVDNH$g7`7}L
zD^(tlu&}X}pnecjR+K&0hc++Gcfc-ObU+0<qxEccVK74r2vgYM!d_fX6C$R#naj)L
z<zPP2T|XM;LYfCU7<*{Tbh;B=@j$!~x18UqJqlZ?&Cf<6j21L=ps8G+JDlH{c@YL$
gl>5R!TcJkA?4$tPG`n<r;ziH-R&A^vH(mea9}3EZWB>pF

literal 2927
zcma)8%WfP+6m@LR!;WYCAYnry8HtFn7#oQokQZ!VXECb?HjY{~-8ECCbXPU?@XSat
z0znc-DhUC_l1;Kjd;nt44*<WwZ*Z!5y6rKEgr&CI)wk~R+;i_&>px}JSK^QBXEL>h
z=lVd%jB4+?;h><x_#gc{U;8tE*WJ+bVkGlqETs|B&_vO(_7A+<P-Lp5RVnpu#k=0J
zz!?MtDX5v3P#hHP88XW0z8vqTQW)6KM}Fw;Olh9Vg6<o+FKnSxH80KEdcSsr7%s(|
zerVkuu|_sVv?0p)<7;j!wMs!-l5;_!uwN3TX;M(F$poh1>1IY#siGzbY}7j9w;e7r
zu4rl!D4b9e4|^#$QM?KkvGi*zi-?D=tEn+uOpvwRCXHhiL(9Bte@1c(^GzN%j3Ox=
zk@TTIcW-E;c$v_ghGgqx$_-1>oM??JaB)Hfg~L*XfGSxeDaztxuZ|!I>Jaxs9W$W|
z<RtmRqDtC7b2m#`CS#t{#Hu_ov?z08P^>P_2Y24R2QRmijO$RA1T`7+Nl>nl3~fh-
z8ywHZQWem(o!O#H5Q5O*Bsh7CDkW7yMJhAoA*udlL}WQt-t7e6G(uvE!f-&z2G5cb
z@ZmGhx~{i~tBHDBT2ornX!NdS&3N!3bkSl&vqYPDPBo*{z@yv9V6lWs3K*m`(Pc39
z%-!PRvbL-KwS)Q8c((=rB=VNiQ=0qZRo7p>2*0Bn1C9K+PEuq3qfd@bNNV_LVx(p#
z6N==fCk=)#y#XHjM3;<<*$LoAX9r5d@MfhcR0rw2j&?%mp%_`H<~G1+=**xp1tKy)
z&1=A^R9TYIl0uD0c|=Rk$n+8tTnms=^AOlLoTC|n1$T=XQ|hC`Ln9?Ro>MbEkZN+s
zOpzY~;XxY3sj?UfeEUj0u4ItCk6r`9mhSWxK#I7Fy|hbb+@N&CSY7A1<@!^iL_iIy
zKuG~>TS3=_xBIoX)9Lh}oEs)Z^fsfXhmh3pxRue74Ui2qwhY%+{5O1B1}QG3<-PYl
zKut503tkl^q$+fmn%Ybzvm%ybQJm0Ska#`z5f_@OKuArY&fNxR4gH%L=8wB>laaiE
zQp@#nA|@6*gtTPnfK@8Ml%d0blSOl();oGG44Ea2Pgsrz;8@S40Ni5pgPcye<`o@m
zq5K-eQ`6baG?(OILJPw4gk+fl@c|a+uHCfs8WpD@7lA;Niym~V92C%xoz20>N{~F%
zeTU9U3DjIZ>qV)C@`kR5oO3Zox*|gyU$Z0EyUfs4@h_h=lcNhC8vfoS28}qffwRJx
zXoaZ}FLwij)YGP$*|Pbv#<M8VUi2b6a-EtzA9(A!RZD}0hOQHC1$iiEJ+~XD&_Ip{
z^%U}~@7`KWp@ETurh^B15QsgnZk257I)+SwKF?y&mIh<=D0&twov{_y355n)njyeC
z;Jr2m6jXY)<}Una*Vr1%!^P<X&jg-6VI}@3JO<AhL0Bo{ISMQ=)b6qsHmrvW>$p3g
zU(C_rtLG?t${w?GcJyC+myB8V9W1W6_50u-IRAf@KlX8DfQ=szskb8n7>B8Ryvn|0
zLpx&MR!c?5!>c{%El2){M1StG@9WEM?|!{XeB7)O(D&khM)vbd6<m1#3;g>P-m~Y&
zt%c(&NIrO2T9GYP^QBhZHW(SaMh8<x$`UXnv7}d1?6#|+aDcX5EMT3*&8tR!kD&#C
zxGn%X0!wH9(|^{MFap@P^+_&An0{Maq`A#7Y%wweUR-y|h)JdllL1Q)`Y*>i5V*{0
zFw+ff%P<BpX3-d6Ws5DqQ`arX4D%+i+bWujlo8NF*JeD!2!f?f7&l=O!N`#P`NR*|
zU*Xr^Pdp81cAJrmwG{ar;=P4q^?ml#wc=3p73`iLcaZZxV)}=8`^}E%q7dIyuK`SW
zWslek>uz3MPZz|p;&!pbfG7<XTm*?s1PZ_wTJJDRE8<4I@x?CQTe@1&4(?uW?nY(-
W%Z%%9p`TnE2Nl!A26{~F=-^)_h@wCM

diff --git a/numscrypt/docs/sphinx/_build/doctrees/installation_use.doctree b/numscrypt/docs/sphinx/_build/doctrees/installation_use.doctree
index e1fbb18df7922fda9a5962716eca635f50eae330..79692c4eb4d6beb2ec433eb01f11ba579d12e9fa 100644
GIT binary patch
literal 13834
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
E4X22}CIA2c

literal 13966
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
E0RI7~mjD0&

diff --git a/numscrypt/docs/sphinx/_build/doctrees/supported_constructs.doctree b/numscrypt/docs/sphinx/_build/doctrees/supported_constructs.doctree
index d9c53f6e6ad33041d81bd0b86e5483e4c48f854a..9af508712d1fa31f1b0844942b7951ccfcf024c2 100644
GIT binary patch
literal 50487
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

literal 50478
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
HuUY$F+i>sO

diff --git a/numscrypt/docs/sphinx/_build/doctrees/what_why.doctree b/numscrypt/docs/sphinx/_build/doctrees/what_why.doctree
index 2b7e82669f52b6bfc236bcf063ea7036fd796cec..acbde861c87d01a4634accfeaed4e18059b7ff1e 100644
GIT binary patch
delta 2692
zcmbtWO>Y}T7>>W~IF8*kO;RVV-L$IGv`O2vs;ERE5vqjb)*yP|6t=UwW6!qxmD$-Q
zIe<X|sYruFG=tzDAR!KwdH``j>H#4RT;NnyMQ}jkz}JBToOox~j-9l$kvObm@6J5W
z^M1@c@6XrnT}!{2{@}B%^r@`}M>~0neUCCsWs@HWHXYrwwU*~G*JD@<7@|xzhWN0F
z4UZybc`mFg7#53u2Xa;N0!8bA7g7UDJ|ua?a!re3gK4n2jhR|Q5+ud56t^rhkgrRg
zx6Cefr;*@eL8u4JVxfZ9T;$+rQK`qG!N%xKD&9WFC*05p47%yFg>{110&-3Gu_?(A
z&jmoOWD0rWE#R6{+@wTCdDcf1yG(+VVZ<1<^pN3U1w6;|X6TDM*@^Lp0t8nP&%{br
z<<@)E3gS7#MnM45R%OVu;%e&3V%oM`EE`FlH;84MfDRw$Ktu+jvGFbmVkKWaPio{4
zsViBtz;X<p<M7PEa}sdL0$C)d0Wil<ThU9hM9zrw`O}>mIS)}>2z3<dWM*e*j|JuX
zqSRQy!gjJGQcUrOx)sz1KMc@k$Qc#Jxj~W}eBY~(X|=1_%e@5N%TEm^LoTTxAj0Lx
zVZ0;bD%Hr#5Z@~hpEz4Mn2CyZw^8^gd1@~txmfb@-SWtviA;@LCnfm#OG5lsp1M}z
z`FRIH!8hiW<m*q69Lvnct7Tu?n(83X2C;aM|7F1|$3>@-kE!6_3C-`OtHcZQu8Al`
zn|q|ob(atDy}gT%uZVVWr82MrB8*=m34;3M|2xzVcT=AgcZy5pel8Sq^lmcLF(l+Q
z;MWFw<?hzlWa{Kz%2tT`0ya#fj`tZp0STYR*?tuK%5*V#YEPY4?4n<p-k&^NBcB86
z7ypI2R=bzj8)~VGx>oxp@obHJ1*l(dqpEyN@9}_&=W+*^;}bb)c#aR(pWCimZXMNi
z>a7QuJ`V?W;9OSXCf{)`#UDqiXCNEjKcT7POQq63hp=h3S|dMz^dCX`BlWv5`;w~P
z(=o@oxwtUfOr7i3?^gi+eRocJskslh4RSdIISH|nctM=ajvp+0A%g^H*fl&8(ja*z
zWUYl~q<BA3?+g=UGtI`guq_)IK1y4L@&pVQt^pTvlMl!KqlMI#O|sPFBY^|XrLBeF
zVu5^@XH2YzZCE)Pz&!xobju1X<|)$~HABbOEEg=$MYcj4Qx*cA6kX!lMyu*k2QW%D
za@!$lV+}Nd*CpY)7YnJw7b8p`-Z~EWi$WMhA@ejaIbV6+2CTJA$w$`_bs;#gK8lee
zo8qs;G4Xe5alRC32ryGEpa3etrpwTVMyxim;bD@eZ4dGy9%ibQk=V0)8A*z76H}=f
z%N3W>(-oeLLzH|5Q|eK%oSqUva$J0zUh0%g&#>H<2T`e@z<f(8STKVAn-R^#V8`yZ
z+cTtV>z2ugY~*<n+#bq=bQ_y$e@^RqKUw4xEz8D`N@(54%6rRh^J2Uxqk&`I6#t}W
zrn83UwydZmKK6H%Q+$~`Fj8n^7sJG%Y9zi(&Wela+SH9BiJ>80j<V$kI5Z&;2TCs9
zNKYOqskosGU7K$5vSwO=5(=eJT;gGBTKtqAJ6d2A8CXZgO?jK|hgrp=CIszc*MyF;
zR7;7K<oJsz?B0T6l)C#h6<$2@^h*naMH!|XhBuh%03R6)Kno^<#$(9wWi!;bPFD}?
zQ!TMQSVa@fsubFZsm_iM-H8i^BGBjts!AHnLjkm1#0=wFt3M$PZjI(F<zI(jR#8j3
z!xEV%RdN-M+yiny<b|GuXt^3hC^Sqwy}|6Eh7!1O1_zUn7q_KEQzG={jwvzDh+<@$
aKB!c~&3uzwZITDgke7Ody(uo#7ykuvTI?7A

delta 2623
zcmbtWO>7%Q6t3+!Ydii+LX)(PLTH`DDM^cHOA!%BrEow77paGeLs^Y?$DU2>-OcW7
z;|R4bNToH5grb=uZn+fEL-~<%g&xX@LtCyD5(gxZ5E6m|7bGO!?D{88gqn)OYIkSe
zyzhJ8dv9j$p8Mt8z?Fd;KWq#v@DB?IHg065Qx(girbV&p;EF3Q2^Kd|9n*Ci%fABu
zBmBf<iH)0H-PN3Ro4zo;Mi8AwrVbzLqQrm89SoN|{-7|i@yy|u6FSx`2T{W^MTx~b
z-d%A)u&iO~hJ!V#Qsh)I^#@a$L4ETM0sh(HGs!r0kcP`hTM^g!cz${+Ud1K`zm@}T
z(=K%kTh*+39h=~$#P7{aWRh+jIaFQsAR1S+_}ol>DWmF!i^??&#%9H+!r~DZ7`R@U
z8We^b70aoM7R%^f-BtnBbmfTjnVdbIiyOLXgEB@#kQhs~acjtRG5`DU)Mysh%UD-k
zx?aOB!I%Q>8*_*F&ohN=(!sU`glhOAu8Crpf1jTUD=Pmo^!lp_*YX?<tDaK>N<$7>
zQ?V&|>Y^B884!o!29*)oNTcF98wK4gM^|-hV^hbbW?+~9IG5wanWMvLr=m&uumcki
zdx@KK(<Sm8OWWA)n_#K75NgE$#xg6zxM5I;08!8FaE-F`8gfj-tiptYQ5{^qG<$p{
zs^hXJMNI3K)-Pbx|CLkNaV!VI(JUPt2o}}s6UR?MVd)4GLs8uZt3Yqt#hz}djk>Qw
zTa%h$t^nTs+1!~pMP+r(&?ync7)uaT>&h8rsTwk?9;(XR>R7NaHU*>zvJ1u9PHZv6
zTQfQSUVh|M60~!vVRmYBzgDx*ii+#VsHsTT9SlizLF&P7sYI}Ok^hrFc-}7#!=%_T
zQ4REES=_KK7pvRHQofZ7se`bkQ3^yd%nHQk7g;gnm01dT)arBv-z?;sF(@%m#i26u
z2}Gf^%bu)Y=sp&e&FH5oCY!<UQOH?L_w4RW#L#_<!9YJjmYAaXB`SwK77OYS%g#~c
zDrpbSNs0}xkwruo4R^8I--4vsSod#HHv1wpJAAAQlHvDq2T~qWD5^?Nf`oW;ek|cr
zkS;ItCqw(+QlM7`Z3NXw1&Od8F%lvXQkRB}3xZhiq!C$#mkW;v&t(LBHDc5t9VW0Z
zkbUGV7xVA>gcUv?&ds&RHSz&j+U;wbBadwGweYcKiwL5SkG(Qt15j5O+K^l!XT36c
zzvGj{$bWiF^|QN#z^^35JB!)ydAS=J?sTcMK?-p9X`A3vJEHAp2=Q)mBQiPCB3}T@
zuYe`FS&T}8{G-T$kh1l8<dg71&)p-u70Bk+>foQDXp7t-3Vi+=;%_D<&M7Q*q>iAj
z8b>6#JN+5h&4~>L*5axNbZ?Odz%M5GT_N{CyiNXlVm8&A1~?d*SMPUqi61d_<Tz-3
zkB~~+d>iIZJ22U4{$2ERcAEvj27{^qQa$kh9qwN{p!u!ji5=nIN<Ke&v#5X|Ujz0x
zoxrzFX2&86+e+XOIfIm)%uYq}t>su~-#(%&C*TznLVTC+)zM`5={=W&tcKB{@Ip6D
z%VPn=L>FRc7sSKyZ$pm-@o@ZZsM&+a2N1Jeh*SW9+m(HFudSEqZ@uR3)*C+qr=uq~
zTmH^u<``)$KP$oaur>INXHOmi)t3UkFLwE6fv?;jdKtYvc{XzN@tkkno-9RP>8bKs
zfKu$DjPz8IfS`&LNbXHipk@%sCGx4a@pi5`47U|HxhTYHnQ)2)_q37jWkrP}!i96t
wKLz5Q`;`AT(zi4?GT@Fk)LrYJ3UESHI&*ScWrOm{<DU|+-zkDzLtgplzZ>@mjsO4v

diff --git a/numscrypt/docs/sphinx/_build/html/.buildinfo b/numscrypt/docs/sphinx/_build/html/.buildinfo
index 1628da3..417c0c9 100644
--- a/numscrypt/docs/sphinx/_build/html/.buildinfo
+++ b/numscrypt/docs/sphinx/_build/html/.buildinfo
@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 20ecd46bc80f0b5c8558f20a72f5a755
+config: 3a8694f6ba9920c7983861d6105bd938
 tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/numscrypt/docs/sphinx/_build/html/_sources/installation_use.txt b/numscrypt/docs/sphinx/_build/html/_sources/installation_use.txt
index 793f0b4..390c145 100644
--- a/numscrypt/docs/sphinx/_build/html/_sources/installation_use.txt
+++ b/numscrypt/docs/sphinx/_build/html/_sources/installation_use.txt
@@ -28,14 +28,14 @@ To experiment with Numscrypt yourself:
 Troubleshooting checklist
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-1. Problem installing NumPy. To be able to test back to back with CPython, NumPy has to be installed into Python 3.5. On Linux and OSX the simplest way to achieve this, is to use `miniconda <http://conda.pydata.org/miniconda.html>`_.
-2. Problem installing Numscrypt into the right version of Python. Numscrypt and Transcrypt require Python 3.5. To be certain that the right version of Python is picked for installation, on Windows install with:
+1. Problem installing NumPy. To be able to test back to back with CPython, NumPy has to be installed into Python 3.6. On Linux and OSX the simplest way to achieve this, is to use `miniconda <http://conda.pydata.org/miniconda.html>`_.
+2. Problem installing Numscrypt into the right version of Python. Numscrypt and Transcrypt require Python 3.6. To be certain that the right version of Python is picked for installation, on Windows install with:
 
-   *python35 -m pip install Transcrypt*
+   *python36 -m pip install Transcrypt*
 
    On Linux install with:
 
-   *python3.5 -m pip install Transcrypt*
+   *python3.6 -m pip install Transcrypt*
 
-   Preferably use the miniconda installation of Python 3.5 as described earlier in this checklist.
+   Preferably use the miniconda installation of Python 3.6 as described earlier in this checklist.
    Use the --upgrade switch to upgrade rather than first-time install, as described in `pip's documentation <https://pip.pypa.io/en/stable/>`_.
diff --git a/numscrypt/docs/sphinx/_build/html/genindex.html b/numscrypt/docs/sphinx/_build/html/genindex.html
index e909ad8..da26eed 100644
--- a/numscrypt/docs/sphinx/_build/html/genindex.html
+++ b/numscrypt/docs/sphinx/_build/html/genindex.html
@@ -7,7 +7,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     
-    <title>Index &mdash; Transcrypt 0.0.35 documentation</title>
+    <title>Index &mdash; Transcrypt 0.0.37 documentation</title>
     
     <link rel="stylesheet" href="_static/classic.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
@@ -15,7 +15,7 @@
     <script type="text/javascript">
       var DOCUMENTATION_OPTIONS = {
         URL_ROOT:    './',
-        VERSION:     '0.0.35',
+        VERSION:     '0.0.37',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '.html',
         HAS_SOURCE:  true
@@ -24,7 +24,7 @@
     <script type="text/javascript" src="_static/jquery.js"></script>
     <script type="text/javascript" src="_static/underscore.js"></script>
     <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="Transcrypt 0.0.35 documentation" href="index.html" /> 
+    <link rel="top" title="Transcrypt 0.0.37 documentation" href="index.html" /> 
   </head>
   <body role="document">
     <div class="related" role="navigation" aria-label="related navigation">
@@ -33,7 +33,7 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="#" title="General Index"
              accesskey="I">index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>  
 
@@ -84,7 +84,7 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="#" title="General Index"
              >index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
diff --git a/numscrypt/docs/sphinx/_build/html/index.html b/numscrypt/docs/sphinx/_build/html/index.html
index d504766..1ad8829 100644
--- a/numscrypt/docs/sphinx/_build/html/index.html
+++ b/numscrypt/docs/sphinx/_build/html/index.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     
-    <title>Welcome to Numscrypt’s documentation! &mdash; Transcrypt 0.0.35 documentation</title>
+    <title>Welcome to Numscrypt’s documentation! &mdash; Transcrypt 0.0.37 documentation</title>
     
     <link rel="stylesheet" href="_static/classic.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
@@ -14,7 +14,7 @@
     <script type="text/javascript">
       var DOCUMENTATION_OPTIONS = {
         URL_ROOT:    './',
-        VERSION:     '0.0.35',
+        VERSION:     '0.0.37',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '.html',
         HAS_SOURCE:  true
@@ -23,7 +23,7 @@
     <script type="text/javascript" src="_static/jquery.js"></script>
     <script type="text/javascript" src="_static/underscore.js"></script>
     <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="Transcrypt 0.0.35 documentation" href="#" />
+    <link rel="top" title="Transcrypt 0.0.37 documentation" href="#" />
     <link rel="next" title="1. Numscrypt: what and why" href="what_why.html" /> 
   </head>
   <body role="document">
@@ -36,7 +36,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="what_why.html" title="1. Numscrypt: what and why"
              accesskey="N">next</a> |</li>
-        <li class="nav-item nav-item-0"><a href="#">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="#">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>  
 
@@ -129,7 +129,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="what_why.html" title="1. Numscrypt: what and why"
              >next</a> |</li>
-        <li class="nav-item nav-item-0"><a href="#">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="#">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
diff --git a/numscrypt/docs/sphinx/_build/html/installation_use.html b/numscrypt/docs/sphinx/_build/html/installation_use.html
index 1c6052d..a38d52a 100644
--- a/numscrypt/docs/sphinx/_build/html/installation_use.html
+++ b/numscrypt/docs/sphinx/_build/html/installation_use.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     
-    <title>2. Getting started &mdash; Transcrypt 0.0.35 documentation</title>
+    <title>2. Getting started &mdash; Transcrypt 0.0.37 documentation</title>
     
     <link rel="stylesheet" href="_static/classic.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
@@ -14,7 +14,7 @@
     <script type="text/javascript">
       var DOCUMENTATION_OPTIONS = {
         URL_ROOT:    './',
-        VERSION:     '0.0.35',
+        VERSION:     '0.0.37',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '.html',
         HAS_SOURCE:  true
@@ -23,7 +23,7 @@
     <script type="text/javascript" src="_static/jquery.js"></script>
     <script type="text/javascript" src="_static/underscore.js"></script>
     <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="Transcrypt 0.0.35 documentation" href="index.html" />
+    <link rel="top" title="Transcrypt 0.0.37 documentation" href="index.html" />
     <link rel="next" title="3. Currently available features" href="supported_constructs.html" />
     <link rel="prev" title="1. Numscrypt: what and why" href="what_why.html" /> 
   </head>
@@ -40,7 +40,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="what_why.html" title="1. Numscrypt: what and why"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>  
 
@@ -74,13 +74,13 @@ <h2>2.1. Installation<a class="headerlink" href="#installation" title="Permalink
 <div class="section" id="troubleshooting-checklist">
 <h3>2.1.1. Troubleshooting checklist<a class="headerlink" href="#troubleshooting-checklist" title="Permalink to this headline">¶</a></h3>
 <ol class="arabic">
-<li><p class="first">Problem installing NumPy. To be able to test back to back with CPython, NumPy has to be installed into Python 3.5. On Linux and OSX the simplest way to achieve this, is to use <a class="reference external" href="http://conda.pydata.org/miniconda.html">miniconda</a>.</p>
+<li><p class="first">Problem installing NumPy. To be able to test back to back with CPython, NumPy has to be installed into Python 3.6. On Linux and OSX the simplest way to achieve this, is to use <a class="reference external" href="http://conda.pydata.org/miniconda.html">miniconda</a>.</p>
 </li>
-<li><p class="first">Problem installing Numscrypt into the right version of Python. Numscrypt and Transcrypt require Python 3.5. To be certain that the right version of Python is picked for installation, on Windows install with:</p>
-<p><em>python35 -m pip install Transcrypt</em></p>
+<li><p class="first">Problem installing Numscrypt into the right version of Python. Numscrypt and Transcrypt require Python 3.6. To be certain that the right version of Python is picked for installation, on Windows install with:</p>
+<p><em>python36 -m pip install Transcrypt</em></p>
 <p>On Linux install with:</p>
-<p><em>python3.5 -m pip install Transcrypt</em></p>
-<p>Preferably use the miniconda installation of Python 3.5 as described earlier in this checklist.
+<p><em>python3.6 -m pip install Transcrypt</em></p>
+<p>Preferably use the miniconda installation of Python 3.6 as described earlier in this checklist.
 Use the &#8211;upgrade switch to upgrade rather than first-time install, as described in <a class="reference external" href="https://pip.pypa.io/en/stable/">pip&#8217;s documentation</a>.</p>
 </li>
 </ol>
@@ -150,7 +150,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="what_why.html" title="1. Numscrypt: what and why"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
diff --git a/numscrypt/docs/sphinx/_build/html/objects.inv b/numscrypt/docs/sphinx/_build/html/objects.inv
index 3fde24e..8e9718b 100644
--- a/numscrypt/docs/sphinx/_build/html/objects.inv
+++ b/numscrypt/docs/sphinx/_build/html/objects.inv
@@ -1,6 +1,6 @@
 # Sphinx inventory version 2
 # Project: Transcrypt
-# Version: 0.0.35
+# Version: 0.0.37
 # The remainder of this file is compressed using zlib.
 xڝ��N�0��~
 K���57z�
�D�co���w-Q���q�B��p��3��.��'�������ࣤ���6N��z:I)��`;q.��qd���Zij�&��i�k��V�C0�������`��=~i��jŨJQ��v� `��[ԹB��^���Z>��%�⠆t6�e�Zu�φ7=��N��t�^��5�j��R~��<Xw8�_�sRM���v��0h7����۫L�
�+M
\ No newline at end of file
diff --git a/numscrypt/docs/sphinx/_build/html/search.html b/numscrypt/docs/sphinx/_build/html/search.html
index 5f29432..8065eee 100644
--- a/numscrypt/docs/sphinx/_build/html/search.html
+++ b/numscrypt/docs/sphinx/_build/html/search.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     
-    <title>Search &mdash; Transcrypt 0.0.35 documentation</title>
+    <title>Search &mdash; Transcrypt 0.0.37 documentation</title>
     
     <link rel="stylesheet" href="_static/classic.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
@@ -14,7 +14,7 @@
     <script type="text/javascript">
       var DOCUMENTATION_OPTIONS = {
         URL_ROOT:    './',
-        VERSION:     '0.0.35',
+        VERSION:     '0.0.37',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '.html',
         HAS_SOURCE:  true
@@ -24,7 +24,7 @@
     <script type="text/javascript" src="_static/underscore.js"></script>
     <script type="text/javascript" src="_static/doctools.js"></script>
     <script type="text/javascript" src="_static/searchtools.js"></script>
-    <link rel="top" title="Transcrypt 0.0.35 documentation" href="index.html" />
+    <link rel="top" title="Transcrypt 0.0.37 documentation" href="index.html" />
   <script type="text/javascript">
     jQuery(function() { Search.loadIndex("searchindex.js"); });
   </script>
@@ -40,7 +40,7 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="genindex.html" title="General Index"
              accesskey="I">index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>  
 
@@ -91,7 +91,7 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="genindex.html" title="General Index"
              >index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
diff --git a/numscrypt/docs/sphinx/_build/html/searchindex.js b/numscrypt/docs/sphinx/_build/html/searchindex.js
index 58d3a63..5126b5a 100644
--- a/numscrypt/docs/sphinx/_build/html/searchindex.js
+++ b/numscrypt/docs/sphinx/_build/html/searchindex.js
@@ -1 +1 @@
-Search.setIndex({envversion:47,filenames:["index","installation_use","supported_constructs","what_why"],objects:{},objnames:{},objtypes:{},terms:{"001j":2,"15j":2,"33j":2,"75j":2,"__call__":2,"__envir__":2,"__javascript__":1,"__main__":2,"__new__":2,"__pragma__":2,"__repr__":2,"__str__":2,"case":3,"default":[],"import":2,"int":2,"new":2,"return":2,"switch":1,"true":2,"try":[],"while":3,a_linalg:[],abil:3,abl:1,access:3,achiev:1,add_3a:2,add_a3:2,addit:2,against:2,all:2,along:[],alphabet:2,alreadi:[],also:[1,2,3],alt:2,alter:[],altern:[],although:3,alwai:3,annot:3,anoth:3,anymor:[],appear:3,applic:3,approach:3,arbitrari:3,aren:3,arrai:[],arrang:2,asm:3,aspect:3,astyp:2,attent:[],attract:3,autom:2,automated_test:1,autotest:[1,2],avail:[],avoid:2,back:1,balanc:3,basic:[],becom:[],been:3,befor:[],behind:[],benchmark:[],benefit:3,better:[],between:3,block:[],bp0:2,bp1:2,bp2:2,bp3:2,bp4:2,bp5:2,bp6:2,bp7:2,bpsl0:2,bpsl1:2,bpsl2:2,bpsl3:2,bpsl4:2,bpsl5:2,bpsl6:2,bpsl7:2,branch:3,broad:3,brows:[],browser:[],bsl0:2,bsl1:2,bsl2:2,bsl3:2,bsl4:2,bsl5:2,bsl6:2,bsl7:2,bundl:[],call:2,can:[1,3],caus:[],certain:1,certainli:3,chanc:3,check:2,choic:3,chrome:1,cid:2,clean:[],clear:[],clearest:3,click:1,code:[],collect:2,column:[],combin:[],command:1,comp_a:2,comp_a_squar:2,comp_b:2,comp_b_squar:2,comp_c:2,comp_c_squar:2,comp_d_squar:2,comp_e_squar:2,comp_f_squar:2,compar:[1,3],compat:3,compil:[1,2,3],complet:3,complex128:2,complex32:2,complex64:2,complex:[],complic:[],comprehend:[],compromis:[],comput:[],conclus:[],confusingli:3,conserv:3,consid:[],consider:[],consol:[],constantli:[],construct:2,contrast:[],contribut:[],convolut:3,copi:[2,3],cost:[],cours:[],cover:2,cpython:[1,2],creat:[],critic:[],cs0:2,cs1:2,cti:2,cts0:2,cts1:2,cts2:2,current:[],cut:2,data:3,date:2,decent:3,dedic:3,def:2,deliber:3,delta:2,demo:[2,3],demonstr:3,describ:1,descript:2,deserv:[],design:[],desktop:3,despit:3,develop:1,deviat:3,dif:2,differ:2,differenti:[],dimens:[2,3],dimension:3,direct:3,directori:1,disadvis:[],distribut:2,div_3a:2,div_a3:2,divis:2,doesn:3,done:[1,2],dot:2,dotproduct:2,down:[],download:[],ds0:2,ds1:2,ds2:2,ds3:2,dti:2,dts0:2,dts1:2,dtype:2,due:[],dysfunct:2,earlier:1,eas:[],educ:3,effect:2,effici:3,eleg:[],elem:2,elementwis:[2,3],els:2,empti:2,enabl:3,enorm:3,environ:3,equat:[],error:1,especi:[],espit:[],essenti:[],even:[],eventu:3,exampl:[],execut:3,executor_nam:2,exist:3,experi:1,experiment1:1,experiment:[],express:2,extend:2,facad:[],facil:[],facilit:3,fact:3,fals:2,familiar:3,fast:3,favor:3,favour:[],fco:2,featur:[],fft2:2,fft:[],file:1,find:[],first:[1,3],float32:2,float64:2,focus:3,follow:1,forc:3,form:[],format:2,fourier:[],fragment:2,freq:2,freqs2:2,frequenc:2,frequent:[],from:[1,2,3],fsampl:2,fsin:2,fulli:3,futur:3,gain:3,gener:[1,3],get:[],getelementbyid:2,getnow:2,given:3,goal:3,good:3,gpgpu:3,guid:[],had:[],happen:[],hardwar:3,harmon:[],have:3,here:[],highli:[],hile:[],how:1,howev:[],hsplit:2,hstack:2,html:1,http:[],icol:2,icurr:2,ident:2,ifft2:2,ifft:[],illustr:3,imag:2,implement:[],increas:3,inde:[],index:2,innerhtml:2,instal:[],instead:[],int32:2,interact:[],introduc:3,introduct:3,inv:2,invers:[],irow:2,isampl:2,ito:[],itself:[],javascript:[1,3],just:3,keep:3,known:[],lack:[],languag:3,larg:3,lead:[],lean:3,learn:2,led:3,left:3,lengthi:2,librari:[2,3],like:[2,3],linalg:[],line:[],linear:[],linux:1,list:3,load:1,log:[],look:[],lot:[],mai:3,make:1,mani:3,manner:3,manycor:3,map:[],math:[2,3],matrix:[],matter:3,mean:3,meant:3,mechan:[],medium:3,memori:3,mere:[],mimic:3,mind:3,miniconda:1,minor:3,mix:2,module_fft:2,module_linalg:2,more:[],moreov:[],most:3,much:3,mul_3a:2,mul_a3:2,multi:3,multipl:3,natur:3,nayuki:[],ndarrai:[1,2,3],need:[1,3],neg_a:2,newest:[],newli:3,non:3,noopov:2,noskip:2,notat:3,now:[],ns_natur:[],ns_set:[],num:2,num_rand:2,number:1,numcrypt:[],numer:3,numpi:[1,2,3],obviou:3,offici:[],offset:3,often:3,old:2,onli:[1,3],oper:[2,3],opov:2,optim:3,optim_spac:[],optimize_spac:[],order:3,org:2,orig2:2,orig:2,origin:2,osx:1,other:[],out:3,output:1,over:3,overhead:[],overload:[2,3],own:1,pad:[],page:1,pariti:3,part:[2,3],partial:3,per:3,perform:[2,3],permut:2,physic:3,pick:1,pip:1,place:[],point:1,pointless:3,port:3,power:[],pre:2,precalcul:[],prefer:1,print:2,probabl:[],problem:1,procedur:[],process:[],prod:2,product:2,program:3,prompt:1,prove:3,provid:[],pure:3,pursuit:3,put:1,pypa:[],python35:1,python3:1,python:[1,3],quot:2,quotient:2,rand:2,random:2,rang:2,rapid:[],rare:3,rather:[1,3],rational:[],readi:2,real:2,reconsider:3,reconstr2:2,reconstr:2,reconstruct:2,recurs:[],refer:1,reflect:[],regress:2,rel:3,relax:3,releas:[],relev:3,replac:2,report:1,requir:[1,3],reshap:[],reshuffl:3,resolv:2,respect:3,restrict:3,result:2,rid:2,right:1,robust:3,round:2,row:[2,3],run:[1,2],sampl:[],save:[],scalabilti:3,scalabl:[],scalar:2,scale:3,scienc:3,scientist:3,seen:[],seriou:3,set:[],sever:3,shape:2,should:1,shown:2,significantli:[],simd:3,simpl:2,simpler:3,simplest:1,simplic:3,simplif:3,simplifi:3,sin:2,sinc:[2,3],size:2,skip:2,slice:[2,3],slice_a:2,slice_at:2,sliceable_a:2,sliceable_at:2,slicing_optim:2,slow:3,slower:[],small:3,solut:3,some:[],someth:3,sometim:3,soon:[],sought:3,sourc:3,sourcecod:2,space:[],special:3,speed:3,stabl:[],stai:1,start:[],still:3,storag:3,store:3,str:2,strid:[],stride:3,strive:[],struck:[],stub:2,sub_3a:2,sub_a3:2,subdirectori:1,subject:2,suboptim:[],subset:3,subtract:2,suit:2,suitabl:[],sum:2,support:[2,3],system:[],systemat:[],tcurrent:2,technician:3,technolog:3,ten:2,test:[],testlet:2,than:[1,2,3],thei:[2,3],them:3,thi:[1,3],thing:[1,3],time:[1,2],timeend:2,timestartadd:2,timestartdiv:2,timestartfft:2,timestartifft:2,timestartinv:2,timestartmul:2,timestartscalp:2,timestartsub:2,timestarttranspos:2,timestopfft:2,timestopifft:2,tolist:2,too:3,took:2,tool:[2,3],tour:[],transcrypt:[1,2,3],transform:[],transpil:2,transpiler_nam:2,transpos:2,trick:3,trivial:3,ttotal:2,tupl:2,two:[2,3],type:[1,3],under:1,understand:[],unnatur:[],updat:[],upgrad:1,usecomplex:2,variant:[],vector:2,vel:2,veri:[2,3],version:[1,3],view:3,vsplit:2,vstack:2,vsum:2,wai:[1,3],weird:3,well:3,went:1,were:1,weren:[],what:[],when:3,where:1,wherea:3,which:2,whole:[],why:[],window:1,wise:[],worth:2,would:2,yet:1,you:1,your:1,yourself:1,zero:2},titles:["Welcome to Numscrypt&#8217;s documentation!","2. Getting started","3. Currently available features","1. Numscrypt: what and why"],titleterms:{arrai:2,avail:2,basic:2,benchmark:2,browser:3,checklist:1,code:2,complex:2,comput:3,content:0,creat:2,current:2,document:0,exampl:2,facil:[],featur:2,fft:2,fourier:2,get:1,guid:2,ifft:2,instal:1,interact:2,invers:2,linalg:2,matrix:2,more:2,ns_set:[],numscrypt:[0,2,3],optimize_spac:[],sampl:2,some:2,start:1,systemat:2,tabl:0,test:2,tour:2,transform:2,troubleshoot:1,welcom:0,what:3,why:3}})
\ No newline at end of file
+Search.setIndex({envversion:47,filenames:["index","installation_use","supported_constructs","what_why"],objects:{},objnames:{},objtypes:{},terms:{"001j":2,"15j":2,"33j":2,"75j":2,"__call__":2,"__envir__":2,"__javascript__":1,"__main__":2,"__new__":2,"__pragma__":2,"__repr__":2,"__str__":2,"case":3,"default":[],"import":2,"int":2,"new":2,"return":2,"switch":1,"true":2,"try":[],"while":3,a_linalg:[],abil:3,abl:1,access:3,achiev:1,add_3a:2,add_a3:2,addit:2,against:2,all:2,along:[],alphabet:2,alreadi:[],also:[1,2,3],alt:2,alter:[],altern:[],although:3,alwai:3,annot:3,anoth:3,anymor:[],appear:3,applic:3,approach:3,arbitrari:3,aren:3,arrai:[],arrang:2,asm:3,aspect:3,astyp:2,attent:[],attract:3,autom:2,automated_test:1,autotest:[1,2],avail:[],avoid:2,back:1,balanc:3,basic:[],becom:[],been:3,befor:[],behind:[],benchmark:[],benefit:3,better:[],between:3,block:[],bp0:2,bp1:2,bp2:2,bp3:2,bp4:2,bp5:2,bp6:2,bp7:2,bpsl0:2,bpsl1:2,bpsl2:2,bpsl3:2,bpsl4:2,bpsl5:2,bpsl6:2,bpsl7:2,branch:3,broad:3,brows:[],browser:[],bsl0:2,bsl1:2,bsl2:2,bsl3:2,bsl4:2,bsl5:2,bsl6:2,bsl7:2,bundl:[],call:2,can:[1,3],caus:[],certain:1,certainli:3,chanc:3,check:2,choic:3,chrome:1,cid:2,clean:[],clear:[],clearest:3,click:1,code:[],collect:2,column:[],combin:[],command:1,comp_a:2,comp_a_squar:2,comp_b:2,comp_b_squar:2,comp_c:2,comp_c_squar:2,comp_d_squar:2,comp_e_squar:2,comp_f_squar:2,compar:[1,3],compat:3,compil:[1,2,3],complet:3,complex128:2,complex32:2,complex64:2,complex:[],complic:[],comprehend:[],compromis:[],comput:[],conclus:[],confusingli:3,conserv:3,consid:[],consider:[],consol:[],constantli:[],construct:2,contrast:[],contribut:[],convolut:3,copi:[2,3],cost:[],cours:[],cover:2,cpython:[1,2],creat:[],critic:[],cs0:2,cs1:2,cti:2,cts0:2,cts1:2,cts2:2,current:[],cut:2,data:3,date:2,decent:3,dedic:3,def:2,deliber:3,delta:2,demo:[2,3],demonstr:3,describ:1,descript:2,deserv:[],design:[],desktop:3,despit:3,develop:1,deviat:3,dif:2,differ:2,differenti:[],dimens:[2,3],dimension:3,direct:3,directori:1,disadvis:[],distribut:2,div_3a:2,div_a3:2,divis:2,doesn:3,done:[1,2],dot:2,dotproduct:2,down:[],download:[],ds0:2,ds1:2,ds2:2,ds3:2,dti:2,dts0:2,dts1:2,dtype:2,due:[],dysfunct:2,earlier:1,eas:[],educ:3,effect:2,effici:3,eleg:[],elem:2,elementwis:[2,3],els:2,empti:2,enabl:3,enorm:3,environ:3,equat:[],error:1,especi:[],espit:[],essenti:[],even:[],eventu:3,exampl:[],execut:3,executor_nam:2,exist:3,experi:1,experiment1:1,experiment:[],express:2,extend:2,facad:[],facil:[],facilit:3,fact:3,fals:2,familiar:3,fast:3,favor:3,favour:[],fco:2,featur:[],fft2:2,fft:[],file:1,find:[],first:[1,3],float32:2,float64:2,focus:3,follow:1,forc:3,form:[],format:2,fourier:[],fragment:2,freq:2,freqs2:2,frequenc:2,frequent:[],from:[1,2,3],fsampl:2,fsin:2,fulli:3,futur:3,gain:3,gener:[1,3],get:[],getelementbyid:2,getnow:2,given:3,goal:3,good:3,gpgpu:3,guid:[],had:[],happen:[],hardwar:3,harmon:[],have:3,here:[],highli:[],hile:[],how:1,howev:[],hsplit:2,hstack:2,html:1,http:[],icol:2,icurr:2,ident:2,ifft2:2,ifft:[],illustr:3,imag:2,implement:[],increas:3,inde:[],index:2,innerhtml:2,instal:[],instead:[],int32:2,interact:[],introduc:3,introduct:3,inv:2,invers:[],irow:2,isampl:2,ito:[],itself:[],javascript:[1,3],just:3,keep:3,known:[],lack:[],languag:3,larg:3,lead:[],lean:3,learn:2,led:3,left:3,lengthi:2,librari:[2,3],like:[2,3],linalg:[],line:[],linear:[],linux:1,list:3,load:1,log:[],look:[],lot:[],mai:3,make:1,mani:3,manner:3,manycor:3,map:[],math:[2,3],matrix:[],matter:3,mean:3,meant:3,mechan:[],medium:3,memori:3,mere:[],mimic:3,mind:3,miniconda:1,minor:3,mix:2,module_fft:2,module_linalg:2,more:[],moreov:[],most:3,much:3,mul_3a:2,mul_a3:2,multi:3,multipl:3,natur:3,nayuki:[],ndarrai:[1,2,3],need:[1,3],neg_a:2,newest:[],newli:3,non:3,noopov:2,noskip:2,notat:3,now:[],ns_natur:[],ns_set:[],num:2,num_rand:2,number:1,numcrypt:[],numer:3,numpi:[1,2,3],obviou:3,offici:[],offset:3,often:3,old:2,onli:[1,3],oper:[2,3],opov:2,optim:3,optim_spac:[],optimize_spac:[],order:3,org:2,orig2:2,orig:2,origin:2,osx:1,other:[],out:3,output:1,over:3,overhead:[],overload:[2,3],own:1,pad:[],page:1,pariti:3,part:[2,3],partial:3,per:3,perform:[2,3],permut:2,physic:3,pick:1,pip:1,place:[],point:1,pointless:3,port:3,power:[],pre:2,precalcul:[],prefer:1,print:2,probabl:[],problem:1,procedur:[],process:[],prod:2,product:2,program:3,prompt:1,prove:3,provid:[],pure:3,pursuit:3,put:1,pypa:[],python35:[],python36:1,python3:1,python:[1,3],quot:2,quotient:2,rand:2,random:2,rang:2,rapid:[],rare:3,rather:[1,3],rational:[],readi:2,real:2,reconsider:3,reconstr2:2,reconstr:2,reconstruct:2,recurs:[],refer:1,reflect:[],regress:2,rel:3,relax:3,releas:[],relev:3,replac:2,report:1,requir:[1,3],reshap:[],reshuffl:3,resolv:2,respect:3,restrict:3,result:2,rid:2,right:1,robust:3,round:2,row:[2,3],run:[1,2],sampl:[],save:[],scalabilti:3,scalabl:[],scalar:2,scale:3,scienc:3,scientist:3,seen:[],seriou:3,set:[],sever:3,shape:2,should:1,shown:2,significantli:[],simd:3,simpl:2,simpler:3,simplest:1,simplic:3,simplif:3,simplifi:3,sin:2,sinc:[2,3],size:2,skip:2,slice:[2,3],slice_a:2,slice_at:2,sliceable_a:2,sliceable_at:2,slicing_optim:2,slow:3,slower:[],small:3,solut:3,some:[],someth:3,sometim:3,soon:[],sought:3,sourc:3,sourcecod:2,space:[],special:3,speed:3,stabl:[],stai:1,start:[],still:3,storag:3,store:3,str:2,strid:[],stride:3,strive:[],struck:[],stub:2,sub_3a:2,sub_a3:2,subdirectori:1,subject:2,suboptim:[],subset:3,subtract:2,suit:2,suitabl:[],sum:2,support:[2,3],system:[],systemat:[],tcurrent:2,technician:3,technolog:3,ten:2,test:[],testlet:2,than:[1,2,3],thei:[2,3],them:3,thi:[1,3],thing:[1,3],time:[1,2],timeend:2,timestartadd:2,timestartdiv:2,timestartfft:2,timestartifft:2,timestartinv:2,timestartmul:2,timestartscalp:2,timestartsub:2,timestarttranspos:2,timestopfft:2,timestopifft:2,tolist:2,too:3,took:2,tool:[2,3],tour:[],transcrypt:[1,2,3],transform:[],transpil:2,transpiler_nam:2,transpos:2,trick:3,trivial:3,ttotal:2,tupl:2,two:[2,3],type:[1,3],under:1,understand:[],unnatur:[],updat:[],upgrad:1,usecomplex:2,variant:[],vector:2,vel:2,veri:[2,3],version:[1,3],view:3,vsplit:2,vstack:2,vsum:2,wai:[1,3],weird:3,well:3,went:1,were:1,weren:[],what:[],when:3,where:1,wherea:3,which:2,whole:[],why:[],window:1,wise:[],worth:2,would:2,yet:1,you:1,your:1,yourself:1,zero:2},titles:["Welcome to Numscrypt&#8217;s documentation!","2. Getting started","3. Currently available features","1. Numscrypt: what and why"],titleterms:{arrai:2,avail:2,basic:2,benchmark:2,browser:3,checklist:1,code:2,complex:2,comput:3,content:0,creat:2,current:2,document:0,exampl:2,facil:[],featur:2,fft:2,fourier:2,get:1,guid:2,ifft:2,instal:1,interact:2,invers:2,linalg:2,matrix:2,more:2,ns_set:[],numscrypt:[0,2,3],optimize_spac:[],sampl:2,some:2,start:1,systemat:2,tabl:0,test:2,tour:2,transform:2,troubleshoot:1,welcom:0,what:3,why:3}})
\ No newline at end of file
diff --git a/numscrypt/docs/sphinx/_build/html/supported_constructs.html b/numscrypt/docs/sphinx/_build/html/supported_constructs.html
index c0764da..b57b7b6 100644
--- a/numscrypt/docs/sphinx/_build/html/supported_constructs.html
+++ b/numscrypt/docs/sphinx/_build/html/supported_constructs.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     
-    <title>3. Currently available features &mdash; Transcrypt 0.0.35 documentation</title>
+    <title>3. Currently available features &mdash; Transcrypt 0.0.37 documentation</title>
     
     <link rel="stylesheet" href="_static/classic.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
@@ -14,7 +14,7 @@
     <script type="text/javascript">
       var DOCUMENTATION_OPTIONS = {
         URL_ROOT:    './',
-        VERSION:     '0.0.35',
+        VERSION:     '0.0.37',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '.html',
         HAS_SOURCE:  true
@@ -23,7 +23,7 @@
     <script type="text/javascript" src="_static/jquery.js"></script>
     <script type="text/javascript" src="_static/underscore.js"></script>
     <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="Transcrypt 0.0.35 documentation" href="index.html" />
+    <link rel="top" title="Transcrypt 0.0.37 documentation" href="index.html" />
     <link rel="prev" title="2. Getting started" href="installation_use.html" /> 
   </head>
   <body role="document">
@@ -36,7 +36,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="installation_use.html" title="2. Getting started"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>  
 
@@ -729,7 +729,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="installation_use.html" title="2. Getting started"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
diff --git a/numscrypt/docs/sphinx/_build/html/what_why.html b/numscrypt/docs/sphinx/_build/html/what_why.html
index e1ef831..93d2f3c 100644
--- a/numscrypt/docs/sphinx/_build/html/what_why.html
+++ b/numscrypt/docs/sphinx/_build/html/what_why.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     
-    <title>1. Numscrypt: what and why &mdash; Transcrypt 0.0.35 documentation</title>
+    <title>1. Numscrypt: what and why &mdash; Transcrypt 0.0.37 documentation</title>
     
     <link rel="stylesheet" href="_static/classic.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
@@ -14,7 +14,7 @@
     <script type="text/javascript">
       var DOCUMENTATION_OPTIONS = {
         URL_ROOT:    './',
-        VERSION:     '0.0.35',
+        VERSION:     '0.0.37',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '.html',
         HAS_SOURCE:  true
@@ -23,7 +23,7 @@
     <script type="text/javascript" src="_static/jquery.js"></script>
     <script type="text/javascript" src="_static/underscore.js"></script>
     <script type="text/javascript" src="_static/doctools.js"></script>
-    <link rel="top" title="Transcrypt 0.0.35 documentation" href="index.html" />
+    <link rel="top" title="Transcrypt 0.0.37 documentation" href="index.html" />
     <link rel="next" title="2. Getting started" href="installation_use.html" />
     <link rel="prev" title="Welcome to Numscrypt’s documentation!" href="index.html" /> 
   </head>
@@ -40,7 +40,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="index.html" title="Welcome to Numscrypt’s documentation!"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>  
 
@@ -124,7 +124,7 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="index.html" title="Welcome to Numscrypt’s documentation!"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.35 documentation</a> &raquo;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Transcrypt 0.0.37 documentation</a> &raquo;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
diff --git a/numscrypt/docs/sphinx/installation_use.rst b/numscrypt/docs/sphinx/installation_use.rst
index 793f0b4..390c145 100644
--- a/numscrypt/docs/sphinx/installation_use.rst
+++ b/numscrypt/docs/sphinx/installation_use.rst
@@ -28,14 +28,14 @@ To experiment with Numscrypt yourself:
 Troubleshooting checklist
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-1. Problem installing NumPy. To be able to test back to back with CPython, NumPy has to be installed into Python 3.5. On Linux and OSX the simplest way to achieve this, is to use `miniconda <http://conda.pydata.org/miniconda.html>`_.
-2. Problem installing Numscrypt into the right version of Python. Numscrypt and Transcrypt require Python 3.5. To be certain that the right version of Python is picked for installation, on Windows install with:
+1. Problem installing NumPy. To be able to test back to back with CPython, NumPy has to be installed into Python 3.6. On Linux and OSX the simplest way to achieve this, is to use `miniconda <http://conda.pydata.org/miniconda.html>`_.
+2. Problem installing Numscrypt into the right version of Python. Numscrypt and Transcrypt require Python 3.6. To be certain that the right version of Python is picked for installation, on Windows install with:
 
-   *python35 -m pip install Transcrypt*
+   *python36 -m pip install Transcrypt*
 
    On Linux install with:
 
-   *python3.5 -m pip install Transcrypt*
+   *python3.6 -m pip install Transcrypt*
 
-   Preferably use the miniconda installation of Python 3.5 as described earlier in this checklist.
+   Preferably use the miniconda installation of Python 3.6 as described earlier in this checklist.
    Use the --upgrade switch to upgrade rather than first-time install, as described in `pip's documentation <https://pip.pypa.io/en/stable/>`_.