index.js

// Generated by purs bundle 0.13.4
var PS = {};
(function(exports) {
  "use strict";

  exports.arrayMap = function (f) {
    return function (arr) {
      var l = arr.length;
      var result = new Array(l);
      for (var i = 0; i < l; i++) {
        result[i] = f(arr[i]);
      }
      return result;
    };
  };
})(PS["Data.Functor"] = PS["Data.Functor"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Function"] = $PS["Data.Function"] || {};
  var exports = $PS["Data.Function"];
  var flip = function (f) {
      return function (b) {
          return function (a) {
              return f(a)(b);
          };
      };
  };
  var $$const = function (a) {
      return function (v) {
          return a;
      };
  };
  exports["flip"] = flip;
  exports["const"] = $$const;
})(PS);
(function(exports) {
  "use strict";

  exports.unit = {};
})(PS["Data.Unit"] = PS["Data.Unit"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Unit"] = $PS["Data.Unit"] || {};
  var exports = $PS["Data.Unit"];
  var $foreign = $PS["Data.Unit"];
  exports["unit"] = $foreign.unit;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Functor"] = $PS["Data.Functor"] || {};
  var exports = $PS["Data.Functor"];
  var $foreign = $PS["Data.Functor"];
  var Data_Function = $PS["Data.Function"];
  var Data_Unit = $PS["Data.Unit"];                
  var Functor = function (map) {
      this.map = map;
  };
  var map = function (dict) {
      return dict.map;
  };
  var $$void = function (dictFunctor) {
      return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
  };                                                                                             
  var functorArray = new Functor($foreign.arrayMap);
  exports["Functor"] = Functor;
  exports["map"] = map;
  exports["void"] = $$void;
  exports["functorArray"] = functorArray;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Control.Apply"] = $PS["Control.Apply"] || {};
  var exports = $PS["Control.Apply"];
  var Data_Functor = $PS["Data.Functor"];                
  var Apply = function (Functor0, apply) {
      this.Functor0 = Functor0;
      this.apply = apply;
  };                      
  var apply = function (dict) {
      return dict.apply;
  };
  var lift2 = function (dictApply) {
      return function (f) {
          return function (a) {
              return function (b) {
                  return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);
              };
          };
      };
  };
  exports["Apply"] = Apply;
  exports["apply"] = apply;
  exports["lift2"] = lift2;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Control.Applicative"] = $PS["Control.Applicative"] || {};
  var exports = $PS["Control.Applicative"];
  var Control_Apply = $PS["Control.Apply"];        
  var Applicative = function (Apply0, pure) {
      this.Apply0 = Apply0;
      this.pure = pure;
  };
  var pure = function (dict) {
      return dict.pure;
  };
  var liftA1 = function (dictApplicative) {
      return function (f) {
          return function (a) {
              return Control_Apply.apply(dictApplicative.Apply0())(pure(dictApplicative)(f))(a);
          };
      };
  };
  exports["Applicative"] = Applicative;
  exports["pure"] = pure;
  exports["liftA1"] = liftA1;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Control.Bind"] = $PS["Control.Bind"] || {};
  var exports = $PS["Control.Bind"];
  var Bind = function (Apply0, bind) {
      this.Apply0 = Apply0;
      this.bind = bind;
  };                     
  var bind = function (dict) {
      return dict.bind;
  };
  exports["Bind"] = Bind;
  exports["bind"] = bind;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Control.Semigroupoid"] = $PS["Control.Semigroupoid"] || {};
  var exports = $PS["Control.Semigroupoid"];
  var Semigroupoid = function (compose) {
      this.compose = compose;
  };
  var semigroupoidFn = new Semigroupoid(function (f) {
      return function (g) {
          return function (x) {
              return f(g(x));
          };
      };
  });
  exports["semigroupoidFn"] = semigroupoidFn;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Control.Category"] = $PS["Control.Category"] || {};
  var exports = $PS["Control.Category"];
  var Control_Semigroupoid = $PS["Control.Semigroupoid"];                
  var Category = function (Semigroupoid0, identity) {
      this.Semigroupoid0 = Semigroupoid0;
      this.identity = identity;
  };
  var identity = function (dict) {
      return dict.identity;
  };
  var categoryFn = new Category(function () {
      return Control_Semigroupoid.semigroupoidFn;
  }, function (x) {
      return x;
  });
  exports["identity"] = identity;
  exports["categoryFn"] = categoryFn;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Control.Lazy"] = $PS["Control.Lazy"] || {};
  var exports = $PS["Control.Lazy"];               
  var Lazy = function (defer) {
      this.defer = defer;
  }; 
  var defer = function (dict) {
      return dict.defer;
  };
  exports["defer"] = defer;
  exports["Lazy"] = Lazy;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Control.Monad"] = $PS["Control.Monad"] || {};
  var exports = $PS["Control.Monad"];
  var Control_Applicative = $PS["Control.Applicative"];
  var Control_Bind = $PS["Control.Bind"];                
  var Monad = function (Applicative0, Bind1) {
      this.Applicative0 = Applicative0;
      this.Bind1 = Bind1;
  };
  var ap = function (dictMonad) {
      return function (f) {
          return function (a) {
              return Control_Bind.bind(dictMonad.Bind1())(f)(function (v) {
                  return Control_Bind.bind(dictMonad.Bind1())(a)(function (v1) {
                      return Control_Applicative.pure(dictMonad.Applicative0())(v(v1));
                  });
              });
          };
      };
  };
  exports["Monad"] = Monad;
  exports["ap"] = ap;
})(PS);
(function(exports) {
  "use strict";

  exports.filter = function (f) {
    return function (xs) {
      return xs.filter(f);
    };
  };
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Array"] = $PS["Data.Array"] || {};
  var exports = $PS["Data.Array"];
  var $foreign = $PS["Data.Array"];
  exports["filter"] = $foreign.filter;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Boolean"] = $PS["Data.Boolean"] || {};
  var exports = $PS["Data.Boolean"];
  var otherwise = true;
  exports["otherwise"] = otherwise;
})(PS);
(function(exports) {
  "use strict";

  exports.topInt = 2147483647;
  exports.bottomInt = -2147483648;

  exports.topChar = String.fromCharCode(65535);
  exports.bottomChar = String.fromCharCode(0);
})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
(function(exports) {
  "use strict";

  var unsafeCompareImpl = function (lt) {
    return function (eq) {
      return function (gt) {
        return function (x) {
          return function (y) {
            return x < y ? lt : x === y ? eq : gt;
          };
        };
      };
    };
  };                                         
  exports.ordIntImpl = unsafeCompareImpl;   
  exports.ordCharImpl = unsafeCompareImpl;
})(PS["Data.Ord"] = PS["Data.Ord"] || {});
(function(exports) {
  "use strict";

  var refEq = function (r1) {
    return function (r2) {
      return r1 === r2;
    };
  };

  exports.eqBooleanImpl = refEq;
  exports.eqIntImpl = refEq;
  exports.eqNumberImpl = refEq;
  exports.eqCharImpl = refEq;
})(PS["Data.Eq"] = PS["Data.Eq"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Eq"] = $PS["Data.Eq"] || {};
  var exports = $PS["Data.Eq"];
  var $foreign = $PS["Data.Eq"];
  var Eq = function (eq) {
      this.eq = eq;
  };
  var eqNumber = new Eq($foreign.eqNumberImpl);
  var eqInt = new Eq($foreign.eqIntImpl);
  var eqChar = new Eq($foreign.eqCharImpl);
  var eqBoolean = new Eq($foreign.eqBooleanImpl);
  var eq = function (dict) {
      return dict.eq;
  };
  var notEq = function (dictEq) {
      return function (x) {
          return function (y) {
              return eq(eqBoolean)(eq(dictEq)(x)(y))(false);
          };
      };
  };
  exports["Eq"] = Eq;
  exports["notEq"] = notEq;
  exports["eqInt"] = eqInt;
  exports["eqNumber"] = eqNumber;
  exports["eqChar"] = eqChar;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Ordering"] = $PS["Data.Ordering"] || {};
  var exports = $PS["Data.Ordering"];              
  var LT = (function () {
      function LT() {

      };
      LT.value = new LT();
      return LT;
  })();
  var GT = (function () {
      function GT() {

      };
      GT.value = new GT();
      return GT;
  })();
  var EQ = (function () {
      function EQ() {

      };
      EQ.value = new EQ();
      return EQ;
  })();
  exports["LT"] = LT;
  exports["GT"] = GT;
  exports["EQ"] = EQ;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Ord"] = $PS["Data.Ord"] || {};
  var exports = $PS["Data.Ord"];
  var $foreign = $PS["Data.Ord"];
  var Data_Eq = $PS["Data.Eq"];
  var Data_Ordering = $PS["Data.Ordering"];
  var Ord = function (Eq0, compare) {
      this.Eq0 = Eq0;
      this.compare = compare;
  };                                                                                                 
  var ordInt = new Ord(function () {
      return Data_Eq.eqInt;
  }, $foreign.ordIntImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
  var ordChar = new Ord(function () {
      return Data_Eq.eqChar;
  }, $foreign.ordCharImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
  var compare = function (dict) {
      return dict.compare;
  };
  exports["Ord"] = Ord;
  exports["compare"] = compare;
  exports["ordInt"] = ordInt;
  exports["ordChar"] = ordChar;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Bounded"] = $PS["Data.Bounded"] || {};
  var exports = $PS["Data.Bounded"];
  var $foreign = $PS["Data.Bounded"];
  var Data_Ord = $PS["Data.Ord"];                  
  var Bounded = function (Ord0, bottom, top) {
      this.Ord0 = Ord0;
      this.bottom = bottom;
      this.top = top;
  };
  var top = function (dict) {
      return dict.top;
  };                                            
  var boundedInt = new Bounded(function () {
      return Data_Ord.ordInt;
  }, $foreign.bottomInt, $foreign.topInt);
  var boundedChar = new Bounded(function () {
      return Data_Ord.ordChar;
  }, $foreign.bottomChar, $foreign.topChar);
  var bottom = function (dict) {
      return dict.bottom;
  };
  exports["Bounded"] = Bounded;
  exports["bottom"] = bottom;
  exports["top"] = top;
  exports["boundedInt"] = boundedInt;
  exports["boundedChar"] = boundedChar;
})(PS);
(function(exports) {
  "use strict";

  exports.intSub = function (x) {
    return function (y) {
      /* jshint bitwise: false */
      return x - y | 0;
    };
  };

  exports.numSub = function (n1) {
    return function (n2) {
      return n1 - n2;
    };
  };
})(PS["Data.Ring"] = PS["Data.Ring"] || {});
(function(exports) {
  "use strict";

  exports.intAdd = function (x) {
    return function (y) {
      /* jshint bitwise: false */
      return x + y | 0;
    };
  };

  exports.intMul = function (x) {
    return function (y) {
      /* jshint bitwise: false */
      return x * y | 0;
    };
  };

  exports.numAdd = function (n1) {
    return function (n2) {
      return n1 + n2;
    };
  };

  exports.numMul = function (n1) {
    return function (n2) {
      return n1 * n2;
    };
  };
})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Semiring"] = $PS["Data.Semiring"] || {};
  var exports = $PS["Data.Semiring"];
  var $foreign = $PS["Data.Semiring"];
  var Semiring = function (add, mul, one, zero) {
      this.add = add;
      this.mul = mul;
      this.one = one;
      this.zero = zero;
  };
  var zero = function (dict) {
      return dict.zero;
  }; 
  var semiringNumber = new Semiring($foreign.numAdd, $foreign.numMul, 1.0, 0.0);
  var semiringInt = new Semiring($foreign.intAdd, $foreign.intMul, 1, 0);
  var one = function (dict) {
      return dict.one;
  };
  var mul = function (dict) {
      return dict.mul;
  };
  var add = function (dict) {
      return dict.add;
  };
  exports["Semiring"] = Semiring;
  exports["add"] = add;
  exports["zero"] = zero;
  exports["mul"] = mul;
  exports["one"] = one;
  exports["semiringInt"] = semiringInt;
  exports["semiringNumber"] = semiringNumber;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Ring"] = $PS["Data.Ring"] || {};
  var exports = $PS["Data.Ring"];
  var $foreign = $PS["Data.Ring"];
  var Data_Semiring = $PS["Data.Semiring"];
  var Ring = function (Semiring0, sub) {
      this.Semiring0 = Semiring0;
      this.sub = sub;
  };
  var sub = function (dict) {
      return dict.sub;
  };
  var ringNumber = new Ring(function () {
      return Data_Semiring.semiringNumber;
  }, $foreign.numSub);
  var ringInt = new Ring(function () {
      return Data_Semiring.semiringInt;
  }, $foreign.intSub);
  var negate = function (dictRing) {
      return function (a) {
          return sub(dictRing)(Data_Semiring.zero(dictRing.Semiring0()))(a);
      };
  };
  exports["Ring"] = Ring;
  exports["sub"] = sub;
  exports["negate"] = negate;
  exports["ringInt"] = ringInt;
  exports["ringNumber"] = ringNumber;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.CommutativeRing"] = $PS["Data.CommutativeRing"] || {};
  var exports = $PS["Data.CommutativeRing"];
  var Data_Ring = $PS["Data.Ring"];
  var CommutativeRing = function (Ring0) {
      this.Ring0 = Ring0;
  }; 
  var commutativeRingInt = new CommutativeRing(function () {
      return Data_Ring.ringInt;
  });
  exports["commutativeRingInt"] = commutativeRingInt;
})(PS);
(function(exports) {
  "use strict";

  exports.toCharCode = function (c) {
    return c.charCodeAt(0);
  };

  exports.fromCharCode = function (c) {
    return String.fromCharCode(c);
  };
})(PS["Data.Enum"] = PS["Data.Enum"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Maybe"] = $PS["Data.Maybe"] || {};
  var exports = $PS["Data.Maybe"];
  var Control_Category = $PS["Control.Category"];
  var Data_Function = $PS["Data.Function"];        
  var Nothing = (function () {
      function Nothing() {

      };
      Nothing.value = new Nothing();
      return Nothing;
  })();
  var Just = (function () {
      function Just(value0) {
          this.value0 = value0;
      };
      Just.create = function (value0) {
          return new Just(value0);
      };
      return Just;
  })();
  var maybe = function (v) {
      return function (v1) {
          return function (v2) {
              if (v2 instanceof Nothing) {
                  return v;
              };
              if (v2 instanceof Just) {
                  return v1(v2.value0);
              };
              throw new Error("Failed pattern match at Data.Maybe (line 217, column 1 - line 217, column 51): " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
          };
      };
  };
  var isNothing = maybe(true)(Data_Function["const"](false));
  var fromMaybe = function (a) {
      return maybe(a)(Control_Category.identity(Control_Category.categoryFn));
  };
  var fromJust = function (dictPartial) {
      return function (v) {
          if (v instanceof Just) {
              return v.value0;
          };
          throw new Error("Failed pattern match at Data.Maybe (line 268, column 1 - line 268, column 46): " + [ v.constructor.name ]);
      };
  };
  exports["Nothing"] = Nothing;
  exports["Just"] = Just;
  exports["maybe"] = maybe;
  exports["fromMaybe"] = fromMaybe;
  exports["isNothing"] = isNothing;
  exports["fromJust"] = fromJust;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Enum"] = $PS["Data.Enum"] || {};
  var exports = $PS["Data.Enum"];
  var $foreign = $PS["Data.Enum"];
  var Data_Bounded = $PS["Data.Bounded"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Ord = $PS["Data.Ord"];
  var Enum = function (Ord0, pred, succ) {
      this.Ord0 = Ord0;
      this.pred = pred;
      this.succ = succ;
  };
  var BoundedEnum = function (Bounded0, Enum1, cardinality, fromEnum, toEnum) {
      this.Bounded0 = Bounded0;
      this.Enum1 = Enum1;
      this.cardinality = cardinality;
      this.fromEnum = fromEnum;
      this.toEnum = toEnum;
  };
  var toEnum = function (dict) {
      return dict.toEnum;
  };              
  var fromEnum = function (dict) {
      return dict.fromEnum;
  };
  var toEnumWithDefaults = function (dictBoundedEnum) {
      return function (low) {
          return function (high) {
              return function (x) {
                  var v = toEnum(dictBoundedEnum)(x);
                  if (v instanceof Data_Maybe.Just) {
                      return v.value0;
                  };
                  if (v instanceof Data_Maybe.Nothing) {
                      var $54 = x < fromEnum(dictBoundedEnum)(Data_Bounded.bottom(dictBoundedEnum.Bounded0()));
                      if ($54) {
                          return low;
                      };
                      return high;
                  };
                  throw new Error("Failed pattern match at Data.Enum (line 158, column 33 - line 160, column 62): " + [ v.constructor.name ]);
              };
          };
      };
  };
  var defaultSucc = function (toEnum$prime) {
      return function (fromEnum$prime) {
          return function (a) {
              return toEnum$prime(fromEnum$prime(a) + 1 | 0);
          };
      };
  };
  var defaultPred = function (toEnum$prime) {
      return function (fromEnum$prime) {
          return function (a) {
              return toEnum$prime(fromEnum$prime(a) - 1 | 0);
          };
      };
  };
  var charToEnum = function (v) {
      if (v >= Data_Bounded.bottom(Data_Bounded.boundedInt) && v <= Data_Bounded.top(Data_Bounded.boundedInt)) {
          return new Data_Maybe.Just($foreign.fromCharCode(v));
      };
      return Data_Maybe.Nothing.value;
  };
  var enumChar = new Enum(function () {
      return Data_Ord.ordChar;
  }, defaultPred(charToEnum)($foreign.toCharCode), defaultSucc(charToEnum)($foreign.toCharCode));
  var boundedEnumChar = new BoundedEnum(function () {
      return Data_Bounded.boundedChar;
  }, function () {
      return enumChar;
  }, $foreign.toCharCode(Data_Bounded.top(Data_Bounded.boundedChar)) - $foreign.toCharCode(Data_Bounded.bottom(Data_Bounded.boundedChar)) | 0, $foreign.toCharCode, charToEnum);
  exports["Enum"] = Enum;
  exports["BoundedEnum"] = BoundedEnum;
  exports["toEnum"] = toEnum;
  exports["fromEnum"] = fromEnum;
  exports["toEnumWithDefaults"] = toEnumWithDefaults;
  exports["defaultSucc"] = defaultSucc;
  exports["defaultPred"] = defaultPred;
  exports["boundedEnumChar"] = boundedEnumChar;
})(PS);
(function(exports) {
  "use strict";

  exports.intDegree = function (x) {
    return Math.min(Math.abs(x), 2147483647);
  };

  // See the Euclidean definition in
  // https://en.m.wikipedia.org/wiki/Modulo_operation.
  exports.intDiv = function (x) {
    return function (y) {
      if (y === 0) return 0;
      return y > 0 ? Math.floor(x / y) : -Math.floor(x / -y);
    };
  };

  exports.intMod = function (x) {
    return function (y) {
      if (y === 0) return 0;
      var yy = Math.abs(y);
      return ((x % yy) + yy) % yy;
    };
  };
})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.EuclideanRing"] = $PS["Data.EuclideanRing"] || {};
  var exports = $PS["Data.EuclideanRing"];
  var $foreign = $PS["Data.EuclideanRing"];
  var Data_CommutativeRing = $PS["Data.CommutativeRing"];  
  var EuclideanRing = function (CommutativeRing0, degree, div, mod) {
      this.CommutativeRing0 = CommutativeRing0;
      this.degree = degree;
      this.div = div;
      this.mod = mod;
  };
  var mod = function (dict) {
      return dict.mod;
  }; 
  var euclideanRingInt = new EuclideanRing(function () {
      return Data_CommutativeRing.commutativeRingInt;
  }, $foreign.intDegree, $foreign.intDiv, $foreign.intMod);
  var div = function (dict) {
      return dict.div;
  };
  exports["div"] = div;
  exports["mod"] = mod;
  exports["euclideanRingInt"] = euclideanRingInt;
})(PS);
(function(exports) {
  "use strict";

  exports.foldrArray = function (f) {
    return function (init) {
      return function (xs) {
        var acc = init;
        var len = xs.length;
        for (var i = len - 1; i >= 0; i--) {
          acc = f(xs[i])(acc);
        }
        return acc;
      };
    };
  };

  exports.foldlArray = function (f) {
    return function (init) {
      return function (xs) {
        var acc = init;
        var len = xs.length;
        for (var i = 0; i < len; i++) {
          acc = f(acc)(xs[i]);
        }
        return acc;
      };
    };
  };
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Semigroup"] = $PS["Data.Semigroup"] || {};
  var exports = $PS["Data.Semigroup"];
  var Data_Unit = $PS["Data.Unit"];
  var Semigroup = function (append) {
      this.append = append;
  }; 
  var semigroupUnit = new Semigroup(function (v) {
      return function (v1) {
          return Data_Unit.unit;
      };
  });
  var append = function (dict) {
      return dict.append;
  };
  exports["Semigroup"] = Semigroup;
  exports["append"] = append;
  exports["semigroupUnit"] = semigroupUnit;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Monoid"] = $PS["Data.Monoid"] || {};
  var exports = $PS["Data.Monoid"];
  var Data_Semigroup = $PS["Data.Semigroup"];
  var Data_Unit = $PS["Data.Unit"];
  var Monoid = function (Semigroup0, mempty) {
      this.Semigroup0 = Semigroup0;
      this.mempty = mempty;
  };
  var monoidUnit = new Monoid(function () {
      return Data_Semigroup.semigroupUnit;
  }, Data_Unit.unit);
  var mempty = function (dict) {
      return dict.mempty;
  };
  exports["Monoid"] = Monoid;
  exports["mempty"] = mempty;
  exports["monoidUnit"] = monoidUnit;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Foldable"] = $PS["Data.Foldable"] || {};
  var exports = $PS["Data.Foldable"];
  var $foreign = $PS["Data.Foldable"];
  var Data_Monoid = $PS["Data.Monoid"];
  var Data_Semigroup = $PS["Data.Semigroup"];      
  var Foldable = function (foldMap, foldl, foldr) {
      this.foldMap = foldMap;
      this.foldl = foldl;
      this.foldr = foldr;
  };
  var foldr = function (dict) {
      return dict.foldr;
  };
  var foldl = function (dict) {
      return dict.foldl;
  }; 
  var foldMapDefaultR = function (dictFoldable) {
      return function (dictMonoid) {
          return function (f) {
              return foldr(dictFoldable)(function (x) {
                  return function (acc) {
                      return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
                  };
              })(Data_Monoid.mempty(dictMonoid));
          };
      };
  };
  var foldableArray = new Foldable(function (dictMonoid) {
      return foldMapDefaultR(foldableArray)(dictMonoid);
  }, $foreign.foldlArray, $foreign.foldrArray);
  var foldMap = function (dict) {
      return dict.foldMap;
  };
  exports["Foldable"] = Foldable;
  exports["foldr"] = foldr;
  exports["foldl"] = foldl;
  exports["foldMap"] = foldMap;
  exports["foldableArray"] = foldableArray;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.FoldableWithIndex"] = $PS["Data.FoldableWithIndex"] || {};
  var exports = $PS["Data.FoldableWithIndex"];
  var FoldableWithIndex = function (Foldable0, foldMapWithIndex, foldlWithIndex, foldrWithIndex) {
      this.Foldable0 = Foldable0;
      this.foldMapWithIndex = foldMapWithIndex;
      this.foldlWithIndex = foldlWithIndex;
      this.foldrWithIndex = foldrWithIndex;
  };
  var foldrWithIndex = function (dict) {
      return dict.foldrWithIndex;
  };
  exports["FoldableWithIndex"] = FoldableWithIndex;
  exports["foldrWithIndex"] = foldrWithIndex;
})(PS);
(function(exports) {
  "use strict";

  exports.defer = function (thunk) {
    var v = null;
    return function() {
      if (thunk === undefined) return v;

      v = thunk();
      thunk = undefined; // eslint-disable-line no-param-reassign
      return v;
    };
  };

  exports.force = function (l) {
    return l();
  };
})(PS["Data.Lazy"] = PS["Data.Lazy"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Lazy"] = $PS["Data.Lazy"] || {};
  var exports = $PS["Data.Lazy"];
  var $foreign = $PS["Data.Lazy"];
  var Data_Functor = $PS["Data.Functor"];
  var functorLazy = new Data_Functor.Functor(function (f) {
      return function (l) {
          return $foreign.defer(function (v) {
              return f($foreign.force(l));
          });
      };
  });
  exports["functorLazy"] = functorLazy;
  exports["defer"] = $foreign.defer;
  exports["force"] = $foreign.force;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Newtype"] = $PS["Data.Newtype"] || {};
  var exports = $PS["Data.Newtype"];                                   
  var Newtype = function (unwrap, wrap) {
      this.unwrap = unwrap;
      this.wrap = wrap;
  };
  var unwrap = function (dict) {
      return dict.unwrap;
  };
  exports["unwrap"] = unwrap;
  exports["Newtype"] = Newtype;
})(PS);
(function(exports) {
  "use strict";

  exports.unfoldrArrayImpl = function (isNothing) {
    return function (fromJust) {
      return function (fst) {
        return function (snd) {
          return function (f) {
            return function (b) {
              var result = [];
              var value = b;
              while (true) { // eslint-disable-line no-constant-condition
                var maybe = f(value);
                if (isNothing(maybe)) return result;
                var tuple = fromJust(maybe);
                result.push(fst(tuple));
                value = snd(tuple);
              }
            };
          };
        };
      };
    };
  };
})(PS["Data.Unfoldable"] = PS["Data.Unfoldable"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Tuple"] = $PS["Data.Tuple"] || {};
  var exports = $PS["Data.Tuple"];                         
  var Tuple = (function () {
      function Tuple(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      Tuple.create = function (value0) {
          return function (value1) {
              return new Tuple(value0, value1);
          };
      };
      return Tuple;
  })();
  var uncurry = function (f) {
      return function (v) {
          return f(v.value0)(v.value1);
      };
  };
  var snd = function (v) {
      return v.value1;
  };                                                                                                    
  var fst = function (v) {
      return v.value0;
  };
  exports["Tuple"] = Tuple;
  exports["fst"] = fst;
  exports["snd"] = snd;
  exports["uncurry"] = uncurry;
})(PS);
(function(exports) {
  "use strict";

  exports.unfoldr1ArrayImpl = function (isNothing) {
    return function (fromJust) {
      return function (fst) {
        return function (snd) {
          return function (f) {
            return function (b) {
              var result = [];
              var value = b;
              while (true) { // eslint-disable-line no-constant-condition
                var tuple = f(value);
                result.push(fst(tuple));
                var maybe = snd(tuple);
                if (isNothing(maybe)) return result;
                value = fromJust(maybe);
              }
            };
          };
        };
      };
    };
  };
})(PS["Data.Unfoldable1"] = PS["Data.Unfoldable1"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Unfoldable1"] = $PS["Data.Unfoldable1"] || {};
  var exports = $PS["Data.Unfoldable1"];
  var $foreign = $PS["Data.Unfoldable1"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Tuple = $PS["Data.Tuple"];                
  var Unfoldable1 = function (unfoldr1) {
      this.unfoldr1 = unfoldr1;
  };
  var unfoldable1Array = new Unfoldable1($foreign.unfoldr1ArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
  exports["Unfoldable1"] = Unfoldable1;
  exports["unfoldable1Array"] = unfoldable1Array;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Unfoldable"] = $PS["Data.Unfoldable"] || {};
  var exports = $PS["Data.Unfoldable"];
  var $foreign = $PS["Data.Unfoldable"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Tuple = $PS["Data.Tuple"];
  var Data_Unfoldable1 = $PS["Data.Unfoldable1"];  
  var Unfoldable = function (Unfoldable10, unfoldr) {
      this.Unfoldable10 = Unfoldable10;
      this.unfoldr = unfoldr;
  };
  var unfoldr = function (dict) {
      return dict.unfoldr;
  };
  var unfoldableArray = new Unfoldable(function () {
      return Data_Unfoldable1.unfoldable1Array;
  }, $foreign.unfoldrArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
  exports["Unfoldable"] = Unfoldable;
  exports["unfoldr"] = unfoldr;
  exports["unfoldableArray"] = unfoldableArray;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.List.Lazy.Types"] = $PS["Data.List.Lazy.Types"] || {};
  var exports = $PS["Data.List.Lazy.Types"];
  var Control_Lazy = $PS["Control.Lazy"];
  var Data_Foldable = $PS["Data.Foldable"];
  var Data_Function = $PS["Data.Function"];
  var Data_Lazy = $PS["Data.Lazy"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Monoid = $PS["Data.Monoid"];
  var Data_Newtype = $PS["Data.Newtype"];
  var Data_Semigroup = $PS["Data.Semigroup"];
  var Data_Unfoldable = $PS["Data.Unfoldable"];
  var Data_Unfoldable1 = $PS["Data.Unfoldable1"];                
  var List = function (x) {
      return x;
  };
  var Nil = (function () {
      function Nil() {

      };
      Nil.value = new Nil();
      return Nil;
  })();
  var Cons = (function () {
      function Cons(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      Cons.create = function (value0) {
          return function (value1) {
              return new Cons(value0, value1);
          };
      };
      return Cons;
  })();
  var nil = List(Data_Lazy.defer(function (v) {
      return Nil.value;
  }));             
  var newtypeList = new Data_Newtype.Newtype(function (n) {
      return n;
  }, List);
  var step = (function () {
      var $215 = Data_Newtype.unwrap(newtypeList);
      return function ($216) {
          return Data_Lazy.force($215($216));
      };
  })();   
  var lazyList = new Control_Lazy.Lazy(function (f) {
      return List(Data_Lazy.defer(function ($217) {
          return step(f($217));
      }));
  });
  var cons = function (x) {
      return function (xs) {
          return List(Data_Lazy.defer(function (v) {
              return new Cons(x, xs);
          }));
      };
  };
  var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
      return function (f) {
          return Data_Foldable.foldl(foldableList)(function (b) {
              return function (a) {
                  return Data_Semigroup.append(dictMonoid.Semigroup0())(b)(f(a));
              };
          })(Data_Monoid.mempty(dictMonoid));
      };
  }, function (op) {
      var go = function ($copy_b) {
          return function ($copy_xs) {
              var $tco_var_b = $copy_b;
              var $tco_done = false;
              var $tco_result;
              function $tco_loop(b, xs) {
                  var v = step(xs);
                  if (v instanceof Nil) {
                      $tco_done = true;
                      return b;
                  };
                  if (v instanceof Cons) {
                      $tco_var_b = op(b)(v.value0);
                      $copy_xs = v.value1;
                      return;
                  };
                  throw new Error("Failed pattern match at Data.List.Lazy.Types (line 122, column 7 - line 124, column 40): " + [ v.constructor.name ]);
              };
              while (!$tco_done) {
                  $tco_result = $tco_loop($tco_var_b, $copy_xs);
              };
              return $tco_result;
          };
      };
      return go;
  }, function (op) {
      return function (z) {
          return function (xs) {
              var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(cons))(nil);
              return Data_Foldable.foldl(foldableList)(Data_Function.flip(op))(z)(rev(xs));
          };
      };
  });
  var unfoldable1List = new Data_Unfoldable1.Unfoldable1((function () {
      var go = function (f) {
          return function (b) {
              return Control_Lazy.defer(lazyList)(function (v) {
                  var v1 = f(b);
                  if (v1.value1 instanceof Data_Maybe.Just) {
                      return cons(v1.value0)(go(f)(v1.value1.value0));
                  };
                  if (v1.value1 instanceof Data_Maybe.Nothing) {
                      return cons(v1.value0)(nil);
                  };
                  throw new Error("Failed pattern match at Data.List.Lazy.Types (line 146, column 28 - line 148, column 33): " + [ v1.constructor.name ]);
              });
          };
      };
      return go;
  })());
  var unfoldableList = new Data_Unfoldable.Unfoldable(function () {
      return unfoldable1List;
  }, (function () {
      var go = function (f) {
          return function (b) {
              return Control_Lazy.defer(lazyList)(function (v) {
                  var v1 = f(b);
                  if (v1 instanceof Data_Maybe.Nothing) {
                      return nil;
                  };
                  if (v1 instanceof Data_Maybe.Just) {
                      return cons(v1.value0.value0)(go(f)(v1.value0.value1));
                  };
                  throw new Error("Failed pattern match at Data.List.Lazy.Types (line 152, column 28 - line 154, column 39): " + [ v1.constructor.name ]);
              });
          };
      };
      return go;
  })());
  exports["List"] = List;
  exports["Nil"] = Nil;
  exports["Cons"] = Cons;
  exports["step"] = step;
  exports["newtypeList"] = newtypeList;
  exports["foldableList"] = foldableList;
  exports["unfoldableList"] = unfoldableList;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.List.Lazy"] = $PS["Data.List.Lazy"] || {};
  var exports = $PS["Data.List.Lazy"];
  var Data_Boolean = $PS["Data.Boolean"];
  var Data_Functor = $PS["Data.Functor"];
  var Data_Lazy = $PS["Data.Lazy"];
  var Data_List_Lazy_Types = $PS["Data.List.Lazy.Types"];
  var Data_Newtype = $PS["Data.Newtype"];
  var filter = function (p) {
      var go = function ($copy_v) {
          var $tco_done = false;
          var $tco_result;
          function $tco_loop(v) {
              if (v instanceof Data_List_Lazy_Types.Nil) {
                  $tco_done = true;
                  return Data_List_Lazy_Types.Nil.value;
              };
              if (v instanceof Data_List_Lazy_Types.Cons) {
                  if (p(v.value0)) {
                      $tco_done = true;
                      return new Data_List_Lazy_Types.Cons(v.value0, filter(p)(v.value1));
                  };
                  if (Data_Boolean.otherwise) {
                      $copy_v = Data_List_Lazy_Types.step(v.value1);
                      return;
                  };
              };
              throw new Error("Failed pattern match at Data.List.Lazy (line 428, column 3 - line 428, column 15): " + [ v.constructor.name ]);
          };
          while (!$tco_done) {
              $tco_result = $tco_loop($copy_v);
          };
          return $tco_result;
      };
      var $266 = Data_Functor.map(Data_Lazy.functorLazy)(go);
      var $267 = Data_Newtype.unwrap(Data_List_Lazy_Types.newtypeList);
      return function ($268) {
          return Data_List_Lazy_Types.List($266($267($268)));
      };
  };
  exports["filter"] = filter;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.List.Types"] = $PS["Data.List.Types"] || {};
  var exports = $PS["Data.List.Types"];
  var Control_Applicative = $PS["Control.Applicative"];
  var Control_Apply = $PS["Control.Apply"];
  var Data_Foldable = $PS["Data.Foldable"];
  var Data_Function = $PS["Data.Function"];
  var Data_Functor = $PS["Data.Functor"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Monoid = $PS["Data.Monoid"];
  var Data_Semigroup = $PS["Data.Semigroup"];
  var Data_Unfoldable = $PS["Data.Unfoldable"];
  var Data_Unfoldable1 = $PS["Data.Unfoldable1"];                
  var Nil = (function () {
      function Nil() {

      };
      Nil.value = new Nil();
      return Nil;
  })();
  var Cons = (function () {
      function Cons(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      Cons.create = function (value0) {
          return function (value1) {
              return new Cons(value0, value1);
          };
      };
      return Cons;
  })();
  var listMap = function (f) {
      var chunkedRevMap = function ($copy_chunksAcc) {
          return function ($copy_v) {
              var $tco_var_chunksAcc = $copy_chunksAcc;
              var $tco_done = false;
              var $tco_result;
              function $tco_loop(chunksAcc, v) {
                  if (v instanceof Cons && (v.value1 instanceof Cons && v.value1.value1 instanceof Cons)) {
                      $tco_var_chunksAcc = new Cons(v, chunksAcc);
                      $copy_v = v.value1.value1.value1;
                      return;
                  };
                  var unrolledMap = function (v1) {
                      if (v1 instanceof Cons && (v1.value1 instanceof Cons && v1.value1.value1 instanceof Nil)) {
                          return new Cons(f(v1.value0), new Cons(f(v1.value1.value0), Nil.value));
                      };
                      if (v1 instanceof Cons && v1.value1 instanceof Nil) {
                          return new Cons(f(v1.value0), Nil.value);
                      };
                      return Nil.value;
                  };
                  var reverseUnrolledMap = function ($copy_v1) {
                      return function ($copy_acc) {
                          var $tco_var_v1 = $copy_v1;
                          var $tco_done = false;
                          var $tco_result;
                          function $tco_loop(v1, acc) {
                              if (v1 instanceof Cons && (v1.value0 instanceof Cons && (v1.value0.value1 instanceof Cons && v1.value0.value1.value1 instanceof Cons))) {
                                  $tco_var_v1 = v1.value1;
                                  $copy_acc = new Cons(f(v1.value0.value0), new Cons(f(v1.value0.value1.value0), new Cons(f(v1.value0.value1.value1.value0), acc)));
                                  return;
                              };
                              $tco_done = true;
                              return acc;
                          };
                          while (!$tco_done) {
                              $tco_result = $tco_loop($tco_var_v1, $copy_acc);
                          };
                          return $tco_result;
                      };
                  };
                  $tco_done = true;
                  return reverseUnrolledMap(chunksAcc)(unrolledMap(v));
              };
              while (!$tco_done) {
                  $tco_result = $tco_loop($tco_var_chunksAcc, $copy_v);
              };
              return $tco_result;
          };
      };
      return chunkedRevMap(Nil.value);
  };
  var functorList = new Data_Functor.Functor(listMap);                 
  var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
      return function (f) {
          return Data_Foldable.foldl(foldableList)(function (acc) {
              var $202 = Data_Semigroup.append(dictMonoid.Semigroup0())(acc);
              return function ($203) {
                  return $202(f($203));
              };
          })(Data_Monoid.mempty(dictMonoid));
      };
  }, function (f) {
      var go = function ($copy_b) {
          return function ($copy_v) {
              var $tco_var_b = $copy_b;
              var $tco_done = false;
              var $tco_result;
              function $tco_loop(b, v) {
                  if (v instanceof Nil) {
                      $tco_done = true;
                      return b;
                  };
                  if (v instanceof Cons) {
                      $tco_var_b = f(b)(v.value0);
                      $copy_v = v.value1;
                      return;
                  };
                  throw new Error("Failed pattern match at Data.List.Types (line 109, column 12 - line 111, column 30): " + [ v.constructor.name ]);
              };
              while (!$tco_done) {
                  $tco_result = $tco_loop($tco_var_b, $copy_v);
              };
              return $tco_result;
          };
      };
      return go;
  }, function (f) {
      return function (b) {
          var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value);
          var $204 = Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b);
          return function ($205) {
              return $204(rev($205));
          };
      };
  });
  var semigroupList = new Data_Semigroup.Semigroup(function (xs) {
      return function (ys) {
          return Data_Foldable.foldr(foldableList)(Cons.create)(ys)(xs);
      };
  });
  var unfoldable1List = new Data_Unfoldable1.Unfoldable1(function (f) {
      return function (b) {
          var go = function ($copy_source) {
              return function ($copy_memo) {
                  var $tco_var_source = $copy_source;
                  var $tco_done = false;
                  var $tco_result;
                  function $tco_loop(source, memo) {
                      var v = f(source);
                      if (v.value1 instanceof Data_Maybe.Just) {
                          $tco_var_source = v.value1.value0;
                          $copy_memo = new Cons(v.value0, memo);
                          return;
                      };
                      if (v.value1 instanceof Data_Maybe.Nothing) {
                          $tco_done = true;
                          return Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value)(new Cons(v.value0, memo));
                      };
                      throw new Error("Failed pattern match at Data.List.Types (line 133, column 22 - line 135, column 61): " + [ v.constructor.name ]);
                  };
                  while (!$tco_done) {
                      $tco_result = $tco_loop($tco_var_source, $copy_memo);
                  };
                  return $tco_result;
              };
          };
          return go(b)(Nil.value);
      };
  });
  var unfoldableList = new Data_Unfoldable.Unfoldable(function () {
      return unfoldable1List;
  }, function (f) {
      return function (b) {
          var go = function ($copy_source) {
              return function ($copy_memo) {
                  var $tco_var_source = $copy_source;
                  var $tco_done = false;
                  var $tco_result;
                  function $tco_loop(source, memo) {
                      var v = f(source);
                      if (v instanceof Data_Maybe.Nothing) {
                          $tco_done = true;
                          return Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value)(memo);
                      };
                      if (v instanceof Data_Maybe.Just) {
                          $tco_var_source = v.value0.value1;
                          $copy_memo = new Cons(v.value0.value0, memo);
                          return;
                      };
                      throw new Error("Failed pattern match at Data.List.Types (line 140, column 22 - line 142, column 52): " + [ v.constructor.name ]);
                  };
                  while (!$tco_done) {
                      $tco_result = $tco_loop($tco_var_source, $copy_memo);
                  };
                  return $tco_result;
              };
          };
          return go(b)(Nil.value);
      };
  });
  var applyList = new Control_Apply.Apply(function () {
      return functorList;
  }, function (v) {
      return function (v1) {
          if (v instanceof Nil) {
              return Nil.value;
          };
          if (v instanceof Cons) {
              return Data_Semigroup.append(semigroupList)(Data_Functor.map(functorList)(v.value0)(v1))(Control_Apply.apply(applyList)(v.value1)(v1));
          };
          throw new Error("Failed pattern match at Data.List.Types (line 155, column 1 - line 157, column 48): " + [ v.constructor.name, v1.constructor.name ]);
      };
  });
  var applicativeList = new Control_Applicative.Applicative(function () {
      return applyList;
  }, function (a) {
      return new Cons(a, Nil.value);
  });
  exports["Nil"] = Nil;
  exports["Cons"] = Cons;
  exports["semigroupList"] = semigroupList;
  exports["foldableList"] = foldableList;
  exports["unfoldableList"] = unfoldableList;
  exports["applicativeList"] = applicativeList;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Map.Internal"] = $PS["Data.Map.Internal"] || {};
  var exports = $PS["Data.Map.Internal"];
  var Control_Applicative = $PS["Control.Applicative"];
  var Control_Category = $PS["Control.Category"];
  var Data_Foldable = $PS["Data.Foldable"];
  var Data_FoldableWithIndex = $PS["Data.FoldableWithIndex"];
  var Data_Function = $PS["Data.Function"];
  var Data_List_Lazy = $PS["Data.List.Lazy"];
  var Data_List_Lazy_Types = $PS["Data.List.Lazy.Types"];
  var Data_List_Types = $PS["Data.List.Types"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Ord = $PS["Data.Ord"];
  var Data_Ordering = $PS["Data.Ordering"];
  var Data_Semigroup = $PS["Data.Semigroup"];
  var Data_Tuple = $PS["Data.Tuple"];
  var Data_Unfoldable = $PS["Data.Unfoldable"];                
  var Leaf = (function () {
      function Leaf() {

      };
      Leaf.value = new Leaf();
      return Leaf;
  })();
  var Two = (function () {
      function Two(value0, value1, value2, value3) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
          this.value3 = value3;
      };
      Two.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return function (value3) {
                      return new Two(value0, value1, value2, value3);
                  };
              };
          };
      };
      return Two;
  })();
  var Three = (function () {
      function Three(value0, value1, value2, value3, value4, value5, value6) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
          this.value3 = value3;
          this.value4 = value4;
          this.value5 = value5;
          this.value6 = value6;
      };
      Three.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return function (value3) {
                      return function (value4) {
                          return function (value5) {
                              return function (value6) {
                                  return new Three(value0, value1, value2, value3, value4, value5, value6);
                              };
                          };
                      };
                  };
              };
          };
      };
      return Three;
  })();
  var TwoLeft = (function () {
      function TwoLeft(value0, value1, value2) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
      };
      TwoLeft.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return new TwoLeft(value0, value1, value2);
              };
          };
      };
      return TwoLeft;
  })();
  var TwoRight = (function () {
      function TwoRight(value0, value1, value2) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
      };
      TwoRight.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return new TwoRight(value0, value1, value2);
              };
          };
      };
      return TwoRight;
  })();
  var ThreeLeft = (function () {
      function ThreeLeft(value0, value1, value2, value3, value4, value5) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
          this.value3 = value3;
          this.value4 = value4;
          this.value5 = value5;
      };
      ThreeLeft.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return function (value3) {
                      return function (value4) {
                          return function (value5) {
                              return new ThreeLeft(value0, value1, value2, value3, value4, value5);
                          };
                      };
                  };
              };
          };
      };
      return ThreeLeft;
  })();
  var ThreeMiddle = (function () {
      function ThreeMiddle(value0, value1, value2, value3, value4, value5) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
          this.value3 = value3;
          this.value4 = value4;
          this.value5 = value5;
      };
      ThreeMiddle.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return function (value3) {
                      return function (value4) {
                          return function (value5) {
                              return new ThreeMiddle(value0, value1, value2, value3, value4, value5);
                          };
                      };
                  };
              };
          };
      };
      return ThreeMiddle;
  })();
  var ThreeRight = (function () {
      function ThreeRight(value0, value1, value2, value3, value4, value5) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
          this.value3 = value3;
          this.value4 = value4;
          this.value5 = value5;
      };
      ThreeRight.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return function (value3) {
                      return function (value4) {
                          return function (value5) {
                              return new ThreeRight(value0, value1, value2, value3, value4, value5);
                          };
                      };
                  };
              };
          };
      };
      return ThreeRight;
  })();
  var KickUp = (function () {
      function KickUp(value0, value1, value2, value3) {
          this.value0 = value0;
          this.value1 = value1;
          this.value2 = value2;
          this.value3 = value3;
      };
      KickUp.create = function (value0) {
          return function (value1) {
              return function (value2) {
                  return function (value3) {
                      return new KickUp(value0, value1, value2, value3);
                  };
              };
          };
      };
      return KickUp;
  })();
  var values = function (v) {
      if (v instanceof Leaf) {
          return Data_List_Types.Nil.value;
      };
      if (v instanceof Two) {
          return Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value2))(values(v.value3)));
      };
      if (v instanceof Three) {
          return Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value2))(Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value3))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value5))(values(v.value6)))));
      };
      throw new Error("Failed pattern match at Data.Map.Internal (line 612, column 1 - line 612, column 40): " + [ v.constructor.name ]);
  };
  var singleton = function (k) {
      return function (v) {
          return new Two(Leaf.value, k, v, Leaf.value);
      };
  };
  var toUnfoldable = function (dictUnfoldable) {
      return function (m) {
          var go = function ($copy_v) {
              var $tco_done = false;
              var $tco_result;
              function $tco_loop(v) {
                  if (v instanceof Data_List_Types.Nil) {
                      $tco_done = true;
                      return Data_Maybe.Nothing.value;
                  };
                  if (v instanceof Data_List_Types.Cons) {
                      if (v.value0 instanceof Leaf) {
                          $copy_v = v.value1;
                          return;
                      };
                      if (v.value0 instanceof Two && (v.value0.value0 instanceof Leaf && v.value0.value3 instanceof Leaf)) {
                          $tco_done = true;
                          return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), v.value1));
                      };
                      if (v.value0 instanceof Two && v.value0.value0 instanceof Leaf) {
                          $tco_done = true;
                          return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), new Data_List_Types.Cons(v.value0.value3, v.value1)));
                      };
                      if (v.value0 instanceof Two) {
                          $copy_v = new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(singleton(v.value0.value1)(v.value0.value2), new Data_List_Types.Cons(v.value0.value3, v.value1)));
                          return;
                      };
                      if (v.value0 instanceof Three) {
                          $copy_v = new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(singleton(v.value0.value1)(v.value0.value2), new Data_List_Types.Cons(v.value0.value3, new Data_List_Types.Cons(singleton(v.value0.value4)(v.value0.value5), new Data_List_Types.Cons(v.value0.value6, v.value1)))));
                          return;
                      };
                      throw new Error("Failed pattern match at Data.Map.Internal (line 577, column 18 - line 586, column 71): " + [ v.value0.constructor.name ]);
                  };
                  throw new Error("Failed pattern match at Data.Map.Internal (line 576, column 3 - line 576, column 19): " + [ v.constructor.name ]);
              };
              while (!$tco_done) {
                  $tco_result = $tco_loop($copy_v);
              };
              return $tco_result;
          };
          return Data_Unfoldable.unfoldr(dictUnfoldable)(go)(new Data_List_Types.Cons(m, Data_List_Types.Nil.value));
      };
  };
  var lookup = function (dictOrd) {
      return function (k) {
          var comp = Data_Ord.compare(dictOrd);
          var go = function ($copy_v) {
              var $tco_done = false;
              var $tco_result;
              function $tco_loop(v) {
                  if (v instanceof Leaf) {
                      $tco_done = true;
                      return Data_Maybe.Nothing.value;
                  };
                  if (v instanceof Two) {
                      var v2 = comp(k)(v.value1);
                      if (v2 instanceof Data_Ordering.EQ) {
                          $tco_done = true;
                          return new Data_Maybe.Just(v.value2);
                      };
                      if (v2 instanceof Data_Ordering.LT) {
                          $copy_v = v.value0;
                          return;
                      };
                      $copy_v = v.value3;
                      return;
                  };
                  if (v instanceof Three) {
                      var v3 = comp(k)(v.value1);
                      if (v3 instanceof Data_Ordering.EQ) {
                          $tco_done = true;
                          return new Data_Maybe.Just(v.value2);
                      };
                      var v4 = comp(k)(v.value4);
                      if (v4 instanceof Data_Ordering.EQ) {
                          $tco_done = true;
                          return new Data_Maybe.Just(v.value5);
                      };
                      if (v3 instanceof Data_Ordering.LT) {
                          $copy_v = v.value0;
                          return;
                      };
                      if (v4 instanceof Data_Ordering.GT) {
                          $copy_v = v.value6;
                          return;
                      };
                      $copy_v = v.value3;
                      return;
                  };
                  throw new Error("Failed pattern match at Data.Map.Internal (line 200, column 5 - line 200, column 22): " + [ v.constructor.name ]);
              };
              while (!$tco_done) {
                  $tco_result = $tco_loop($copy_v);
              };
              return $tco_result;
          };
          return go;
      };
  }; 
  var fromZipper = function ($copy_dictOrd) {
      return function ($copy_v) {
          return function ($copy_tree) {
              var $tco_var_dictOrd = $copy_dictOrd;
              var $tco_var_v = $copy_v;
              var $tco_done = false;
              var $tco_result;
              function $tco_loop(dictOrd, v, tree) {
                  if (v instanceof Data_List_Types.Nil) {
                      $tco_done = true;
                      return tree;
                  };
                  if (v instanceof Data_List_Types.Cons) {
                      if (v.value0 instanceof TwoLeft) {
                          $tco_var_dictOrd = dictOrd;
                          $tco_var_v = v.value1;
                          $copy_tree = new Two(tree, v.value0.value0, v.value0.value1, v.value0.value2);
                          return;
                      };
                      if (v.value0 instanceof TwoRight) {
                          $tco_var_dictOrd = dictOrd;
                          $tco_var_v = v.value1;
                          $copy_tree = new Two(v.value0.value0, v.value0.value1, v.value0.value2, tree);
                          return;
                      };
                      if (v.value0 instanceof ThreeLeft) {
                          $tco_var_dictOrd = dictOrd;
                          $tco_var_v = v.value1;
                          $copy_tree = new Three(tree, v.value0.value0, v.value0.value1, v.value0.value2, v.value0.value3, v.value0.value4, v.value0.value5);
                          return;
                      };
                      if (v.value0 instanceof ThreeMiddle) {
                          $tco_var_dictOrd = dictOrd;
                          $tco_var_v = v.value1;
                          $copy_tree = new Three(v.value0.value0, v.value0.value1, v.value0.value2, tree, v.value0.value3, v.value0.value4, v.value0.value5);
                          return;
                      };
                      if (v.value0 instanceof ThreeRight) {
                          $tco_var_dictOrd = dictOrd;
                          $tco_var_v = v.value1;
                          $copy_tree = new Three(v.value0.value0, v.value0.value1, v.value0.value2, v.value0.value3, v.value0.value4, v.value0.value5, tree);
                          return;
                      };
                      throw new Error("Failed pattern match at Data.Map.Internal (line 418, column 3 - line 423, column 88): " + [ v.value0.constructor.name ]);
                  };
                  throw new Error("Failed pattern match at Data.Map.Internal (line 415, column 1 - line 415, column 80): " + [ v.constructor.name, tree.constructor.name ]);
              };
              while (!$tco_done) {
                  $tco_result = $tco_loop($tco_var_dictOrd, $tco_var_v, $copy_tree);
              };
              return $tco_result;
          };
      };
  };
  var insert = function (dictOrd) {
      return function (k) {
          return function (v) {
              var up = function ($copy_v1) {
                  return function ($copy_v2) {
                      var $tco_var_v1 = $copy_v1;
                      var $tco_done = false;
                      var $tco_result;
                      function $tco_loop(v1, v2) {
                          if (v1 instanceof Data_List_Types.Nil) {
                              $tco_done = true;
                              return new Two(v2.value0, v2.value1, v2.value2, v2.value3);
                          };
                          if (v1 instanceof Data_List_Types.Cons) {
                              if (v1.value0 instanceof TwoLeft) {
                                  $tco_done = true;
                                  return fromZipper(dictOrd)(v1.value1)(new Three(v2.value0, v2.value1, v2.value2, v2.value3, v1.value0.value0, v1.value0.value1, v1.value0.value2));
                              };
                              if (v1.value0 instanceof TwoRight) {
                                  $tco_done = true;
                                  return fromZipper(dictOrd)(v1.value1)(new Three(v1.value0.value0, v1.value0.value1, v1.value0.value2, v2.value0, v2.value1, v2.value2, v2.value3));
                              };
                              if (v1.value0 instanceof ThreeLeft) {
                                  $tco_var_v1 = v1.value1;
                                  $copy_v2 = new KickUp(new Two(v2.value0, v2.value1, v2.value2, v2.value3), v1.value0.value0, v1.value0.value1, new Two(v1.value0.value2, v1.value0.value3, v1.value0.value4, v1.value0.value5));
                                  return;
                              };
                              if (v1.value0 instanceof ThreeMiddle) {
                                  $tco_var_v1 = v1.value1;
                                  $copy_v2 = new KickUp(new Two(v1.value0.value0, v1.value0.value1, v1.value0.value2, v2.value0), v2.value1, v2.value2, new Two(v2.value3, v1.value0.value3, v1.value0.value4, v1.value0.value5));
                                  return;
                              };
                              if (v1.value0 instanceof ThreeRight) {
                                  $tco_var_v1 = v1.value1;
                                  $copy_v2 = new KickUp(new Two(v1.value0.value0, v1.value0.value1, v1.value0.value2, v1.value0.value3), v1.value0.value4, v1.value0.value5, new Two(v2.value0, v2.value1, v2.value2, v2.value3));
                                  return;
                              };
                              throw new Error("Failed pattern match at Data.Map.Internal (line 454, column 5 - line 459, column 108): " + [ v1.value0.constructor.name, v2.constructor.name ]);
                          };
                          throw new Error("Failed pattern match at Data.Map.Internal (line 451, column 3 - line 451, column 56): " + [ v1.constructor.name, v2.constructor.name ]);
                      };
                      while (!$tco_done) {
                          $tco_result = $tco_loop($tco_var_v1, $copy_v2);
                      };
                      return $tco_result;
                  };
              };
              var comp = Data_Ord.compare(dictOrd);
              var down = function ($copy_ctx) {
                  return function ($copy_v1) {
                      var $tco_var_ctx = $copy_ctx;
                      var $tco_done = false;
                      var $tco_result;
                      function $tco_loop(ctx, v1) {
                          if (v1 instanceof Leaf) {
                              $tco_done = true;
                              return up(ctx)(new KickUp(Leaf.value, k, v, Leaf.value));
                          };
                          if (v1 instanceof Two) {
                              var v2 = comp(k)(v1.value1);
                              if (v2 instanceof Data_Ordering.EQ) {
                                  $tco_done = true;
                                  return fromZipper(dictOrd)(ctx)(new Two(v1.value0, k, v, v1.value3));
                              };
                              if (v2 instanceof Data_Ordering.LT) {
                                  $tco_var_ctx = new Data_List_Types.Cons(new TwoLeft(v1.value1, v1.value2, v1.value3), ctx);
                                  $copy_v1 = v1.value0;
                                  return;
                              };
                              $tco_var_ctx = new Data_List_Types.Cons(new TwoRight(v1.value0, v1.value1, v1.value2), ctx);
                              $copy_v1 = v1.value3;
                              return;
                          };
                          if (v1 instanceof Three) {
                              var v3 = comp(k)(v1.value1);
                              if (v3 instanceof Data_Ordering.EQ) {
                                  $tco_done = true;
                                  return fromZipper(dictOrd)(ctx)(new Three(v1.value0, k, v, v1.value3, v1.value4, v1.value5, v1.value6));
                              };
                              var v4 = comp(k)(v1.value4);
                              if (v4 instanceof Data_Ordering.EQ) {
                                  $tco_done = true;
                                  return fromZipper(dictOrd)(ctx)(new Three(v1.value0, v1.value1, v1.value2, v1.value3, k, v, v1.value6));
                              };
                              if (v3 instanceof Data_Ordering.LT) {
                                  $tco_var_ctx = new Data_List_Types.Cons(new ThreeLeft(v1.value1, v1.value2, v1.value3, v1.value4, v1.value5, v1.value6), ctx);
                                  $copy_v1 = v1.value0;
                                  return;
                              };
                              if (v3 instanceof Data_Ordering.GT && v4 instanceof Data_Ordering.LT) {
                                  $tco_var_ctx = new Data_List_Types.Cons(new ThreeMiddle(v1.value0, v1.value1, v1.value2, v1.value4, v1.value5, v1.value6), ctx);
                                  $copy_v1 = v1.value3;
                                  return;
                              };
                              $tco_var_ctx = new Data_List_Types.Cons(new ThreeRight(v1.value0, v1.value1, v1.value2, v1.value3, v1.value4, v1.value5), ctx);
                              $copy_v1 = v1.value6;
                              return;
                          };
                          throw new Error("Failed pattern match at Data.Map.Internal (line 434, column 3 - line 434, column 55): " + [ ctx.constructor.name, v1.constructor.name ]);
                      };
                      while (!$tco_done) {
                          $tco_result = $tco_loop($tco_var_ctx, $copy_v1);
                      };
                      return $tco_result;
                  };
              };
              return down(Data_List_Types.Nil.value);
          };
      };
  };
  var pop = function (dictOrd) {
      return function (k) {
          var up = function ($copy_ctxs) {
              return function ($copy_tree) {
                  var $tco_var_ctxs = $copy_ctxs;
                  var $tco_done = false;
                  var $tco_result;
                  function $tco_loop(ctxs, tree) {
                      if (ctxs instanceof Data_List_Types.Nil) {
                          $tco_done = true;
                          return tree;
                      };
                      if (ctxs instanceof Data_List_Types.Cons) {
                          if (ctxs.value0 instanceof TwoLeft && (ctxs.value0.value2 instanceof Leaf && tree instanceof Leaf)) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(Leaf.value, ctxs.value0.value0, ctxs.value0.value1, Leaf.value));
                          };
                          if (ctxs.value0 instanceof TwoRight && (ctxs.value0.value0 instanceof Leaf && tree instanceof Leaf)) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(Leaf.value, ctxs.value0.value1, ctxs.value0.value2, Leaf.value));
                          };
                          if (ctxs.value0 instanceof TwoLeft && ctxs.value0.value2 instanceof Two) {
                              $tco_var_ctxs = ctxs.value1;
                              $copy_tree = new Three(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0, ctxs.value0.value2.value1, ctxs.value0.value2.value2, ctxs.value0.value2.value3);
                              return;
                          };
                          if (ctxs.value0 instanceof TwoRight && ctxs.value0.value0 instanceof Two) {
                              $tco_var_ctxs = ctxs.value1;
                              $copy_tree = new Three(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3, ctxs.value0.value1, ctxs.value0.value2, tree);
                              return;
                          };
                          if (ctxs.value0 instanceof TwoLeft && ctxs.value0.value2 instanceof Three) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(new Two(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0), ctxs.value0.value2.value1, ctxs.value0.value2.value2, new Two(ctxs.value0.value2.value3, ctxs.value0.value2.value4, ctxs.value0.value2.value5, ctxs.value0.value2.value6)));
                          };
                          if (ctxs.value0 instanceof TwoRight && ctxs.value0.value0 instanceof Three) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(new Two(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3), ctxs.value0.value0.value4, ctxs.value0.value0.value5, new Two(ctxs.value0.value0.value6, ctxs.value0.value1, ctxs.value0.value2, tree)));
                          };
                          if (ctxs.value0 instanceof ThreeLeft && (ctxs.value0.value2 instanceof Leaf && (ctxs.value0.value5 instanceof Leaf && tree instanceof Leaf))) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Three(Leaf.value, ctxs.value0.value0, ctxs.value0.value1, Leaf.value, ctxs.value0.value3, ctxs.value0.value4, Leaf.value));
                          };
                          if (ctxs.value0 instanceof ThreeMiddle && (ctxs.value0.value0 instanceof Leaf && (ctxs.value0.value5 instanceof Leaf && tree instanceof Leaf))) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Three(Leaf.value, ctxs.value0.value1, ctxs.value0.value2, Leaf.value, ctxs.value0.value3, ctxs.value0.value4, Leaf.value));
                          };
                          if (ctxs.value0 instanceof ThreeRight && (ctxs.value0.value0 instanceof Leaf && (ctxs.value0.value3 instanceof Leaf && tree instanceof Leaf))) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Three(Leaf.value, ctxs.value0.value1, ctxs.value0.value2, Leaf.value, ctxs.value0.value4, ctxs.value0.value5, Leaf.value));
                          };
                          if (ctxs.value0 instanceof ThreeLeft && ctxs.value0.value2 instanceof Two) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(new Three(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0, ctxs.value0.value2.value1, ctxs.value0.value2.value2, ctxs.value0.value2.value3), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));
                          };
                          if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value0 instanceof Two) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(new Three(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3, ctxs.value0.value1, ctxs.value0.value2, tree), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));
                          };
                          if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value5 instanceof Two) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Three(tree, ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5.value0, ctxs.value0.value5.value1, ctxs.value0.value5.value2, ctxs.value0.value5.value3)));
                          };
                          if (ctxs.value0 instanceof ThreeRight && ctxs.value0.value3 instanceof Two) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Two(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Three(ctxs.value0.value3.value0, ctxs.value0.value3.value1, ctxs.value0.value3.value2, ctxs.value0.value3.value3, ctxs.value0.value4, ctxs.value0.value5, tree)));
                          };
                          if (ctxs.value0 instanceof ThreeLeft && ctxs.value0.value2 instanceof Three) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Three(new Two(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0), ctxs.value0.value2.value1, ctxs.value0.value2.value2, new Two(ctxs.value0.value2.value3, ctxs.value0.value2.value4, ctxs.value0.value2.value5, ctxs.value0.value2.value6), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));
                          };
                          if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value0 instanceof Three) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Three(new Two(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3), ctxs.value0.value0.value4, ctxs.value0.value0.value5, new Two(ctxs.value0.value0.value6, ctxs.value0.value1, ctxs.value0.value2, tree), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));
                          };
                          if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value5 instanceof Three) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Three(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Two(tree, ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5.value0), ctxs.value0.value5.value1, ctxs.value0.value5.value2, new Two(ctxs.value0.value5.value3, ctxs.value0.value5.value4, ctxs.value0.value5.value5, ctxs.value0.value5.value6)));
                          };
                          if (ctxs.value0 instanceof ThreeRight && ctxs.value0.value3 instanceof Three) {
                              $tco_done = true;
                              return fromZipper(dictOrd)(ctxs.value1)(new Three(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Two(ctxs.value0.value3.value0, ctxs.value0.value3.value1, ctxs.value0.value3.value2, ctxs.value0.value3.value3), ctxs.value0.value3.value4, ctxs.value0.value3.value5, new Two(ctxs.value0.value3.value6, ctxs.value0.value4, ctxs.value0.value5, tree)));
                          };
                          throw new Error("Failed pattern match at Data.Map.Internal (line 511, column 9 - line 528, column 136): " + [ ctxs.value0.constructor.name, tree.constructor.name ]);
                      };
                      throw new Error("Failed pattern match at Data.Map.Internal (line 508, column 5 - line 528, column 136): " + [ ctxs.constructor.name ]);
                  };
                  while (!$tco_done) {
                      $tco_result = $tco_loop($tco_var_ctxs, $copy_tree);
                  };
                  return $tco_result;
              };
          };
          var removeMaxNode = function ($copy_ctx) {
              return function ($copy_m) {
                  var $tco_var_ctx = $copy_ctx;
                  var $tco_done = false;
                  var $tco_result;
                  function $tco_loop(ctx, m) {
                      if (m instanceof Two && (m.value0 instanceof Leaf && m.value3 instanceof Leaf)) {
                          $tco_done = true;
                          return up(ctx)(Leaf.value);
                      };
                      if (m instanceof Two) {
                          $tco_var_ctx = new Data_List_Types.Cons(new TwoRight(m.value0, m.value1, m.value2), ctx);
                          $copy_m = m.value3;
                          return;
                      };
                      if (m instanceof Three && (m.value0 instanceof Leaf && (m.value3 instanceof Leaf && m.value6 instanceof Leaf))) {
                          $tco_done = true;
                          return up(new Data_List_Types.Cons(new TwoRight(Leaf.value, m.value1, m.value2), ctx))(Leaf.value);
                      };
                      if (m instanceof Three) {
                          $tco_var_ctx = new Data_List_Types.Cons(new ThreeRight(m.value0, m.value1, m.value2, m.value3, m.value4, m.value5), ctx);
                          $copy_m = m.value6;
                          return;
                      };
                      throw new Error("Failed pattern match at Data.Map.Internal (line 540, column 5 - line 544, column 107): " + [ m.constructor.name ]);
                  };
                  while (!$tco_done) {
                      $tco_result = $tco_loop($tco_var_ctx, $copy_m);
                  };
                  return $tco_result;
              };
          };
          var maxNode = function ($copy_m) {
              var $tco_done = false;
              var $tco_result;
              function $tco_loop(m) {
                  if (m instanceof Two && m.value3 instanceof Leaf) {
                      $tco_done = true;
                      return {
                          key: m.value1,
                          value: m.value2
                      };
                  };
                  if (m instanceof Two) {
                      $copy_m = m.value3;
                      return;
                  };
                  if (m instanceof Three && m.value6 instanceof Leaf) {
                      $tco_done = true;
                      return {
                          key: m.value4,
                          value: m.value5
                      };
                  };
                  if (m instanceof Three) {
                      $copy_m = m.value6;
                      return;
                  };
                  throw new Error("Failed pattern match at Data.Map.Internal (line 531, column 33 - line 535, column 45): " + [ m.constructor.name ]);
              };
              while (!$tco_done) {
                  $tco_result = $tco_loop($copy_m);
              };
              return $tco_result;
          };
          var comp = Data_Ord.compare(dictOrd);
          var down = function ($copy_ctx) {
              return function ($copy_m) {
                  var $tco_var_ctx = $copy_ctx;
                  var $tco_done = false;
                  var $tco_result;
                  function $tco_loop(ctx, m) {
                      if (m instanceof Leaf) {
                          $tco_done = true;
                          return Data_Maybe.Nothing.value;
                      };
                      if (m instanceof Two) {
                          var v = comp(k)(m.value1);
                          if (m.value3 instanceof Leaf && v instanceof Data_Ordering.EQ) {
                              $tco_done = true;
                              return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, up(ctx)(Leaf.value)));
                          };
                          if (v instanceof Data_Ordering.EQ) {
                              var max = maxNode(m.value0);
                              $tco_done = true;
                              return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, removeMaxNode(new Data_List_Types.Cons(new TwoLeft(max.key, max.value, m.value3), ctx))(m.value0)));
                          };
                          if (v instanceof Data_Ordering.LT) {
                              $tco_var_ctx = new Data_List_Types.Cons(new TwoLeft(m.value1, m.value2, m.value3), ctx);
                              $copy_m = m.value0;
                              return;
                          };
                          $tco_var_ctx = new Data_List_Types.Cons(new TwoRight(m.value0, m.value1, m.value2), ctx);
                          $copy_m = m.value3;
                          return;
                      };
                      if (m instanceof Three) {
                          var leaves = (function () {
                              if (m.value0 instanceof Leaf && (m.value3 instanceof Leaf && m.value6 instanceof Leaf)) {
                                  return true;
                              };
                              return false;
                          })();
                          var v = comp(k)(m.value4);
                          var v3 = comp(k)(m.value1);
                          if (leaves && v3 instanceof Data_Ordering.EQ) {
                              $tco_done = true;
                              return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, fromZipper(dictOrd)(ctx)(new Two(Leaf.value, m.value4, m.value5, Leaf.value))));
                          };
                          if (leaves && v instanceof Data_Ordering.EQ) {
                              $tco_done = true;
                              return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value5, fromZipper(dictOrd)(ctx)(new Two(Leaf.value, m.value1, m.value2, Leaf.value))));
                          };
                          if (v3 instanceof Data_Ordering.EQ) {
                              var max = maxNode(m.value0);
                              $tco_done = true;
                              return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, removeMaxNode(new Data_List_Types.Cons(new ThreeLeft(max.key, max.value, m.value3, m.value4, m.value5, m.value6), ctx))(m.value0)));
                          };
                          if (v instanceof Data_Ordering.EQ) {
                              var max = maxNode(m.value3);
                              $tco_done = true;
                              return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value5, removeMaxNode(new Data_List_Types.Cons(new ThreeMiddle(m.value0, m.value1, m.value2, max.key, max.value, m.value6), ctx))(m.value3)));
                          };
                          if (v3 instanceof Data_Ordering.LT) {
                              $tco_var_ctx = new Data_List_Types.Cons(new ThreeLeft(m.value1, m.value2, m.value3, m.value4, m.value5, m.value6), ctx);
                              $copy_m = m.value0;
                              return;
                          };
                          if (v3 instanceof Data_Ordering.GT && v instanceof Data_Ordering.LT) {
                              $tco_var_ctx = new Data_List_Types.Cons(new ThreeMiddle(m.value0, m.value1, m.value2, m.value4, m.value5, m.value6), ctx);
                              $copy_m = m.value3;
                              return;
                          };
                          $tco_var_ctx = new Data_List_Types.Cons(new ThreeRight(m.value0, m.value1, m.value2, m.value3, m.value4, m.value5), ctx);
                          $copy_m = m.value6;
                          return;
                      };
                      throw new Error("Failed pattern match at Data.Map.Internal (line 481, column 34 - line 504, column 80): " + [ m.constructor.name ]);
                  };
                  while (!$tco_done) {
                      $tco_result = $tco_loop($tco_var_ctx, $copy_m);
                  };
                  return $tco_result;
              };
          };
          return down(Data_List_Types.Nil.value);
      };
  };
  var foldableMap = new Data_Foldable.Foldable(function (dictMonoid) {
      return function (f) {
          return function (m) {
              return Data_Foldable.foldMap(Data_List_Types.foldableList)(dictMonoid)(f)(values(m));
          };
      };
  }, function (f) {
      return function (z) {
          return function (m) {
              return Data_Foldable.foldl(Data_List_Types.foldableList)(f)(z)(values(m));
          };
      };
  }, function (f) {
      return function (z) {
          return function (m) {
              return Data_Foldable.foldr(Data_List_Types.foldableList)(f)(z)(values(m));
          };
      };
  });
  var empty = Leaf.value;
  var fromFoldable = function (dictOrd) {
      return function (dictFoldable) {
          return Data_Foldable.foldl(dictFoldable)(function (m) {
              return function (v) {
                  return insert(dictOrd)(v.value0)(v.value1)(m);
              };
          })(empty);
      };
  };
  var filterWithKey = function (dictOrd) {
      return function (predicate) {
          var $758 = fromFoldable(dictOrd)(Data_List_Lazy_Types.foldableList);
          var $759 = Data_List_Lazy.filter(Data_Tuple.uncurry(predicate));
          var $760 = toUnfoldable(Data_List_Lazy_Types.unfoldableList);
          return function ($761) {
              return $758($759($760($761)));
          };
      };
  };
  var filter = function (dictOrd) {
      return function (predicate) {
          return filterWithKey(dictOrd)(Data_Function["const"](predicate));
      };
  };
  var $$delete = function (dictOrd) {
      return function (k) {
          return function (m) {
              return Data_Maybe.maybe(m)(Data_Tuple.snd)(pop(dictOrd)(k)(m));
          };
      };
  };
  var asList = Control_Category.identity(Control_Category.categoryFn);
  var foldableWithIndexMap = new Data_FoldableWithIndex.FoldableWithIndex(function () {
      return foldableMap;
  }, function (dictMonoid) {
      return function (f) {
          return function (m) {
              return Data_Foldable.foldMap(Data_List_Types.foldableList)(dictMonoid)(Data_Tuple.uncurry(f))(asList(toUnfoldable(Data_List_Types.unfoldableList)(m)));
          };
      };
  }, function (f) {
      return function (z) {
          return function (m) {
              return Data_Foldable.foldl(Data_List_Types.foldableList)((function () {
                  var $763 = Data_Function.flip(f);
                  return function ($764) {
                      return Data_Tuple.uncurry($763($764));
                  };
              })())(z)(asList(toUnfoldable(Data_List_Types.unfoldableList)(m)));
          };
      };
  }, function (f) {
      return function (z) {
          return function (m) {
              return Data_Foldable.foldr(Data_List_Types.foldableList)(Data_Tuple.uncurry(f))(z)(asList(toUnfoldable(Data_List_Types.unfoldableList)(m)));
          };
      };
  });
  var mapMaybeWithKey = function (dictOrd) {
      return function (f) {
          return Data_FoldableWithIndex.foldrWithIndex(foldableWithIndexMap)(function (k) {
              return function (a) {
                  return function (acc) {
                      return Data_Maybe.maybe(acc)(function (b) {
                          return insert(dictOrd)(k)(b)(acc);
                      })(f(k)(a));
                  };
              };
          })(empty);
      };
  };
  var mapMaybe = function (dictOrd) {
      var $765 = mapMaybeWithKey(dictOrd);
      return function ($766) {
          return $765(Data_Function["const"]($766));
      };
  }; 
  var alter = function (dictOrd) {
      return function (f) {
          return function (k) {
              return function (m) {
                  var v = f(lookup(dictOrd)(k)(m));
                  if (v instanceof Data_Maybe.Nothing) {
                      return $$delete(dictOrd)(k)(m);
                  };
                  if (v instanceof Data_Maybe.Just) {
                      return insert(dictOrd)(k)(v.value0)(m);
                  };
                  throw new Error("Failed pattern match at Data.Map.Internal (line 549, column 15 - line 551, column 25): " + [ v.constructor.name ]);
              };
          };
      };
  };
  var unionWith = function (dictOrd) {
      return function (f) {
          return function (m1) {
              return function (m2) {
                  var go = function (m) {
                      return function (v) {
                          return alter(dictOrd)((function () {
                              var $769 = Data_Maybe.maybe(v.value1)(f(v.value1));
                              return function ($770) {
                                  return Data_Maybe.Just.create($769($770));
                              };
                          })())(v.value0)(m);
                      };
                  };
                  return Data_Foldable.foldl(Data_List_Types.foldableList)(go)(m2)(toUnfoldable(Data_List_Types.unfoldableList)(m1));
              };
          };
      };
  };
  exports["empty"] = empty;
  exports["singleton"] = singleton;
  exports["insert"] = insert;
  exports["lookup"] = lookup;
  exports["toUnfoldable"] = toUnfoldable;
  exports["unionWith"] = unionWith;
  exports["filter"] = filter;
  exports["mapMaybe"] = mapMaybe;
  exports["foldableWithIndexMap"] = foldableWithIndexMap;
})(PS);
(function(exports) {
  "use strict";

  exports.showNumberImpl = function (n) {
    var str = n.toString();
    return isNaN(str + ".0") ? str : str + ".0";
  };
})(PS["Data.Show"] = PS["Data.Show"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Show"] = $PS["Data.Show"] || {};
  var exports = $PS["Data.Show"];
  var $foreign = $PS["Data.Show"];
  var Show = function (show) {
      this.show = show;
  };
  var showNumber = new Show($foreign.showNumberImpl);
  var show = function (dict) {
      return dict.show;
  };
  exports["show"] = show;
  exports["showNumber"] = showNumber;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.Sparse.Polynomial"] = $PS["Data.Sparse.Polynomial"] || {};
  var exports = $PS["Data.Sparse.Polynomial"];
  var Data_Eq = $PS["Data.Eq"];
  var Data_Foldable = $PS["Data.Foldable"];
  var Data_FoldableWithIndex = $PS["Data.FoldableWithIndex"];
  var Data_Functor = $PS["Data.Functor"];
  var Data_Map_Internal = $PS["Data.Map.Internal"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Ord = $PS["Data.Ord"];
  var Data_Ring = $PS["Data.Ring"];
  var Data_Semiring = $PS["Data.Semiring"];
  var Data_Unfoldable = $PS["Data.Unfoldable"];
  var Poly = (function () {
      function Poly(value0) {
          this.value0 = value0;
      };
      Poly.create = function (value0) {
          return new Poly(value0);
      };
      return Poly;
  })();
  var semiringPoly = function (dictEq) {
      return function (dictSemiring) {
          return new Data_Semiring.Semiring(function (v) {
              return function (v1) {
                  return Poly.create(Data_Map_Internal.filter(Data_Ord.ordInt)(function (v2) {
                      return Data_Eq.notEq(dictEq)(v2)(Data_Semiring.zero(dictSemiring));
                  })(Data_Map_Internal.unionWith(Data_Ord.ordInt)(Data_Semiring.add(dictSemiring))(v.value0)(v1.value0)));
              };
          }, function (v) {
              return function (v1) {
                  return Poly.create(Data_Map_Internal.filter(Data_Ord.ordInt)(function (v2) {
                      return Data_Eq.notEq(dictEq)(v2)(Data_Semiring.zero(dictSemiring));
                  })(Data_Foldable.foldr(Data_Foldable.foldableArray)(Data_Map_Internal.unionWith(Data_Ord.ordInt)(Data_Semiring.add(dictSemiring)))(Data_Map_Internal.empty)(Data_Functor.map(Data_Functor.functorArray)(function (v2) {
                      return Data_FoldableWithIndex.foldrWithIndex(Data_Map_Internal.foldableWithIndexMap)(function (j) {
                          return function (w) {
                              return function (acc) {
                                  return Data_Map_Internal.insert(Data_Ord.ordInt)(v2.value0 + j | 0)(Data_Semiring.mul(dictSemiring)(v2.value1)(w))(acc);
                              };
                          };
                      })(Data_Map_Internal.empty)(v1.value0);
                  })(Data_Map_Internal.toUnfoldable(Data_Unfoldable.unfoldableArray)(v.value0)))));
              };
          }, Poly.create(Data_Map_Internal.singleton(0)(Data_Semiring.one(dictSemiring))), new Poly(Data_Map_Internal.empty));
      };
  }; 
  var query = function (dictSemiring) {
      return function (v) {
          return function (n) {
              return Data_Maybe.fromMaybe(Data_Semiring.zero(dictSemiring))(Data_Map_Internal.lookup(Data_Ord.ordInt)(n)(v.value0));
          };
      };
  };                                                         
  var monoPol = function (x) {
      return function (n) {
          return Poly.create(Data_Map_Internal.insert(Data_Ord.ordInt)(n)(x)(Data_Map_Internal.empty));
      };
  };                                                                                           
  var functorPoly = new Data_Functor.Functor(function (f) {
      return function (v) {
          return Poly.create(Data_Map_Internal.mapMaybe(Data_Ord.ordInt)(function (v1) {
              return Data_Maybe.Just.create(f(v1));
          })(v.value0));
      };
  });
  var ringPoly = function (dictEq) {
      return function (dictSemiring) {
          return function (dictRing) {
              return new Data_Ring.Ring(function () {
                  return semiringPoly(dictEq)(dictRing.Semiring0());
              }, function (p1) {
                  return function (p2) {
                      return Data_Semiring.add(semiringPoly(dictEq)(dictRing.Semiring0()))(p1)(Data_Functor.map(functorPoly)(function (v) {
                          return Data_Semiring.mul(dictRing.Semiring0())(v)(Data_Ring.negate(dictRing)(Data_Semiring.one(dictRing.Semiring0())));
                      })(p2));
                  };
              });
          };
      };
  };
  exports["monoPol"] = monoPol;
  exports["query"] = query;
  exports["semiringPoly"] = semiringPoly;
  exports["ringPoly"] = ringPoly;
})(PS);
(function(exports) {
  "use strict";                                             
  var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";

  exports._singleton = function (fallback) {
    return hasFromCodePoint ? String.fromCodePoint : fallback;
  };
})(PS["Data.String.CodePoints"] = PS["Data.String.CodePoints"] || {});
(function(exports) {
  "use strict";

  exports.singleton = function (c) {
    return c;
  };
})(PS["Data.String.CodeUnits"] = PS["Data.String.CodeUnits"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.String.CodeUnits"] = $PS["Data.String.CodeUnits"] || {};
  var exports = $PS["Data.String.CodeUnits"];
  var $foreign = $PS["Data.String.CodeUnits"];
  exports["singleton"] = $foreign.singleton;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Data.String.CodePoints"] = $PS["Data.String.CodePoints"] || {};
  var exports = $PS["Data.String.CodePoints"];
  var $foreign = $PS["Data.String.CodePoints"];
  var Data_Boolean = $PS["Data.Boolean"];
  var Data_Bounded = $PS["Data.Bounded"];
  var Data_Enum = $PS["Data.Enum"];
  var Data_Eq = $PS["Data.Eq"];
  var Data_EuclideanRing = $PS["Data.EuclideanRing"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Ord = $PS["Data.Ord"];
  var Data_String_CodeUnits = $PS["Data.String.CodeUnits"];
  var fromCharCode = (function () {
      var $53 = Data_Enum.toEnumWithDefaults(Data_Enum.boundedEnumChar)(Data_Bounded.bottom(Data_Bounded.boundedChar))(Data_Bounded.top(Data_Bounded.boundedChar));
      return function ($54) {
          return Data_String_CodeUnits.singleton($53($54));
      };
  })();
  var singletonFallback = function (v) {
      if (v <= 65535) {
          return fromCharCode(v);
      };
      var lead = Data_EuclideanRing.div(Data_EuclideanRing.euclideanRingInt)(v - 65536 | 0)(1024) + 55296 | 0;
      var trail = Data_EuclideanRing.mod(Data_EuclideanRing.euclideanRingInt)(v - 65536 | 0)(1024) + 56320 | 0;
      return fromCharCode(lead) + fromCharCode(trail);
  };                                                                          
  var singleton = $foreign["_singleton"](singletonFallback);
  var eqCodePoint = new Data_Eq.Eq(function (x) {
      return function (y) {
          return x === y;
      };
  });
  var ordCodePoint = new Data_Ord.Ord(function () {
      return eqCodePoint;
  }, function (x) {
      return function (y) {
          return Data_Ord.compare(Data_Ord.ordInt)(x)(y);
      };
  });
  var boundedCodePoint = new Data_Bounded.Bounded(function () {
      return ordCodePoint;
  }, 0, 1114111);
  var boundedEnumCodePoint = new Data_Enum.BoundedEnum(function () {
      return boundedCodePoint;
  }, function () {
      return enumCodePoint;
  }, 1114111 + 1 | 0, function (v) {
      return v;
  }, function (n) {
      if (n >= 0 && n <= 1114111) {
          return new Data_Maybe.Just(n);
      };
      if (Data_Boolean.otherwise) {
          return Data_Maybe.Nothing.value;
      };
      throw new Error("Failed pattern match at Data.String.CodePoints (line 63, column 1 - line 68, column 26): " + [ n.constructor.name ]);
  });
  var enumCodePoint = new Data_Enum.Enum(function () {
      return ordCodePoint;
  }, Data_Enum.defaultPred(Data_Enum.toEnum(boundedEnumCodePoint))(Data_Enum.fromEnum(boundedEnumCodePoint)), Data_Enum.defaultSucc(Data_Enum.toEnum(boundedEnumCodePoint))(Data_Enum.fromEnum(boundedEnumCodePoint)));
  exports["singleton"] = singleton;
  exports["boundedEnumCodePoint"] = boundedEnumCodePoint;
})(PS);
(function(exports) {
  "use strict";

  exports.pureE = function (a) {
    return function () {
      return a;
    };
  };

  exports.bindE = function (a) {
    return function (f) {
      return function () {
        return f(a())();
      };
    };
  };
})(PS["Effect"] = PS["Effect"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Effect"] = $PS["Effect"] || {};
  var exports = $PS["Effect"];
  var $foreign = $PS["Effect"];
  var Control_Applicative = $PS["Control.Applicative"];
  var Control_Apply = $PS["Control.Apply"];
  var Control_Bind = $PS["Control.Bind"];
  var Control_Monad = $PS["Control.Monad"];
  var Data_Functor = $PS["Data.Functor"];
  var Data_Monoid = $PS["Data.Monoid"];
  var Data_Semigroup = $PS["Data.Semigroup"];                
  var monadEffect = new Control_Monad.Monad(function () {
      return applicativeEffect;
  }, function () {
      return bindEffect;
  });
  var bindEffect = new Control_Bind.Bind(function () {
      return applyEffect;
  }, $foreign.bindE);
  var applyEffect = new Control_Apply.Apply(function () {
      return functorEffect;
  }, Control_Monad.ap(monadEffect));
  var applicativeEffect = new Control_Applicative.Applicative(function () {
      return applyEffect;
  }, $foreign.pureE);
  var functorEffect = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEffect));
  var semigroupEffect = function (dictSemigroup) {
      return new Data_Semigroup.Semigroup(Control_Apply.lift2(applyEffect)(Data_Semigroup.append(dictSemigroup)));
  };
  var monoidEffect = function (dictMonoid) {
      return new Data_Monoid.Monoid(function () {
          return semigroupEffect(dictMonoid.Semigroup0());
      }, $foreign.pureE(Data_Monoid.mempty(dictMonoid)));
  };
  exports["functorEffect"] = functorEffect;
  exports["applicativeEffect"] = applicativeEffect;
  exports["semigroupEffect"] = semigroupEffect;
  exports["monoidEffect"] = monoidEffect;
})(PS);
(function(exports) {
  exports.body = function(){
        return document.body;
  };

  exports.newSVG = function(node){
    return function(){
      let svgnode = document.createElementNS("http://www.w3.org/2000/svg","svg");
      svgnode.setAttribute("style","position: absolute; width:100%; height:100%; ");
      node.appendChild(svgnode);
      return svgnode};
   };
})(PS["Main"] = PS["Main"] || {});
(function(exports) {
  "use strict";            

  exports.atan2 = function (y) {
    return function (x) {
      return Math.atan2(y, x);
    };
  };                       

  exports.cos = Math.cos;    

  exports.sin = Math.sin;

  exports.sqrt = Math.sqrt;    

  exports.pi = Math.PI;
})(PS["Math"] = PS["Math"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Math"] = $PS["Math"] || {};
  var exports = $PS["Math"];
  var $foreign = $PS["Math"];
  exports["atan2"] = $foreign.atan2;
  exports["cos"] = $foreign.cos;
  exports["sin"] = $foreign.sin;
  exports["sqrt"] = $foreign.sqrt;
  exports["pi"] = $foreign.pi;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["SVG.Geometry"] = $PS["SVG.Geometry"] || {};
  var exports = $PS["SVG.Geometry"];
  var Data_Array = $PS["Data.Array"];
  var Data_Boolean = $PS["Data.Boolean"];
  var Data_Eq = $PS["Data.Eq"];
  var Data_Ring = $PS["Data.Ring"];
  var Data_Semiring = $PS["Data.Semiring"];
  var Data_Sparse_Polynomial = $PS["Data.Sparse.Polynomial"];
  var Data_Unit = $PS["Data.Unit"];
  var $$Math = $PS["Math"];                
  var Vector = function (x) {
      return x;
  };
  var Point = function (x) {
      return x;
  };
  var Line = function (x) {
      return x;
  };
  var Summable = function (plus) {
      this.plus = plus;
  };
  var Measurable = function (length) {
      this.length = length;
  };
  var Intersectable = function (meets) {
      this.meets = meets;
  };
  var Based = function (abs, coords, ord) {
      this.abs = abs;
      this.coords = coords;
      this.ord = ord;
  };
  var vector = function (v) {
      return function (v1) {
          return Vector(Data_Ring.sub(Data_Sparse_Polynomial.ringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber)(Data_Ring.ringNumber))(v1.coordinates)(v.coordinates));
      };
  };
  var summableVectorVector = new Summable(function (v) {
      return function (v1) {
          return Vector(Data_Semiring.add(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(v)(v1));
      };
  });
  var segment = function (origin) {
      return function (extremity) {
          return function (asOriented) {
              return {
                  origin: origin,
                  extremity: extremity,
                  asOriented: asOriented
              };
          };
      };
  };
  var scale = function (k) {
      return function (v) {
          return Vector(Data_Semiring.mul(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(Data_Sparse_Polynomial.monoPol(k)(0))(v));
      };
  };
  var rightangle = function (origin) {
      return function (center) {
          return function (extremity) {
              return function (radius) {
                  return {
                      origin: origin,
                      center: center,
                      extremity: extremity,
                      radius: radius
                  };
              };
          };
      };
  };
  var rename = function (str) {
      return function (v) {
          return Point({
              name: str,
              coordinates: v.coordinates
          });
      };
  };
  var point = function (name) {
      return function (x) {
          return function (y) {
              return Point({
                  name: name,
                  coordinates: Data_Semiring.add(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(Data_Sparse_Polynomial.monoPol(x)(0))(Data_Sparse_Polynomial.monoPol(y)(1))
              });
          };
      };
  };
  var plus = function (dict) {
      return dict.plus;
  };
  var ord = function (dict) {
      return dict.ord;
  };
  var middle = function (name) {
      return function (v) {
          return {
              name: name,
              coordinates: Data_Semiring.mul(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(Data_Semiring.add(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(v.origin.coordinates)(v.extremity.coordinates))(Data_Sparse_Polynomial.monoPol(0.5)(0))
          };
      };
  };
  var meets = function (dict) {
      return dict.meets;
  };
  var length = function (dict) {
      return dict.length;
  };
  var interLineLine = new Intersectable(function (v) {
      return function (v1) {
          var delta = v.a * v1.b - v1.a * v.b;
          if (delta === 0.0) {
              return [  ];
          };
          if (Data_Boolean.otherwise) {
              return [ point("")((v.b * v1.c - v1.b * v.c) / delta)((v1.a * v.c - v.a * v1.c) / delta) ];
          };
          throw new Error("Failed pattern match at SVG.Geometry (line 176, column 8 - line 179, column 65): " + [ Data_Unit.unit.constructor.name ]);
      };
  });
  var halfline = function (origin) {
      return function (direction) {
          return {
              origin: origin,
              direction: direction
          };
      };
  };
  var coords = function (dict) {
      return dict.coords;
  };
  var circle = function (p) {
      return function (r) {
          return {
              center: p,
              radius: r
          };
      };
  };
  var basedVector = new Based(function (v) {
      return Data_Sparse_Polynomial.query(Data_Semiring.semiringNumber)(v)(0);
  }, function (v) {
      return v;
  }, function (v) {
      return Data_Sparse_Polynomial.query(Data_Semiring.semiringNumber)(v)(1);
  });
  var basedPoint = new Based(function (v) {
      return Data_Sparse_Polynomial.query(Data_Semiring.semiringNumber)(v.coordinates)(0);
  }, function (v) {
      return v.coordinates;
  }, function (v) {
      return Data_Sparse_Polynomial.query(Data_Semiring.semiringNumber)(v.coordinates)(1);
  });
  var summublePointVector = new Summable(function (p) {
      return function (v) {
          return {
              name: "",
              coordinates: Data_Semiring.add(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(coords(basedPoint)(p))(coords(basedVector)(v))
          };
      };
  });
  var arc = function (origin) {
      return function (center) {
          return function (extremity) {
              return function (radius) {
                  return function (flag) {
                      return function (flipped) {
                          return function (swapped) {
                              return function (asOriented) {
                                  return {
                                      origin: origin,
                                      center: center,
                                      extremity: extremity,
                                      radius: radius,
                                      flag: flag,
                                      flipped: flipped,
                                      swapped: swapped,
                                      asOriented: asOriented
                                  };
                              };
                          };
                      };
                  };
              };
          };
      };
  };
  var abs = function (dict) {
      return dict.abs;
  };
  var line = function (m) {
      return function (n) {
          return Line({
              a: ord(basedPoint)(m) - ord(basedPoint)(n),
              b: abs(basedPoint)(n) - abs(basedPoint)(m),
              c: abs(basedPoint)(m) * ord(basedPoint)(n) - ord(basedPoint)(m) * abs(basedPoint)(n)
          });
      };
  };
  var measurableVector = new Measurable(function (v) {
      return $$Math.sqrt(abs(basedVector)(v) * abs(basedVector)(v) + ord(basedVector)(v) * ord(basedVector)(v));
  });
  var cosAngle = function (u) {
      return function (v) {
          return (abs(basedVector)(u) * abs(basedVector)(v) + ord(basedVector)(u) * ord(basedVector)(v)) / (length(measurableVector)(u) * length(measurableVector)(v));
      };
  };
  var interLineHalfLine = new Intersectable(function (l) {
      return function (v) {
          var l$prime = line(v.origin)(plus(summublePointVector)(v.origin)(v.direction));
          return Data_Array.filter(function (p) {
              return cosAngle(vector(v.origin)(p))(v.direction) >= 0.0;
          })(meets(interLineLine)(l)(l$prime));
      };
  });
  var interHalfLineLine = new Intersectable(function (hl) {
      return function (l) {
          return meets(interLineHalfLine)(l)(hl);
      };
  });
  var interSegmentLine = new Intersectable(function (v) {
      return function (l) {
          var hl = halfline(v.origin)(vector(v.origin)(v.extremity));
          return Data_Array.filter(function (p) {
              return cosAngle(vector(v.extremity)(p))(vector(v.extremity)(v.origin)) >= 0.0;
          })(meets(interHalfLineLine)(hl)(l));
      };
  });
  var interSegmentHalfLine = new Intersectable(function (s) {
      return function (v) {
          var l = line(v.origin)(plus(summublePointVector)(v.origin)(v.direction));
          return Data_Array.filter(function (p) {
              return cosAngle(vector(v.origin)(p))(v.direction) >= 0.0;
          })(meets(interSegmentLine)(s)(l));
      };
  });
  var interHalfLineSegment = new Intersectable(function (hl) {
      return function (s) {
          return meets(interSegmentHalfLine)(s)(hl);
      };
  });
  var interSegmentSegment = new Intersectable(function (v) {
      return function (s) {
          var hl = halfline(v.origin)(vector(v.origin)(v.extremity));
          return Data_Array.filter(function (p) {
              return cosAngle(vector(v.extremity)(p))(vector(v.extremity)(v.origin)) >= 0.0;
          })(meets(interHalfLineSegment)(hl)(s));
      };
  });
  var normalTo = function (v) {
      return Vector(Data_Semiring.add(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(Data_Sparse_Polynomial.monoPol(-ord(basedVector)(v))(0))(Data_Sparse_Polynomial.monoPol(abs(basedVector)(v))(1)));
  };
  var projection = function (direction) {
      return function (v) {
          return scale((abs(basedVector)(v) * abs(basedVector)(direction) + ord(basedVector)(v) * ord(basedVector)(direction)) / (length(measurableVector)(direction) * length(measurableVector)(direction)))(direction);
      };
  };
  var rotated = function (ang) {
      return function (v) {
          return Vector(Data_Semiring.add(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(Data_Sparse_Polynomial.monoPol(abs(basedVector)(v) * $$Math.cos(ang) - ord(basedVector)(v) * $$Math.sin(ang))(0))(Data_Sparse_Polynomial.monoPol(abs(basedVector)(v) * $$Math.sin(ang) + ord(basedVector)(v) * $$Math.cos(ang))(1)));
      };
  }; 
  var aVectorOfLine = function (v) {
      return Vector(Data_Semiring.add(Data_Sparse_Polynomial.semiringPoly(Data_Eq.eqNumber)(Data_Semiring.semiringNumber))(Data_Sparse_Polynomial.monoPol(-v.b)(0))(Data_Sparse_Polynomial.monoPol(v.a)(1)));
  };
  var aPointOnLine = function (v) {
      return point("")((-v.a * v.c) / (v.a * v.a + v.b * v.b))((-v.b * v.c) / (v.a * v.a + v.b * v.b));
  };
  var interLineCircle = new Intersectable(function (v) {
      return function (v1) {
          var u = aVectorOfLine(v);
          var m = aPointOnLine(v);
          var n = plus(summublePointVector)(m)(projection(u)(vector(m)(v1.center)));
          var ob = length(measurableVector)(vector(v1.center)(n));
          if (ob > v1.radius) {
              return [  ];
          };
          if (ob === v1.radius) {
              return [ n ];
          };
          if (Data_Boolean.otherwise) {
              var om = $$Math.sqrt(v1.radius * v1.radius - ob * ob);
              var v2 = scale(om / length(measurableVector)(u))(u);
              return [ plus(summublePointVector)(n)(v2), plus(summublePointVector)(n)(scale(-1.0)(v2)) ];
          };
          throw new Error("Failed pattern match at SVG.Geometry (line 196, column 10 - line 202, column 55): " + [ Data_Unit.unit.constructor.name ]);
      };
  });
  var interCircleLine = new Intersectable(function (c) {
      return function (l) {
          return meets(interLineCircle)(l)(c);
      };
  });
  var interCircleCircle = new Intersectable(function (v) {
      return function (v1) {
          var y1 = ord(basedPoint)(v1.center);
          var y0 = ord(basedPoint)(v.center);
          var x1 = abs(basedPoint)(v1.center);
          var x0 = abs(basedPoint)(v.center);
          var l = {
              a: 2.0 * (x0 - x1),
              b: 2.0 * (y0 - y1),
              c: ((((x1 * x1 - x0 * x0) + y1 * y1) - y0 * y0) + v.radius * v.radius) - v1.radius * v1.radius
          };
          return meets(interCircleLine)(v1)(l);
      };
  });
  var interHalfLineCircle = new Intersectable(function (v) {
      return function (c) {
          var l$prime = line(v.origin)(plus(summublePointVector)(v.origin)(v.direction));
          return Data_Array.filter(function (p) {
              return cosAngle(vector(v.origin)(p))(v.direction) >= 0.0;
          })(meets(interCircleLine)(c)(l$prime));
      };
  });
  var interCircleHalfLine = new Intersectable(function (c) {
      return function (hl) {
          return meets(interHalfLineCircle)(hl)(c);
      };
  });
  exports["Vector"] = Vector;
  exports["aPointOnLine"] = aPointOnLine;
  exports["aVectorOfLine"] = aVectorOfLine;
  exports["abs"] = abs;
  exports["arc"] = arc;
  exports["circle"] = circle;
  exports["halfline"] = halfline;
  exports["length"] = length;
  exports["line"] = line;
  exports["meets"] = meets;
  exports["middle"] = middle;
  exports["normalTo"] = normalTo;
  exports["ord"] = ord;
  exports["plus"] = plus;
  exports["point"] = point;
  exports["projection"] = projection;
  exports["rename"] = rename;
  exports["rightangle"] = rightangle;
  exports["rotated"] = rotated;
  exports["scale"] = scale;
  exports["segment"] = segment;
  exports["vector"] = vector;
  exports["basedPoint"] = basedPoint;
  exports["basedVector"] = basedVector;
  exports["measurableVector"] = measurableVector;
  exports["summableVectorVector"] = summableVectorVector;
  exports["summublePointVector"] = summublePointVector;
  exports["interLineLine"] = interLineLine;
  exports["interHalfLineCircle"] = interHalfLineCircle;
  exports["interCircleHalfLine"] = interCircleHalfLine;
  exports["interCircleCircle"] = interCircleCircle;
  exports["interHalfLineSegment"] = interHalfLineSegment;
  exports["interSegmentSegment"] = interSegmentSegment;
})(PS);
(function(exports) {
  
  exports.svgline = function(svg){
    return function (x1){
    return function(y1){
    return function(x2){
    return function(y2){
    return function(stroke){
    return function(strokeWidth){
    return function(){
      let l = document.createElementNS("http://www.w3.org/2000/svg","line");
      l.setAttributeNS(null,"x1",x1);
      l.setAttributeNS(null,"y1",y1);
      l.setAttributeNS(null,"x2",x2);
      l.setAttributeNS(null,"y2",y2);
      l.setAttributeNS(null,"style", "stroke:"+stroke+"; stroke-width:"+strokeWidth+"px;");
      svg.appendChild(l);
      };};};};};};};
   };

  exports.svgtext = function(svg){
    return function (x){
    return function (y){
    return function (fill){
    return function (fontStyle){
    return function (text){
    return function (){
      let t = document.createElementNS("http://www.w3.org/2000/svg","text");
      t.setAttributeNS(null,"x",x);
      t.setAttributeNS(null,"y",y);
      t.setAttributeNS(null,"style","fill:"+fill+"; font:"+fontStyle+";");
      t.textContent = text;
      svg.appendChild(t);
      };};};};};};
  };

  exports.svgpath = function(svg){
    return function(stroke){
    return function(strokeWidth){
    return function(fill){
    return function(path){
    return function(){
      let p = document.createElementNS("http://www.w3.org/2000/svg","path");
      p.setAttributeNS(null,"d",path);
      p.setAttributeNS(null,"style","stroke:"+stroke+"; stroke-width:"+strokeWidth+"; fill:"+fill+";");
      svg.appendChild(p);
      };};};};};
  };
})(PS["SVG.Render"] = PS["SVG.Render"] || {});
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["SVG.Render"] = $PS["SVG.Render"] || {};
  var exports = $PS["SVG.Render"];
  var $foreign = $PS["SVG.Render"];
  var Control_Applicative = $PS["Control.Applicative"];
  var Data_Enum = $PS["Data.Enum"];
  var Data_Foldable = $PS["Data.Foldable"];
  var Data_Functor = $PS["Data.Functor"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Monoid = $PS["Data.Monoid"];
  var Data_Semigroup = $PS["Data.Semigroup"];
  var Data_Show = $PS["Data.Show"];
  var Data_Sparse_Polynomial = $PS["Data.Sparse.Polynomial"];
  var Data_String_CodePoints = $PS["Data.String.CodePoints"];
  var Data_Unit = $PS["Data.Unit"];
  var Effect = $PS["Effect"];
  var $$Math = $PS["Math"];
  var SVG_Geometry = $PS["SVG.Geometry"];                
  var Render = function (render$prime) {
      this["render'"] = render$prime;
  };
  var renderPoint = new Render(function (v) {
      return function (v1) {
          return function __do() {
              $foreign.svgline(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1) - 5.0)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1) - 5.0)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1) + 5.0)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1) + 5.0)(v.stroke)(v.strokeWidth)();
              $foreign.svgline(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1) - 5.0)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1) + 5.0)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1) + 5.0)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1) - 5.0)(v.stroke)(v.strokeWidth)();
              return $foreign.svgtext(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1) + 10.0)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1) - 10.0)(v.textFill)(v.fontStyle)(v1.name)();
          };
      };
  });
  var renderHalfLine = new Render(function (v) {
      return function (v1) {
          var far = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v1.origin)(SVG_Geometry.scale(10.0)(v1.direction));
          return $foreign.svgline(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1.origin))(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1.origin))(SVG_Geometry.abs(SVG_Geometry.basedPoint)(far))(SVG_Geometry.ord(SVG_Geometry.basedPoint)(far))(v.stroke)(v.strokeWidth);
      };
  });
  var renderCircle = new Render(function (v) {
      return function (v1) {
          return function __do() {
              $foreign.svgpath(v.svg)(v.stroke)(v.strokeWidth)(v.fill)("M " + (Data_Show.show(Data_Show.showNumber)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1.center) - v1.radius) + (" " + (Data_Show.show(Data_Show.showNumber)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1.center)) + (" " + ("a " + (Data_Show.show(Data_Show.showNumber)(v1.radius) + (" " + (Data_Show.show(Data_Show.showNumber)(v1.radius) + (" " + ("0 1 0 " + (Data_Show.show(Data_Show.showNumber)(2.0 * v1.radius) + " 0"))))))))))))();
              return $foreign.svgpath(v.svg)(v.stroke)(v.strokeWidth)(v.fill)("M " + (Data_Show.show(Data_Show.showNumber)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1.center) - v1.radius) + (" " + (Data_Show.show(Data_Show.showNumber)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1.center)) + (" " + ("a " + (Data_Show.show(Data_Show.showNumber)(v1.radius) + (" " + (Data_Show.show(Data_Show.showNumber)(v1.radius) + (" " + ("0 1 1 " + (Data_Show.show(Data_Show.showNumber)(2.0 * v1.radius) + " 0"))))))))))))();
          };
      };
  });
  var render$prime = function (dict) {
      return dict["render'"];
  };
  var renderSequence = function (dictRender) {
      return new Render(function (ctx) {
          return function (arr) {
              return Data_Foldable.foldr(Data_Foldable.foldableArray)(Data_Semigroup.append(Effect.semigroupEffect(Data_Semigroup.semigroupUnit)))(Data_Monoid.mempty(Effect.monoidEffect(Data_Monoid.monoidUnit)))(Data_Functor.map(Data_Functor.functorArray)(render$prime(dictRender)(ctx))(arr));
          };
      });
  };
  var renderLine = new Render(function (ctx) {
      return function (l) {
          var v = SVG_Geometry.aVectorOfLine(l);
          var m = SVG_Geometry.aPointOnLine(l);
          return render$prime(renderSequence(renderHalfLine))(ctx)([ SVG_Geometry.halfline(m)(v), SVG_Geometry.halfline(m)(SVG_Geometry.scale(-1.0)(v)) ]);
      };
  });
  var pathCoord = function (p) {
      return " " + (Data_Show.show(Data_Show.showNumber)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(p)) + (" " + (Data_Show.show(Data_Show.showNumber)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(p)) + " ")));
  };
  var renderRightAngle = new Render(function (v) {
      return function (v1) {
          var w = SVG_Geometry.scale(v1.radius / SVG_Geometry.length(SVG_Geometry.measurableVector)(v1.origin))(v1.origin);
          var v2 = SVG_Geometry.scale(v1.radius / SVG_Geometry.length(SVG_Geometry.measurableVector)(v1.extremity))(v1.extremity);
          var u = SVG_Geometry.plus(SVG_Geometry.summableVectorVector)(v2)(w);
          var o = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v1.center)(w);
          var n = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v1.center)(v2);
          var m = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v1.center)(u);
          return $foreign.svgpath(v.svg)(v.stroke)(v.strokeWidth)(v.fill)("M" + (pathCoord(o) + ("L" + (pathCoord(m) + ("L" + pathCoord(n))))));
      };
  });
  var arrowLength = 20.0;
  var arrowBluntness = 0.3;
  var arrowTip = function (v) {
      var v1 = SVG_Geometry.vector(v.origin)(v.extremity);
      var v0 = SVG_Geometry.Vector(Data_Sparse_Polynomial.monoPol(SVG_Geometry.length(SVG_Geometry.measurableVector)(v1))(0));
      var ang = $$Math.atan2(SVG_Geometry.ord(SVG_Geometry.basedVector)(v1))(SVG_Geometry.abs(SVG_Geometry.basedVector)(v1));
      var f = function (theta) {
          var v11 = SVG_Geometry.rotated(theta)(SVG_Geometry.Vector(Data_Sparse_Polynomial.monoPol(arrowLength)(0)));
          return SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v.origin)(SVG_Geometry.rotated(ang)(SVG_Geometry.plus(SVG_Geometry.summableVectorVector)(v11)(v0)));
      };
      return {
          at1: f($$Math.pi - arrowBluntness),
          at2: f($$Math.pi + arrowBluntness)
      };
  };
  var renderArc = new Render(function (v) {
      return function (v1) {
          var v2 = SVG_Geometry.scale(v1.radius / SVG_Geometry.length(SVG_Geometry.measurableVector)(v1.extremity))(v1.extremity);
          var u = SVG_Geometry.scale(v1.radius / SVG_Geometry.length(SVG_Geometry.measurableVector)(v1.origin))(v1.origin);
          var pO = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v1.center)(u);
          var pE = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v1.center)(v2);
          var a2 = (function () {
              if (v1.flipped) {
                  return "0 ";
              };
              return "1 ";
          })();
          var b = (function () {
              var $60 = v1.flipped && v1.swapped;
              if ($60) {
                  return !v1.flag;
              };
              return v1.flag;
          })();
          var a1 = (function () {
              if (b) {
                  return "1 ";
              };
              return "0 ";
          })();
          var a3 = (function () {
              if (b) {
                  return 1.0;
              };
              return -1.0;
          })();
          return function __do() {
              $foreign.svgpath(v.svg)(v.stroke)(v.strokeWidth)(v.fill)("M" + (pathCoord(pO) + ("a " + (Data_Show.show(Data_Show.showNumber)(v1.radius) + (" " + (Data_Show.show(Data_Show.showNumber)(v1.radius) + (" " + ("0 " + (a1 + (a2 + (" " + (Data_Show.show(Data_Show.showNumber)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(pE) - SVG_Geometry.abs(SVG_Geometry.basedPoint)(pO)) + (" " + Data_Show.show(Data_Show.showNumber)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(pE) - SVG_Geometry.ord(SVG_Geometry.basedPoint)(pO)))))))))))))))();
              var d = 0.8 - 4.0e-3 * v1.radius;
              var p = SVG_Geometry.plus(SVG_Geometry.summableVectorVector)(SVG_Geometry.plus(SVG_Geometry.summableVectorVector)(SVG_Geometry.scale(a3 * d)(v2))(v1.origin))(SVG_Geometry.scale(-1.0)(SVG_Geometry.projection(v1.extremity)(v1.origin)));
              var n = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(pE)(SVG_Geometry.scale(-a3)(p));
              var v3 = arrowTip(SVG_Geometry.segment(n)(pE)(Data_Maybe.Nothing.value));
              Data_Maybe.maybe(Control_Applicative.pure(Effect.applicativeEffect)(Data_Unit.unit))(function (str) {
                  return $foreign.svgpath(v.svg)(v.stroke)(v.strokeWidth)(v.stroke)("M" + (pathCoord(v3.at2) + ("L" + (pathCoord(pE) + ("L" + (pathCoord(v3.at1) + "Z"))))));
              })(v1.asOriented)();
              var uv = SVG_Geometry.plus(SVG_Geometry.summableVectorVector)(u)(v2);
              var i = SVG_Geometry.plus(SVG_Geometry.summublePointVector)(v1.center)(SVG_Geometry.scale((v1.radius * 0.8) / SVG_Geometry.length(SVG_Geometry.measurableVector)(uv))(uv));
              return Data_Maybe.maybe(Control_Applicative.pure(Effect.applicativeEffect)(Data_Unit.unit))(function (str) {
                  return $foreign.svgtext(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(i))(SVG_Geometry.ord(SVG_Geometry.basedPoint)(i))(v.textFill)(v.fontStyle)(str);
              })(v1.asOriented)();
          };
      };
  });
  var renderSegment = new Render(function (v) {
      return function (v1) {
          return function __do() {
              $foreign.svgline(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1.origin))(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1.origin))(SVG_Geometry.abs(SVG_Geometry.basedPoint)(v1.extremity))(SVG_Geometry.ord(SVG_Geometry.basedPoint)(v1.extremity))(v.stroke)(v.strokeWidth)();
              Data_Maybe.maybe(Control_Applicative.pure(Effect.applicativeEffect)(Data_Unit.unit))(function (str) {
                  var v2 = arrowTip(v1);
                  return $foreign.svgpath(v.svg)(v.stroke)(v.strokeWidth)(v.stroke)("M" + (pathCoord(v2.at1) + ("L" + (pathCoord(v1.extremity) + ("L" + (pathCoord(v2.at2) + "Z"))))));
              })(v1.asOriented)();
              var m = SVG_Geometry.middle("")(v1);
              return Data_Maybe.maybe(Control_Applicative.pure(Effect.applicativeEffect)(Data_Unit.unit))(function (str) {
                  return function __do() {
                      $foreign.svgtext(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(m) + 10.0)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(m) - 10.0)(v.textFill)(v.fontStyle)(str)();
                      return $foreign.svgtext(v.svg)(SVG_Geometry.abs(SVG_Geometry.basedPoint)(m) + 10.0)(SVG_Geometry.ord(SVG_Geometry.basedPoint)(m) - 23.0)(v.textFill)(v.fontStyle)((function () {
                          var $85 = str === "";
                          if ($85) {
                              return "";
                          };
                          return Data_String_CodePoints.singleton(Data_Maybe.fromJust()(Data_Enum.toEnum(Data_String_CodePoints.boundedEnumCodePoint)(8594)));
                      })())();
                  };
              })(v1.asOriented)();
          };
      };
  });
  exports["render'"] = render$prime;
  exports["renderPoint"] = renderPoint;
  exports["renderHalfLine"] = renderHalfLine;
  exports["renderLine"] = renderLine;
  exports["renderSegment"] = renderSegment;
  exports["renderCircle"] = renderCircle;
  exports["renderArc"] = renderArc;
  exports["renderRightAngle"] = renderRightAngle;
  exports["renderSequence"] = renderSequence;
})(PS);
(function($PS) {
  // Generated by purs version 0.13.4
  "use strict";
  $PS["Main"] = $PS["Main"] || {};
  var exports = $PS["Main"];
  var $foreign = $PS["Main"];
  var Data_Functor = $PS["Data.Functor"];
  var Data_Maybe = $PS["Data.Maybe"];
  var Data_Unit = $PS["Data.Unit"];
  var Effect = $PS["Effect"];
  var SVG_Geometry = $PS["SVG.Geometry"];
  var SVG_Render = $PS["SVG.Render"];                
  var main = Data_Functor["void"](Effect.functorEffect)(function __do() {
      var v = $foreign.body();
      var v1 = $foreign.newSVG(v)();
      var context = {
          svg: v1,
          strokeWidth: 1.5,
          stroke: "#000",
          fill: "#000",
          fontStyle: "italic 15px arial, sans-serif",
          textFill: "#000"
      };
      var render = function (dictRender) {
          return SVG_Render["render'"](dictRender)(context);
      };
      var a = SVG_Geometry.point("A")(310.0)(320.0);
      var b = SVG_Geometry.point("B")(100.0)(210.0);
      render(SVG_Render.renderSequence(SVG_Render.renderPoint))([ a, b ])();
      render(SVG_Render.renderLine)(SVG_Geometry.line(a)(b))();
      var c = SVG_Geometry.circle(a)(SVG_Geometry.length(SVG_Geometry.measurableVector)(SVG_Geometry.vector(a)(b)));
      SVG_Render["render'"](SVG_Render.renderCircle)({
          svg: context.svg,
          stroke: context.stroke,
          fill: "#00000000",
          strokeWidth: context.strokeWidth,
          fontStyle: context.fontStyle,
          textFill: context.textFill
      })(c)();
      var n = SVG_Geometry.normalTo(SVG_Geometry.vector(a)(b));
      var d = SVG_Geometry.halfline(a)(n);
      render(SVG_Render.renderHalfLine)(d)();
      var v2 = Data_Functor.map(Data_Functor.functorArray)(SVG_Geometry.rename("E"))(SVG_Geometry.meets(SVG_Geometry.interHalfLineCircle)(d)(c));
      if (v2.length === 1) {
          render(SVG_Render.renderPoint)(v2[0])();
          var eb = SVG_Geometry.segment(v2[0])(b)(Data_Maybe.Nothing.value);
          render(SVG_Render.renderSegment)(eb)();
          var i = SVG_Geometry.middle("I")(eb);
          render(SVG_Render.renderPoint)(i)();
          var v3 = Data_Functor.map(Data_Functor.functorArray)(SVG_Geometry.rename("F"))(SVG_Geometry.meets(SVG_Geometry.interCircleHalfLine)(c)(SVG_Geometry.halfline(a)(SVG_Geometry.vector(b)(a))));
          if (v3.length === 1) {
              render(SVG_Render.renderPoint)(v3[0])();
              SVG_Render["render'"](SVG_Render.renderSegment)({
                  svg: context.svg,
                  stroke: context.stroke,
                  fill: context.fill,
                  strokeWidth: 5.0,
                  fontStyle: context.fontStyle,
                  textFill: context.textFill
              })(SVG_Geometry.segment(i)(v3[0])(new Data_Maybe.Just("u")))();
              var orientedArc = SVG_Geometry.arc(SVG_Geometry.vector(i)(v3[0]))(i)(SVG_Geometry.vector(i)(b))(50.0)(false)(false)(false)(new Data_Maybe.Just("\u03b1"));
              SVG_Render["render'"](SVG_Render.renderArc)({
                  svg: context.svg,
                  stroke: context.stroke,
                  fill: "#00000000",
                  strokeWidth: context.strokeWidth,
                  fontStyle: context.fontStyle,
                  textFill: context.textFill
              })(orientedArc)();
              var g = SVG_Geometry.circle(v3[0])(SVG_Geometry.length(SVG_Geometry.measurableVector)(SVG_Geometry.vector(i)(v2[0])));
              SVG_Render["render'"](SVG_Render.renderCircle)({
                  svg: context.svg,
                  stroke: context.stroke,
                  fill: "#00000000",
                  strokeWidth: context.strokeWidth,
                  fontStyle: context.fontStyle,
                  textFill: context.textFill
              })(g)();
              var v4 = SVG_Geometry.meets(SVG_Geometry.interCircleCircle)(g)(c);
              if (v4.length === 2) {
                  render(SVG_Render.renderSequence(SVG_Render.renderPoint))([ v4[0], v4[1] ])();
                  var v5 = Data_Functor.map(Data_Functor.functorArray)(SVG_Geometry.rename("H"))(SVG_Geometry.meets(SVG_Geometry.interLineLine)(SVG_Geometry.line(a)(v2[0]))(SVG_Geometry.line(i)(v3[0])));
                  if (v5.length === 1) {
                      render(SVG_Render.renderPoint)(v5[0])();
                      SVG_Render["render'"](SVG_Render.renderRightAngle)({
                          svg: context.svg,
                          stroke: context.stroke,
                          fill: "#00000000",
                          strokeWidth: context.strokeWidth,
                          fontStyle: context.fontStyle,
                          textFill: context.textFill
                      })(SVG_Geometry.rightangle(SVG_Geometry.vector(a)(b))(a)(SVG_Geometry.vector(a)(v2[0]))(15.0))();
                      var v6 = SVG_Geometry.meets(SVG_Geometry.interSegmentSegment)(SVG_Geometry.segment(b)(v5[0])(Data_Maybe.Nothing.value))(SVG_Geometry.segment(v2[0])(v3[0])(Data_Maybe.Nothing.value));
                      if (v6.length === 0) {
                          var v7 = Data_Functor.map(Data_Functor.functorArray)(SVG_Geometry.rename("J"))(SVG_Geometry.meets(SVG_Geometry.interHalfLineSegment)(SVG_Geometry.halfline(b)(SVG_Geometry.vector(b)(v5[0])))(SVG_Geometry.segment(v2[0])(v3[0])(Data_Maybe.Nothing.value)));
                          if (v7.length === 1) {
                              render(SVG_Render.renderPoint)(v7[0])();
                              SVG_Render["render'"](SVG_Render.renderSegment)({
                                  svg: context.svg,
                                  stroke: context.stroke,
                                  fill: context.fill,
                                  strokeWidth: 0.5,
                                  fontStyle: context.fontStyle,
                                  textFill: context.textFill
                              })(SVG_Geometry.segment(i)(v7[0])(new Data_Maybe.Just("")))();
                              return Data_Unit.unit;
                          };
                          throw new Error("Failed pattern match at Main (line 67, column 7 - line 68, column 52): " + [ v7.constructor.name ]);
                      };
                      throw new Error("Failed pattern match at Main (line 66, column 7 - line 66, column 63): " + [ v6.constructor.name ]);
                  };
                  throw new Error("Failed pattern match at Main (line 61, column 7 - line 61, column 59): " + [ v5.constructor.name ]);
              };
              throw new Error("Failed pattern match at Main (line 59, column 7 - line 59, column 28): " + [ v4.constructor.name ]);
          };
          throw new Error("Failed pattern match at Main (line 50, column 7 - line 50, column 65): " + [ v3.constructor.name ]);
      };
      throw new Error("Failed pattern match at Main (line 43, column 7 - line 43, column 43): " + [ v2.constructor.name ]);
  });
  exports["main"] = main;
  exports["body"] = $foreign.body;
  exports["newSVG"] = $foreign.newSVG;
})(PS);
PS["Main"].main();