netw.js

// Generated by psc-bundle 0.8.5.0
var PS = {};
(function(exports) {
    "use strict";

  //module App.Config

  exports.requireConfigFile = function(path){
    return function(){
      return require(path);
    };
  };
})(PS["App.Config"] = PS["App.Config"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Control.Monad.Eff

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

  exports.bindE = function (a) {
    return function (f) {
      return function () {
        return f(a())();
      };
    };
  };

  exports.runPure = function (f) {
    return f();
  };
})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Prelude

  //- Functor --------------------------------------------------------------------

  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;
    };
  };

  //- Monoid ---------------------------------------------------------------------

  exports.concatString = function (s1) {
    return function (s2) {
      return s1 + s2;
    };
  };

  //- Eq -------------------------------------------------------------------------

  exports.refEq = function (r1) {
    return function (r2) {
      return r1 === r2;
    };
  };

  //- Ord ------------------------------------------------------------------------

  exports.unsafeCompareImpl = function (lt) {
    return function (eq) {
      return function (gt) {
        return function (x) {
          return function (y) {
            return x < y ? lt : x > y ? gt : eq;
          };
        };
      };
    };
  };

  //- Bounded --------------------------------------------------------------------

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

  //- BooleanAlgebra -------------------------------------------------------------

  exports.boolOr = function (b1) {
    return function (b2) {
      return b1 || b2;
    };
  };

  exports.boolAnd = function (b1) {
    return function (b2) {
      return b1 && b2;
    };
  };

  exports.boolNot = function (b) {
    return !b;
  };

  //- Show -----------------------------------------------------------------------

  exports.showIntImpl = function (n) {
    return n.toString();
  };

  exports.showStringImpl = function (s) {
    var l = s.length;
    return "\"" + s.replace(
      /[\0-\x1F\x7F"\\]/g,
      function (c, i) { // jshint ignore:line
        switch (c) {
          case "\"":
          case "\\":
            return "\\" + c;
          case "\x07": return "\\a";
          case "\b": return "\\b";
          case "\f": return "\\f";
          case "\n": return "\\n";
          case "\r": return "\\r";
          case "\t": return "\\t";
          case "\v": return "\\v";
        }
        var k = i + 1;
        var empty = k < l && s[k] >= "0" && s[k] <= "9" ? "\\&" : "";
        return "\\" + c.charCodeAt(0).toString(10) + empty;
      }
    ) + "\"";
  };

  exports.showArrayImpl = function (f) {
    return function (xs) {
      var ss = [];
      for (var i = 0, l = xs.length; i < l; i++) {
        ss[i] = f(xs[i]);
      }
      return "[" + ss.join(",") + "]";
    };
  };
})(PS["Prelude"] = PS["Prelude"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Prelude"];
  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;
  })();
  var Semigroupoid = function (compose) {
      this.compose = compose;
  };
  var Category = function (__superclass_Prelude$dotSemigroupoid_0, id) {
      this["__superclass_Prelude.Semigroupoid_0"] = __superclass_Prelude$dotSemigroupoid_0;
      this.id = id;
  };
  var Functor = function (map) {
      this.map = map;
  };
  var Apply = function (__superclass_Prelude$dotFunctor_0, apply) {
      this["__superclass_Prelude.Functor_0"] = __superclass_Prelude$dotFunctor_0;
      this.apply = apply;
  };
  var Applicative = function (__superclass_Prelude$dotApply_0, pure) {
      this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
      this.pure = pure;
  };
  var Bind = function (__superclass_Prelude$dotApply_0, bind) {
      this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
      this.bind = bind;
  };
  var Monad = function (__superclass_Prelude$dotApplicative_0, __superclass_Prelude$dotBind_1) {
      this["__superclass_Prelude.Applicative_0"] = __superclass_Prelude$dotApplicative_0;
      this["__superclass_Prelude.Bind_1"] = __superclass_Prelude$dotBind_1;
  };
  var Semigroup = function (append) {
      this.append = append;
  };
  var Semiring = function (add, mul, one, zero) {
      this.add = add;
      this.mul = mul;
      this.one = one;
      this.zero = zero;
  };
  var Eq = function (eq) {
      this.eq = eq;
  };
  var Ord = function (__superclass_Prelude$dotEq_0, compare) {
      this["__superclass_Prelude.Eq_0"] = __superclass_Prelude$dotEq_0;
      this.compare = compare;
  };
  var Bounded = function (bottom, top) {
      this.bottom = bottom;
      this.top = top;
  };
  var BooleanAlgebra = function (__superclass_Prelude$dotBounded_0, conj, disj, not) {
      this["__superclass_Prelude.Bounded_0"] = __superclass_Prelude$dotBounded_0;
      this.conj = conj;
      this.disj = disj;
      this.not = not;
  };
  var Show = function (show) {
      this.show = show;
  };
  var zero = function (dict) {
      return dict.zero;
  };
  var unsafeCompare = $foreign.unsafeCompareImpl(LT.value)(EQ.value)(GT.value);
  var unit = {};
  var top = function (dict) {
      return dict.top;
  }; 
  var showString = new Show($foreign.showStringImpl);
  var showInt = new Show($foreign.showIntImpl);
  var show = function (dict) {
      return dict.show;
  };
  var showArray = function (dictShow) {
      return new Show($foreign.showArrayImpl(show(dictShow)));
  };                                                                     
  var semigroupoidFn = new Semigroupoid(function (f) {
      return function (g) {
          return function (x) {
              return f(g(x));
          };
      };
  });
  var semigroupString = new Semigroup($foreign.concatString);
  var pure = function (dict) {
      return dict.pure;
  };
  var $$return = function (dictApplicative) {
      return pure(dictApplicative);
  };
  var otherwise = true;
  var one = function (dict) {
      return dict.one;
  };
  var not = function (dict) {
      return dict.not;
  };
  var mul = function (dict) {
      return dict.mul;
  };
  var map = function (dict) {
      return dict.map;
  };
  var $less$dollar$greater = function (dictFunctor) {
      return map(dictFunctor);
  };
  var id = function (dict) {
      return dict.id;
  };
  var functorArray = new Functor($foreign.arrayMap);
  var flip = function (f) {
      return function (b) {
          return function (a) {
              return f(a)(b);
          };
      };
  }; 
  var eqString = new Eq($foreign.refEq);
  var ordString = new Ord(function () {
      return eqString;
  }, unsafeCompare);
  var eqInt = new Eq($foreign.refEq);
  var eq = function (dict) {
      return dict.eq;
  };
  var $eq$eq = function (dictEq) {
      return eq(dictEq);
  };
  var disj = function (dict) {
      return dict.disj;
  };
  var $$const = function (a) {
      return function (v) {
          return a;
      };
  };
  var $$void = function (dictFunctor) {
      return function (fa) {
          return $less$dollar$greater(dictFunctor)($$const(unit))(fa);
      };
  };
  var conj = function (dict) {
      return dict.conj;
  };
  var compose = function (dict) {
      return dict.compose;
  };
  var compare = function (dict) {
      return dict.compare;
  };
  var categoryFn = new Category(function () {
      return semigroupoidFn;
  }, function (x) {
      return x;
  });
  var boundedInt = new Bounded($foreign.bottomInt, $foreign.topInt);
  var boundedBoolean = new Bounded(false, true);
  var bottom = function (dict) {
      return dict.bottom;
  };
  var booleanAlgebraBoolean = new BooleanAlgebra(function () {
      return boundedBoolean;
  }, $foreign.boolAnd, $foreign.boolOr, $foreign.boolNot);
  var $div$eq = function (dictEq) {
      return function (x) {
          return function (y) {
              return not(booleanAlgebraBoolean)($eq$eq(dictEq)(x)(y));
          };
      };
  };
  var bind = function (dict) {
      return dict.bind;
  };
  var $greater$greater$eq = function (dictBind) {
      return bind(dictBind);
  }; 
  var apply = function (dict) {
      return dict.apply;
  };
  var $less$times$greater = function (dictApply) {
      return apply(dictApply);
  };
  var liftA1 = function (dictApplicative) {
      return function (f) {
          return function (a) {
              return $less$times$greater(dictApplicative["__superclass_Prelude.Apply_0"]())(pure(dictApplicative)(f))(a);
          };
      };
  }; 
  var append = function (dict) {
      return dict.append;
  };
  var $less$greater = function (dictSemigroup) {
      return append(dictSemigroup);
  };
  var ap = function (dictMonad) {
      return function (f) {
          return function (a) {
              return bind(dictMonad["__superclass_Prelude.Bind_1"]())(f)(function (v) {
                  return bind(dictMonad["__superclass_Prelude.Bind_1"]())(a)(function (v1) {
                      return $$return(dictMonad["__superclass_Prelude.Applicative_0"]())(v(v1));
                  });
              });
          };
      };
  }; 
  var add = function (dict) {
      return dict.add;
  };
  exports["LT"] = LT;
  exports["GT"] = GT;
  exports["EQ"] = EQ;
  exports["Show"] = Show;
  exports["BooleanAlgebra"] = BooleanAlgebra;
  exports["Bounded"] = Bounded;
  exports["Ord"] = Ord;
  exports["Eq"] = Eq;
  exports["Semiring"] = Semiring;
  exports["Semigroup"] = Semigroup;
  exports["Monad"] = Monad;
  exports["Bind"] = Bind;
  exports["Applicative"] = Applicative;
  exports["Apply"] = Apply;
  exports["Functor"] = Functor;
  exports["Category"] = Category;
  exports["Semigroupoid"] = Semigroupoid;
  exports["show"] = show;
  exports["not"] = not;
  exports["disj"] = disj;
  exports["conj"] = conj;
  exports["bottom"] = bottom;
  exports["top"] = top;
  exports["unsafeCompare"] = unsafeCompare;
  exports["compare"] = compare;
  exports["/="] = $div$eq;
  exports["=="] = $eq$eq;
  exports["eq"] = eq;
  exports["one"] = one;
  exports["mul"] = mul;
  exports["zero"] = zero;
  exports["add"] = add;
  exports["<>"] = $less$greater;
  exports["append"] = append;
  exports["ap"] = ap;
  exports["return"] = $$return;
  exports[">>="] = $greater$greater$eq;
  exports["bind"] = bind;
  exports["liftA1"] = liftA1;
  exports["pure"] = pure;
  exports["<*>"] = $less$times$greater;
  exports["apply"] = apply;
  exports["void"] = $$void;
  exports["<$>"] = $less$dollar$greater;
  exports["map"] = map;
  exports["id"] = id;
  exports["compose"] = compose;
  exports["otherwise"] = otherwise;
  exports["const"] = $$const;
  exports["flip"] = flip;
  exports["unit"] = unit;
  exports["semigroupoidFn"] = semigroupoidFn;
  exports["categoryFn"] = categoryFn;
  exports["functorArray"] = functorArray;
  exports["semigroupString"] = semigroupString;
  exports["eqInt"] = eqInt;
  exports["eqString"] = eqString;
  exports["ordString"] = ordString;
  exports["boundedBoolean"] = boundedBoolean;
  exports["boundedInt"] = boundedInt;
  exports["booleanAlgebraBoolean"] = booleanAlgebraBoolean;
  exports["showInt"] = showInt;
  exports["showString"] = showString;
  exports["showArray"] = showArray;
})(PS["Prelude"] = PS["Prelude"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff"];
  var Prelude = PS["Prelude"];        
  var monadEff = new Prelude.Monad(function () {
      return applicativeEff;
  }, function () {
      return bindEff;
  });
  var bindEff = new Prelude.Bind(function () {
      return applyEff;
  }, $foreign.bindE);
  var applyEff = new Prelude.Apply(function () {
      return functorEff;
  }, Prelude.ap(monadEff));
  var applicativeEff = new Prelude.Applicative(function () {
      return applyEff;
  }, $foreign.returnE);
  var functorEff = new Prelude.Functor(Prelude.liftA1(applicativeEff));
  exports["functorEff"] = functorEff;
  exports["applyEff"] = applyEff;
  exports["applicativeEff"] = applicativeEff;
  exports["bindEff"] = bindEff;
  exports["monadEff"] = monadEff;
  exports["runPure"] = $foreign.runPure;
})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Foreign

  // jshint maxparams: 3
  exports.parseJSONImpl = function (left, right, str) {
    try {
      return right(JSON.parse(str));
    } catch (e) {
      return left(e.toString());
    }
  };

  // jshint maxparams: 1
  exports.toForeign = function (value) {
    return value;
  };

  exports.unsafeFromForeign = function (value) {
    return value;
  };

  exports.typeOf = function (value) {
    return typeof value;
  };

  exports.tagOf = function (value) {
    return Object.prototype.toString.call(value).slice(8, -1);
  };

  exports.isNull = function (value) {
    return value === null;
  };

  exports.isUndefined = function (value) {
    return value === undefined;
  };

  exports.isArray = Array.isArray || function (value) {
    return Object.prototype.toString.call(value) === "[object Array]";
  };
})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Foldable

  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(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var $times$greater = function (dictApply) {
      return function (a) {
          return function (b) {
              return Prelude["<*>"](dictApply)(Prelude["<$>"](dictApply["__superclass_Prelude.Functor_0"]())(Prelude["const"](Prelude.id(Prelude.categoryFn)))(a))(b);
          };
      };
  };
  exports["*>"] = $times$greater;
})(PS["Control.Apply"] = PS["Control.Apply"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];        
  var Monoid = function (__superclass_Prelude$dotSemigroup_0, mempty) {
      this["__superclass_Prelude.Semigroup_0"] = __superclass_Prelude$dotSemigroup_0;
      this.mempty = mempty;
  };               
  var monoidString = new Monoid(function () {
      return Prelude.semigroupString;
  }, "");  
  var mempty = function (dict) {
      return dict.mempty;
  };
  exports["Monoid"] = Monoid;
  exports["mempty"] = mempty;
  exports["monoidString"] = monoidString;
})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Extend = PS["Control.Extend"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Monoid = PS["Data.Monoid"];        
  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 27, column 1 - line 28, column 1: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
          };
      };
  };
  var isNothing = maybe(true)(Prelude["const"](false));
  var functorMaybe = new Prelude.Functor(function (v) {
      return function (v1) {
          if (v1 instanceof Just) {
              return new Just(v(v1.value0));
          };
          return Nothing.value;
      };
  });
  var eqMaybe = function (dictEq) {
      return new Prelude.Eq(function (v) {
          return function (v1) {
              if (v instanceof Nothing && v1 instanceof Nothing) {
                  return true;
              };
              if (v instanceof Just && v1 instanceof Just) {
                  return Prelude["=="](dictEq)(v.value0)(v1.value0);
              };
              return false;
          };
      });
  };
  var applyMaybe = new Prelude.Apply(function () {
      return functorMaybe;
  }, function (v) {
      return function (v1) {
          if (v instanceof Just) {
              return Prelude["<$>"](functorMaybe)(v.value0)(v1);
          };
          if (v instanceof Nothing) {
              return Nothing.value;
          };
          throw new Error("Failed pattern match at Data.Maybe line 122, column 3 - line 123, column 3: " + [ v.constructor.name, v1.constructor.name ]);
      };
  });
  var bindMaybe = new Prelude.Bind(function () {
      return applyMaybe;
  }, function (v) {
      return function (v1) {
          if (v instanceof Just) {
              return v1(v.value0);
          };
          if (v instanceof Nothing) {
              return Nothing.value;
          };
          throw new Error("Failed pattern match at Data.Maybe line 181, column 3 - line 182, column 3: " + [ v.constructor.name, v1.constructor.name ]);
      };
  });
  var applicativeMaybe = new Prelude.Applicative(function () {
      return applyMaybe;
  }, Just.create);
  exports["Nothing"] = Nothing;
  exports["Just"] = Just;
  exports["isNothing"] = isNothing;
  exports["maybe"] = maybe;
  exports["functorMaybe"] = functorMaybe;
  exports["applyMaybe"] = applyMaybe;
  exports["applicativeMaybe"] = applicativeMaybe;
  exports["bindMaybe"] = bindMaybe;
  exports["eqMaybe"] = eqMaybe;
})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Comonad = PS["Control.Comonad"];
  var Control_Extend = PS["Control.Extend"];
  var Data_Monoid = PS["Data.Monoid"];        
  var Disj = function (x) {
      return x;
  };
  var semigroupDisj = function (dictBooleanAlgebra) {
      return new Prelude.Semigroup(function (v) {
          return function (v1) {
              return Prelude.disj(dictBooleanAlgebra)(v)(v1);
          };
      });
  };
  var runDisj = function (v) {
      return v;
  };
  var monoidDisj = function (dictBooleanAlgebra) {
      return new Data_Monoid.Monoid(function () {
          return semigroupDisj(dictBooleanAlgebra);
      }, Prelude.bottom(dictBooleanAlgebra["__superclass_Prelude.Bounded_0"]()));
  };
  exports["Disj"] = Disj;
  exports["runDisj"] = runDisj;
  exports["semigroupDisj"] = semigroupDisj;
  exports["monoidDisj"] = monoidDisj;
})(PS["Data.Monoid.Disj"] = PS["Data.Monoid.Disj"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Foldable"];
  var Prelude = PS["Prelude"];
  var Control_Apply = PS["Control.Apply"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Maybe_Last = PS["Data.Maybe.Last"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];        
  var Foldable = function (foldMap, foldl, foldr) {
      this.foldMap = foldMap;
      this.foldl = foldl;
      this.foldr = foldr;
  };
  var foldr = function (dict) {
      return dict.foldr;
  };
  var traverse_ = function (dictApplicative) {
      return function (dictFoldable) {
          return function (f) {
              return foldr(dictFoldable)(function ($161) {
                  return Control_Apply["*>"](dictApplicative["__superclass_Prelude.Apply_0"]())(f($161));
              })(Prelude.pure(dictApplicative)(Prelude.unit));
          };
      };
  };
  var for_ = function (dictApplicative) {
      return function (dictFoldable) {
          return Prelude.flip(traverse_(dictApplicative)(dictFoldable));
      };
  };
  var foldl = function (dict) {
      return dict.foldl;
  }; 
  var foldMapDefaultR = function (dictFoldable) {
      return function (dictMonoid) {
          return function (f) {
              return function (xs) {
                  return foldr(dictFoldable)(function (x) {
                      return function (acc) {
                          return Prelude["<>"](dictMonoid["__superclass_Prelude.Semigroup_0"]())(f(x))(acc);
                      };
                  })(Data_Monoid.mempty(dictMonoid))(xs);
              };
          };
      };
  };
  var foldableArray = new Foldable(function (dictMonoid) {
      return foldMapDefaultR(foldableArray)(dictMonoid);
  }, $foreign.foldlArray, $foreign.foldrArray);
  var foldMap = function (dict) {
      return dict.foldMap;
  };
  var find = function (dictFoldable) {
      return function (p) {
          return foldl(dictFoldable)(function (r) {
              return function (x) {
                  var $160 = p(x);
                  if ($160) {
                      return new Data_Maybe.Just(x);
                  };
                  if (!$160) {
                      return r;
                  };
                  throw new Error("Failed pattern match at Data.Foldable line 234, column 25 - line 234, column 50: " + [ $160.constructor.name ]);
              };
          })(Data_Maybe.Nothing.value);
      };
  };
  var any = function (dictFoldable) {
      return function (dictBooleanAlgebra) {
          return function (p) {
              return function ($164) {
                  return Data_Monoid_Disj.runDisj(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictBooleanAlgebra))(function ($165) {
                      return Data_Monoid_Disj.Disj(p($165));
                  })($164));
              };
          };
      };
  };
  exports["Foldable"] = Foldable;
  exports["find"] = find;
  exports["any"] = any;
  exports["for_"] = for_;
  exports["traverse_"] = traverse_;
  exports["foldMapDefaultR"] = foldMapDefaultR;
  exports["foldMap"] = foldMap;
  exports["foldl"] = foldl;
  exports["foldr"] = foldr;
  exports["foldableArray"] = foldableArray;
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Traversable

  // jshint maxparams: 3

  exports.traverseArrayImpl = function () {
    function Cont (fn) {
      this.fn = fn;
    }

    var emptyList = {};

    var ConsCell = function (head, tail) {
      this.head = head;
      this.tail = tail;
    };

    function consList (x) {
      return function (xs) {
        return new ConsCell(x, xs);
      };
    }

    function listToArray (list) {
      var arr = [];
      while (list !== emptyList) {
        arr.push(list.head);
        list = list.tail;
      }
      return arr;
    }

    return function (apply) {
      return function (map) {
        return function (pure) {
          return function (f) {
            var buildFrom = function (x, ys) {
              return apply(map(consList)(f(x)))(ys);
            };

            var go = function (acc, currentLen, xs) {
              if (currentLen === 0) {
                return acc;
              } else {
                var last = xs[currentLen - 1];
                return new Cont(function () {
                  return go(buildFrom(last, acc), currentLen - 1, xs);
                });
              }
            };

            return function (array) {
              var result = go(pure(emptyList), array.length, array);
              while (result instanceof Cont) {
                result = result.fn();
              }

              return map(listToArray)(result);
            };
          };
        };
      };
    };
  }();
})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Traversable"];
  var Prelude = PS["Prelude"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Maybe_Last = PS["Data.Maybe.Last"];
  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
  var Traversable = function (__superclass_Data$dotFoldable$dotFoldable_1, __superclass_Prelude$dotFunctor_0, sequence, traverse) {
      this["__superclass_Data.Foldable.Foldable_1"] = __superclass_Data$dotFoldable$dotFoldable_1;
      this["__superclass_Prelude.Functor_0"] = __superclass_Prelude$dotFunctor_0;
      this.sequence = sequence;
      this.traverse = traverse;
  };
  var traverse = function (dict) {
      return dict.traverse;
  };
  var sequenceDefault = function (dictTraversable) {
      return function (dictApplicative) {
          return function (tma) {
              return traverse(dictTraversable)(dictApplicative)(Prelude.id(Prelude.categoryFn))(tma);
          };
      };
  };
  var traversableArray = new Traversable(function () {
      return Data_Foldable.foldableArray;
  }, function () {
      return Prelude.functorArray;
  }, function (dictApplicative) {
      return sequenceDefault(traversableArray)(dictApplicative);
  }, function (dictApplicative) {
      return $foreign.traverseArrayImpl(Prelude.apply(dictApplicative["__superclass_Prelude.Apply_0"]()))(Prelude.map((dictApplicative["__superclass_Prelude.Apply_0"]())["__superclass_Prelude.Functor_0"]()))(Prelude.pure(dictApplicative));
  });
  var sequence = function (dict) {
      return dict.sequence;
  }; 
  var $$for = function (dictApplicative) {
      return function (dictTraversable) {
          return function (x) {
              return function (f) {
                  return traverse(dictTraversable)(dictApplicative)(f)(x);
              };
          };
      };
  };
  exports["Traversable"] = Traversable;
  exports["for"] = $$for;
  exports["sequenceDefault"] = sequenceDefault;
  exports["sequence"] = sequence;
  exports["traverse"] = traverse;
  exports["traversableArray"] = traversableArray;
})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Extend = PS["Control.Extend"];
  var Data_Bifoldable = PS["Data.Bifoldable"];
  var Data_Bifunctor = PS["Data.Bifunctor"];
  var Data_Bitraversable = PS["Data.Bitraversable"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];        
  var Left = (function () {
      function Left(value0) {
          this.value0 = value0;
      };
      Left.create = function (value0) {
          return new Left(value0);
      };
      return Left;
  })();
  var Right = (function () {
      function Right(value0) {
          this.value0 = value0;
      };
      Right.create = function (value0) {
          return new Right(value0);
      };
      return Right;
  })();
  var functorEither = new Prelude.Functor(function (v) {
      return function (v1) {
          if (v1 instanceof Left) {
              return new Left(v1.value0);
          };
          if (v1 instanceof Right) {
              return new Right(v(v1.value0));
          };
          throw new Error("Failed pattern match at Data.Either line 53, column 3 - line 54, column 3: " + [ v.constructor.name, v1.constructor.name ]);
      };
  });
  var either = function (v) {
      return function (v1) {
          return function (v2) {
              if (v2 instanceof Left) {
                  return v(v2.value0);
              };
              if (v2 instanceof Right) {
                  return v1(v2.value0);
              };
              throw new Error("Failed pattern match at Data.Either line 29, column 1 - line 30, column 1: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
          };
      };
  }; 
  var applyEither = new Prelude.Apply(function () {
      return functorEither;
  }, function (v) {
      return function (v1) {
          if (v instanceof Left) {
              return new Left(v.value0);
          };
          if (v instanceof Right) {
              return Prelude["<$>"](functorEither)(v.value0)(v1);
          };
          throw new Error("Failed pattern match at Data.Either line 93, column 3 - line 94, column 3: " + [ v.constructor.name, v1.constructor.name ]);
      };
  });
  var bindEither = new Prelude.Bind(function () {
      return applyEither;
  }, either(function (e) {
      return function (v) {
          return new Left(e);
      };
  })(function (a) {
      return function (f) {
          return f(a);
      };
  }));
  var applicativeEither = new Prelude.Applicative(function () {
      return applyEither;
  }, Right.create);
  exports["Left"] = Left;
  exports["Right"] = Right;
  exports["either"] = either;
  exports["functorEither"] = functorEither;
  exports["applyEither"] = applyEither;
  exports["applicativeEither"] = applicativeEither;
  exports["bindEither"] = bindEither;
})(PS["Data.Either"] = PS["Data.Either"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Function"];
  var Prelude = PS["Prelude"];        
  var on = function (f) {
      return function (g) {
          return function (x) {
              return function (y) {
                  return f(g(x))(g(y));
              };
          };
      };
  };
  exports["on"] = on;
})(PS["Data.Function"] = PS["Data.Function"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Int

  exports.fromNumberImpl = function (just) {
    return function (nothing) {
      return function (n) {
        /* jshint bitwise: false */
        return (n | 0) === n ? just(n) : nothing;
      };
    };
  };

  exports.toNumber = function (n) {
    return n;
  };
})(PS["Data.Int"] = PS["Data.Int"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Maybe.Unsafe

  exports.unsafeThrow = function (msg) {
    throw new Error(msg);
  };
})(PS["Data.Maybe.Unsafe"] = PS["Data.Maybe.Unsafe"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Maybe.Unsafe"];
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];        
  var fromJust = function (v) {
      if (v instanceof Data_Maybe.Just) {
          return v.value0;
      };
      if (v instanceof Data_Maybe.Nothing) {
          return $foreign.unsafeThrow("Data.Maybe.Unsafe.fromJust called on Nothing");
      };
      throw new Error("Failed pattern match at Data.Maybe.Unsafe line 11, column 1 - line 12, column 1: " + [ v.constructor.name ]);
  };
  exports["fromJust"] = fromJust;
})(PS["Data.Maybe.Unsafe"] = PS["Data.Maybe.Unsafe"] || {});
(function(exports) {
  /* global exports */
  "use strict";          

  exports.floor = Math.floor;
})(PS["Math"] = PS["Math"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Math"];
  exports["floor"] = $foreign.floor;
})(PS["Math"] = PS["Math"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Int"];
  var Prelude = PS["Prelude"];
  var Data_Int_Bits = PS["Data.Int.Bits"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var $$Math = PS["Math"];                                                                   
  var fromNumber = $foreign.fromNumberImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var unsafeClamp = function (x) {
      if (x >= $foreign.toNumber(Prelude.top(Prelude.boundedInt))) {
          return Prelude.top(Prelude.boundedInt);
      };
      if (x <= $foreign.toNumber(Prelude.bottom(Prelude.boundedInt))) {
          return Prelude.bottom(Prelude.boundedInt);
      };
      if (Prelude.otherwise) {
          return Data_Maybe_Unsafe.fromJust(fromNumber(x));
      };
      throw new Error("Failed pattern match at Data.Int line 49, column 1 - line 56, column 1: " + [ x.constructor.name ]);
  };
  var floor = function ($2) {
      return unsafeClamp($$Math.floor($2));
  };
  exports["floor"] = floor;
  exports["fromNumber"] = fromNumber;
  exports["toNumber"] = $foreign.toNumber;
})(PS["Data.Int"] = PS["Data.Int"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports._toChar = function (just) {
    return function (nothing) {
      return function (s) {
        return s.length === 1 ? just(s) : nothing;
      };
    };
  };

  exports.length = function (s) {
    return s.length;
  };

  exports.replace = function (s1) {
    return function (s2) {
      return function (s3) {
        return s3.replace(s1, s2);
      };
    };
  };

  exports.take = function (n) {
    return function (s) {
      return s.substr(0, n);
    };
  };

  exports.drop = function (n) {
    return function (s) {
      return s.substr(n);
    };
  };

  exports.joinWith = function (s) {
    return function (xs) {
      return xs.join(s);
    };
  };
})(PS["Data.String"] = PS["Data.String"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.String"];
  var Prelude = PS["Prelude"];
  var Data_Char = PS["Data.Char"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_String_Unsafe = PS["Data.String.Unsafe"];
  var toChar = $foreign._toChar(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  exports["toChar"] = toChar;
  exports["joinWith"] = $foreign.joinWith;
  exports["drop"] = $foreign.drop;
  exports["take"] = $foreign.take;
  exports["replace"] = $foreign.replace;
  exports["length"] = $foreign.length;
})(PS["Data.String"] = PS["Data.String"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Foreign"];
  var Prelude = PS["Prelude"];
  var Data_Either = PS["Data.Either"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Function = PS["Data.Function"];
  var Data_Int_1 = PS["Data.Int"];
  var Data_Int_1 = PS["Data.Int"];
  var Data_String = PS["Data.String"];        
  var TypeMismatch = (function () {
      function TypeMismatch(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      TypeMismatch.create = function (value0) {
          return function (value1) {
              return new TypeMismatch(value0, value1);
          };
      };
      return TypeMismatch;
  })();
  var ErrorAtIndex = (function () {
      function ErrorAtIndex(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ErrorAtIndex.create = function (value0) {
          return function (value1) {
              return new ErrorAtIndex(value0, value1);
          };
      };
      return ErrorAtIndex;
  })();
  var ErrorAtProperty = (function () {
      function ErrorAtProperty(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ErrorAtProperty.create = function (value0) {
          return function (value1) {
              return new ErrorAtProperty(value0, value1);
          };
      };
      return ErrorAtProperty;
  })();
  var JSONError = (function () {
      function JSONError(value0) {
          this.value0 = value0;
      };
      JSONError.create = function (value0) {
          return new JSONError(value0);
      };
      return JSONError;
  })();
  var unsafeReadTagged = function (tag) {
      return function (value) {
          if ($foreign.tagOf(value) === tag) {
              return Prelude.pure(Data_Either.applicativeEither)($foreign.unsafeFromForeign(value));
          };
          return new Data_Either.Left(new TypeMismatch(tag, $foreign.tagOf(value)));
      };
  };
  var showForeignError = new Prelude.Show(function (v) {
      if (v instanceof TypeMismatch) {
          return "Type mismatch: expected " + (v.value0 + (", found " + v.value1));
      };
      if (v instanceof ErrorAtIndex) {
          return "Error at array index " + (Prelude.show(Prelude.showInt)(v.value0) + (": " + Prelude.show(showForeignError)(v.value1)));
      };
      if (v instanceof ErrorAtProperty) {
          return "Error at property " + (Prelude.show(Prelude.showString)(v.value0) + (": " + Prelude.show(showForeignError)(v.value1)));
      };
      if (v instanceof JSONError) {
          return "JSON error: " + v.value0;
      };
      throw new Error("Failed pattern match at Data.Foreign line 54, column 3 - line 55, column 3: " + [ v.constructor.name ]);
  });
  var readString = unsafeReadTagged("String");
  var readNumber = unsafeReadTagged("Number");
  var readInt = function (value) {
      var error = Data_Either.Left.create(new TypeMismatch("Int", $foreign.tagOf(value)));
      var fromNumber = function ($30) {
          return Data_Maybe.maybe(error)(Prelude.pure(Data_Either.applicativeEither))(Data_Int_1.fromNumber($30));
      };
      return Data_Either.either(Prelude["const"](error))(fromNumber)(readNumber(value));
  };
  var readChar = function (value) {
      var error = Data_Either.Left.create(new TypeMismatch("Char", $foreign.tagOf(value)));
      var fromString = function ($31) {
          return Data_Maybe.maybe(error)(Prelude.pure(Data_Either.applicativeEither))(Data_String.toChar($31));
      };
      return Data_Either.either(Prelude["const"](error))(fromString)(readString(value));
  };
  var readBoolean = unsafeReadTagged("Boolean");
  var readArray = function (value) {
      if ($foreign.isArray(value)) {
          return Prelude.pure(Data_Either.applicativeEither)($foreign.unsafeFromForeign(value));
      };
      return new Data_Either.Left(new TypeMismatch("array", $foreign.tagOf(value)));
  };
  var parseJSON = function (json) {
      return $foreign.parseJSONImpl(function ($32) {
          return Data_Either.Left.create(JSONError.create($32));
      }, Data_Either.Right.create, json);
  };
  exports["TypeMismatch"] = TypeMismatch;
  exports["ErrorAtIndex"] = ErrorAtIndex;
  exports["ErrorAtProperty"] = ErrorAtProperty;
  exports["JSONError"] = JSONError;
  exports["readArray"] = readArray;
  exports["readInt"] = readInt;
  exports["readNumber"] = readNumber;
  exports["readBoolean"] = readBoolean;
  exports["readChar"] = readChar;
  exports["readString"] = readString;
  exports["unsafeReadTagged"] = unsafeReadTagged;
  exports["parseJSON"] = parseJSON;
  exports["showForeignError"] = showForeignError;
  exports["isUndefined"] = $foreign.isUndefined;
  exports["isNull"] = $foreign.isNull;
  exports["typeOf"] = $foreign.typeOf;
  exports["unsafeFromForeign"] = $foreign.unsafeFromForeign;
  exports["toForeign"] = $foreign.toForeign;
})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  //------------------------------------------------------------------------------
  // Array size ------------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.length = function (xs) {
    return xs.length;
  };

  exports.snoc = function (l) {
    return function (e) {
      var l1 = l.slice();
      l1.push(e);
      return l1;
    };
  };

  //------------------------------------------------------------------------------
  // Indexed operations ----------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.indexImpl = function (just) {
    return function (nothing) {
      return function (xs) {
        return function (i) {
          return i < 0 || i >= xs.length ? nothing :  just(xs[i]);
        };
      };
    };
  };

  exports.findIndexImpl = function (just) {
    return function (nothing) {
      return function (f) {
        return function (xs) {
          for (var i = 0, l = xs.length; i < l; i++) {
            if (f(xs[i])) return just(i);
          }
          return nothing;
        };
      };
    };
  };

  exports.filter = function (f) {
    return function (xs) {
      return xs.filter(f);
    };
  };

  //------------------------------------------------------------------------------
  // Sorting ---------------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.sortImpl = function (f) {
    return function (l) {
      /* jshint maxparams: 2 */
      return l.slice().sort(function (x, y) {
        return f(x)(y);
      });
    };
  };

  //------------------------------------------------------------------------------
  // Subarrays -------------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.slice = function (s) {
    return function (e) {
      return function (l) {
        return l.slice(s, e);
      };
    };
  };

  //------------------------------------------------------------------------------
  // Zipping ---------------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.zipWith = function (f) {
    return function (xs) {
      return function (ys) {
        var l = xs.length < ys.length ? xs.length : ys.length;
        var result = new Array(l);
        for (var i = 0; i < l; i++) {
          result[i] = f(xs[i])(ys[i]);
        }
        return result;
      };
    };
  };
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Biapplicative = PS["Control.Biapplicative"];
  var Control_Biapply = PS["Control.Biapply"];
  var Control_Comonad = PS["Control.Comonad"];
  var Control_Extend = PS["Control.Extend"];
  var Control_Lazy = PS["Control.Lazy"];
  var Data_Bifoldable = PS["Data.Bifoldable"];
  var Data_Bifunctor = PS["Data.Bifunctor"];
  var Data_Bitraversable = PS["Data.Bitraversable"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];        
  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 snd = function (v) {
      return v.value1;
  }; 
  var semigroupTuple = function (dictSemigroup) {
      return function (dictSemigroup1) {
          return new Prelude.Semigroup(function (v) {
              return function (v1) {
                  return new Tuple(Prelude["<>"](dictSemigroup)(v.value0)(v1.value0), Prelude["<>"](dictSemigroup1)(v.value1)(v1.value1));
              };
          });
      };
  };
  var monoidTuple = function (dictMonoid) {
      return function (dictMonoid1) {
          return new Data_Monoid.Monoid(function () {
              return semigroupTuple(dictMonoid["__superclass_Prelude.Semigroup_0"]())(dictMonoid1["__superclass_Prelude.Semigroup_0"]());
          }, new Tuple(Data_Monoid.mempty(dictMonoid), Data_Monoid.mempty(dictMonoid1)));
      };
  };                                                                                                    
  var fst = function (v) {
      return v.value0;
  };
  exports["Tuple"] = Tuple;
  exports["snd"] = snd;
  exports["fst"] = fst;
  exports["semigroupTuple"] = semigroupTuple;
  exports["monoidTuple"] = monoidTuple;
})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Array"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Lazy = PS["Control.Lazy"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var zipWithA = function (dictApplicative) {
      return function (f) {
          return function (xs) {
              return function (ys) {
                  return Data_Traversable.sequence(Data_Traversable.traversableArray)(dictApplicative)($foreign.zipWith(f)(xs)(ys));
              };
          };
      };
  };
  var sortBy = function (comp) {
      return function (xs) {
          var comp$prime = function (x) {
              return function (y) {
                  var $46 = comp(x)(y);
                  if ($46 instanceof Prelude.GT) {
                      return 1;
                  };
                  if ($46 instanceof Prelude.EQ) {
                      return 0;
                  };
                  if ($46 instanceof Prelude.LT) {
                      return -1;
                  };
                  throw new Error("Failed pattern match at Data.Array line 417, column 15 - line 422, column 1: " + [ $46.constructor.name ]);
              };
          };
          return $foreign.sortImpl(comp$prime)(xs);
      };
  };
  var sort = function (dictOrd) {
      return function (xs) {
          return sortBy(Prelude.compare(dictOrd))(xs);
      };
  };
  var index = $foreign.indexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var $bang$bang = index;
  var findIndex = $foreign.findIndexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var elemIndex = function (dictEq) {
      return function (x) {
          return findIndex(function (v) {
              return Prelude["=="](dictEq)(v)(x);
          });
      };
  };
  exports["zipWithA"] = zipWithA;
  exports["sortBy"] = sortBy;
  exports["sort"] = sort;
  exports["findIndex"] = findIndex;
  exports["elemIndex"] = elemIndex;
  exports["index"] = index;
  exports["!!"] = $bang$bang;
  exports["zipWith"] = $foreign.zipWith;
  exports["filter"] = $foreign.filter;
  exports["snoc"] = $foreign.snoc;
  exports["length"] = $foreign.length;
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Foreign.Index

  // jshint maxparams: 4
  exports.unsafeReadPropImpl = function (f, s, key, value) {
    return value == null ? f : s(value[key]);
  };

  // jshint maxparams: 2
  exports.unsafeHasOwnProperty = function (prop, value) {
    return Object.prototype.hasOwnProperty.call(value, prop);
  };

  exports.unsafeHasProperty = function (prop, value) {
    return prop in value;
  };
})(PS["Data.Foreign.Index"] = PS["Data.Foreign.Index"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Foreign.Index"];
  var Prelude = PS["Prelude"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Function = PS["Data.Function"];
  var Data_Int = PS["Data.Int"];        
  var Index = function (errorAt, hasOwnProperty, hasProperty, ix) {
      this.errorAt = errorAt;
      this.hasOwnProperty = hasOwnProperty;
      this.hasProperty = hasProperty;
      this.ix = ix;
  };
  var unsafeReadProp = function (k) {
      return function (value) {
          return $foreign.unsafeReadPropImpl(new Data_Either.Left(new Data_Foreign.TypeMismatch("object", Data_Foreign.typeOf(value))), Prelude.pure(Data_Either.applicativeEither), k, value);
      };
  };
  var prop = unsafeReadProp;
  var ix = function (dict) {
      return dict.ix;
  };
  var $bang = function (dictIndex) {
      return ix(dictIndex);
  };                         
  var hasPropertyImpl = function (v) {
      return function (value) {
          if (Data_Foreign.isNull(value)) {
              return false;
          };
          if (Data_Foreign.isUndefined(value)) {
              return false;
          };
          if (Data_Foreign.typeOf(value) === "object" || Data_Foreign.typeOf(value) === "function") {
              return $foreign.unsafeHasProperty(v, value);
          };
          return false;
      };
  };
  var hasProperty = function (dict) {
      return dict.hasProperty;
  };
  var hasOwnPropertyImpl = function (v) {
      return function (value) {
          if (Data_Foreign.isNull(value)) {
              return false;
          };
          if (Data_Foreign.isUndefined(value)) {
              return false;
          };
          if (Data_Foreign.typeOf(value) === "object" || Data_Foreign.typeOf(value) === "function") {
              return $foreign.unsafeHasOwnProperty(v, value);
          };
          return false;
      };
  };                                                                                                                   
  var indexString = new Index(Data_Foreign.ErrorAtProperty.create, hasOwnPropertyImpl, hasPropertyImpl, Prelude.flip(prop));
  var hasOwnProperty = function (dict) {
      return dict.hasOwnProperty;
  };
  var errorAt = function (dict) {
      return dict.errorAt;
  };
  exports["Index"] = Index;
  exports["errorAt"] = errorAt;
  exports["hasOwnProperty"] = hasOwnProperty;
  exports["hasProperty"] = hasProperty;
  exports["!"] = $bang;
  exports["ix"] = ix;
  exports["prop"] = prop;
  exports["indexString"] = indexString;
})(PS["Data.Foreign.Index"] = PS["Data.Foreign.Index"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Array = PS["Data.Array"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Foreign_Null = PS["Data.Foreign.Null"];
  var Data_Foreign_NullOrUndefined = PS["Data.Foreign.NullOrUndefined"];
  var Data_Foreign_Undefined = PS["Data.Foreign.Undefined"];
  var Data_Int = PS["Data.Int"];
  var Data_Traversable = PS["Data.Traversable"];        
  var IsForeign = function (read) {
      this.read = read;
  };
  var stringIsForeign = new IsForeign(Data_Foreign.readString);
  var read = function (dict) {
      return dict.read;
  };
  var readWith = function (dictIsForeign) {
      return function (f) {
          return function (value) {
              return Data_Either.either(function ($8) {
                  return Data_Either.Left.create(f($8));
              })(Data_Either.Right.create)(read(dictIsForeign)(value));
          };
      };
  };
  var readProp = function (dictIsForeign) {
      return function (dictIndex) {
          return function (prop) {
              return function (value) {
                  return Prelude[">>="](Data_Either.bindEither)(Data_Foreign_Index["!"](dictIndex)(value)(prop))(readWith(dictIsForeign)(Data_Foreign_Index.errorAt(dictIndex)(prop)));
              };
          };
      };
  };
  var intIsForeign = new IsForeign(Data_Foreign.readInt);
  var foreignIsForeign = new IsForeign(function (f) {
      return Prelude["return"](Data_Either.applicativeEither)(f);
  });
  exports["IsForeign"] = IsForeign;
  exports["readProp"] = readProp;
  exports["readWith"] = readWith;
  exports["read"] = read;
  exports["foreignIsForeign"] = foreignIsForeign;
  exports["stringIsForeign"] = stringIsForeign;
  exports["intIsForeign"] = intIsForeign;
})(PS["Data.Foreign.Class"] = PS["Data.Foreign.Class"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Generic


  //------------------------------------------------------------------------------
  // Zipping ---------------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.zipAll = function(f) {
      return function(xs) {
          return function(ys) {
              var l = xs.length < ys.length ? xs.length : ys.length;
              for (var i = 0; i < l; i++) {
                  if (!f(xs[i])(ys[i])) {
                      return false;
                  }
              }
              return true;
          };
      };
  };
})(PS["Data.Generic"] = PS["Data.Generic"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $$Proxy = (function () {
      function Proxy() {

      };
      Proxy.value = new Proxy();
      return Proxy;
  })();
  exports["Proxy"] = $$Proxy;
})(PS["Type.Proxy"] = PS["Type.Proxy"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Generic"];
  var Prelude = PS["Prelude"];
  var Data_Either = PS["Data.Either"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Array = PS["Data.Array"];
  var Data_String = PS["Data.String"];
  var Type_Proxy = PS["Type.Proxy"];        
  var SProd = (function () {
      function SProd(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      SProd.create = function (value0) {
          return function (value1) {
              return new SProd(value0, value1);
          };
      };
      return SProd;
  })();
  var SRecord = (function () {
      function SRecord(value0) {
          this.value0 = value0;
      };
      SRecord.create = function (value0) {
          return new SRecord(value0);
      };
      return SRecord;
  })();
  var SNumber = (function () {
      function SNumber(value0) {
          this.value0 = value0;
      };
      SNumber.create = function (value0) {
          return new SNumber(value0);
      };
      return SNumber;
  })();
  var SBoolean = (function () {
      function SBoolean(value0) {
          this.value0 = value0;
      };
      SBoolean.create = function (value0) {
          return new SBoolean(value0);
      };
      return SBoolean;
  })();
  var SInt = (function () {
      function SInt(value0) {
          this.value0 = value0;
      };
      SInt.create = function (value0) {
          return new SInt(value0);
      };
      return SInt;
  })();
  var SString = (function () {
      function SString(value0) {
          this.value0 = value0;
      };
      SString.create = function (value0) {
          return new SString(value0);
      };
      return SString;
  })();
  var SChar = (function () {
      function SChar(value0) {
          this.value0 = value0;
      };
      SChar.create = function (value0) {
          return new SChar(value0);
      };
      return SChar;
  })();
  var SArray = (function () {
      function SArray(value0) {
          this.value0 = value0;
      };
      SArray.create = function (value0) {
          return new SArray(value0);
      };
      return SArray;
  })();
  var SigProd = (function () {
      function SigProd(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      SigProd.create = function (value0) {
          return function (value1) {
              return new SigProd(value0, value1);
          };
      };
      return SigProd;
  })();
  var SigRecord = (function () {
      function SigRecord(value0) {
          this.value0 = value0;
      };
      SigRecord.create = function (value0) {
          return new SigRecord(value0);
      };
      return SigRecord;
  })();
  var SigNumber = (function () {
      function SigNumber() {

      };
      SigNumber.value = new SigNumber();
      return SigNumber;
  })();
  var SigBoolean = (function () {
      function SigBoolean() {

      };
      SigBoolean.value = new SigBoolean();
      return SigBoolean;
  })();
  var SigInt = (function () {
      function SigInt() {

      };
      SigInt.value = new SigInt();
      return SigInt;
  })();
  var SigString = (function () {
      function SigString() {

      };
      SigString.value = new SigString();
      return SigString;
  })();
  var SigChar = (function () {
      function SigChar() {

      };
      SigChar.value = new SigChar();
      return SigChar;
  })();
  var SigArray = (function () {
      function SigArray(value0) {
          this.value0 = value0;
      };
      SigArray.create = function (value0) {
          return new SigArray(value0);
      };
      return SigArray;
  })();
  var Generic = function (fromSpine, toSignature, toSpine) {
      this.fromSpine = fromSpine;
      this.toSignature = toSignature;
      this.toSpine = toSpine;
  };
  var toSpine = function (dict) {
      return dict.toSpine;
  };
  var toSignature = function (dict) {
      return dict.toSignature;
  };
  var genericUnit = new Generic(function (v) {
      if (v instanceof SProd && (v.value0 === "Prelude.Unit" && v.value1.length === 0)) {
          return new Data_Maybe.Just(Prelude.unit);
      };
      return Data_Maybe.Nothing.value;
  }, function (x) {
      return new SigProd("Prelude.Unit", [ {
          sigConstructor: "Prelude.Unit", 
          sigValues: [  ]
      } ]);
  }, function (x) {
      return new SProd("Prelude.Unit", [  ]);
  });
  var genericString = new Generic(function (v) {
      if (v instanceof SString) {
          return new Data_Maybe.Just(v.value0);
      };
      return Data_Maybe.Nothing.value;
  }, function (v) {
      return SigString.value;
  }, function (x) {
      return new SString(x);
  });
  var genericNumber = new Generic(function (v) {
      if (v instanceof SNumber) {
          return new Data_Maybe.Just(v.value0);
      };
      return Data_Maybe.Nothing.value;
  }, function (v) {
      return SigNumber.value;
  }, function (x) {
      return new SNumber(x);
  });
  var genericInt = new Generic(function (v) {
      if (v instanceof SInt) {
          return new Data_Maybe.Just(v.value0);
      };
      return Data_Maybe.Nothing.value;
  }, function (v) {
      return SigInt.value;
  }, function (x) {
      return new SInt(x);
  });
  var fromSpine = function (dict) {
      return dict.fromSpine;
  };
  var eqGeneric = new Prelude.Eq(function (v) {
      return function (v1) {
          if (v instanceof SProd && v1 instanceof SProd) {
              return v.value0 === v1.value0 && (Data_Array.length(v.value1) === Data_Array.length(v1.value1) && $foreign.zipAll(function (x) {
                  return function (y) {
                      return Prelude["=="](eqGeneric)(x(Prelude.unit))(y(Prelude.unit));
                  };
              })(v.value1)(v1.value1));
          };
          if (v instanceof SRecord && v1 instanceof SRecord) {
              var go = function (x) {
                  return function (y) {
                      return x.recLabel === y.recLabel && Prelude["=="](eqGeneric)(x.recValue(Prelude.unit))(y.recValue(Prelude.unit));
                  };
              };
              return Data_Array.length(v.value0) === Data_Array.length(v1.value0) && $foreign.zipAll(go)(v.value0)(v1.value0);
          };
          if (v instanceof SInt && v1 instanceof SInt) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SNumber && v1 instanceof SNumber) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SBoolean && v1 instanceof SBoolean) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SChar && v1 instanceof SChar) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SString && v1 instanceof SString) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SArray && v1 instanceof SArray) {
              return Data_Array.length(v.value0) === Data_Array.length(v1.value0) && $foreign.zipAll(function (x) {
                  return function (y) {
                      return Prelude["=="](eqGeneric)(x(Prelude.unit))(y(Prelude.unit));
                  };
              })(v.value0)(v1.value0);
          };
          return false;
      };
  });
  var gEq = function (dictGeneric) {
      return function (x) {
          return function (y) {
              return Prelude["=="](eqGeneric)(toSpine(dictGeneric)(x))(toSpine(dictGeneric)(y));
          };
      };
  };
  var anyProxy = (Type_Proxy["Proxy"]).value;
  var genericArray = function (dictGeneric) {
      return new Generic(function (v) {
          if (v instanceof SArray) {
              return Data_Traversable.traverse(Data_Traversable.traversableArray)(Data_Maybe.applicativeMaybe)(function ($188) {
                  return fromSpine(dictGeneric)((function (v1) {
                      return v1(Prelude.unit);
                  })($188));
              })(v.value0);
          };
          return Data_Maybe.Nothing.value;
      }, function (x) {
          var lowerProxy = function (v) {
              return anyProxy;
          };
          return new SigArray(function (unit) {
              return toSignature(dictGeneric)(lowerProxy(x));
          });
      }, function (xs) {
          return new SArray(Prelude["<$>"](Prelude.functorArray)(function (x) {
              return function (y) {
                  return toSpine(dictGeneric)(x);
              };
          })(xs));
      });
  };
  var genericMaybe = function (dictGeneric) {
      return new Generic(function (v) {
          if (v instanceof SProd && (v.value0 === "Data.Maybe.Just" && v.value1.length === 1)) {
              return Prelude["<$>"](Data_Maybe.functorMaybe)(Data_Maybe.Just.create)(fromSpine(dictGeneric)(v.value1[0](Prelude.unit)));
          };
          if (v instanceof SProd && (v.value0 === "Data.Maybe.Nothing" && v.value1.length === 0)) {
              return Prelude["return"](Data_Maybe.applicativeMaybe)(Data_Maybe.Nothing.value);
          };
          return Data_Maybe.Nothing.value;
      }, function (x) {
          var mbProxy = function (v) {
              return anyProxy;
          };
          return new SigProd("Data.Maybe.Maybe", [ {
              sigConstructor: "Data.Maybe.Just", 
              sigValues: [ function (u) {
                  return toSignature(dictGeneric)(mbProxy(x));
              } ]
          }, {
              sigConstructor: "Data.Maybe.Nothing", 
              sigValues: [  ]
          } ]);
      }, function (v) {
          if (v instanceof Data_Maybe.Just) {
              return new SProd("Data.Maybe.Just", [ function (u) {
                  return toSpine(dictGeneric)(v.value0);
              } ]);
          };
          if (v instanceof Data_Maybe.Nothing) {
              return new SProd("Data.Maybe.Nothing", [  ]);
          };
          throw new Error("Failed pattern match at Data.Generic line 137, column 7 - line 138, column 7: " + [ v.constructor.name ]);
      });
  };
  exports["SigProd"] = SigProd;
  exports["SigRecord"] = SigRecord;
  exports["SigNumber"] = SigNumber;
  exports["SigBoolean"] = SigBoolean;
  exports["SigInt"] = SigInt;
  exports["SigString"] = SigString;
  exports["SigChar"] = SigChar;
  exports["SigArray"] = SigArray;
  exports["SProd"] = SProd;
  exports["SRecord"] = SRecord;
  exports["SNumber"] = SNumber;
  exports["SBoolean"] = SBoolean;
  exports["SInt"] = SInt;
  exports["SString"] = SString;
  exports["SChar"] = SChar;
  exports["SArray"] = SArray;
  exports["Generic"] = Generic;
  exports["gEq"] = gEq;
  exports["fromSpine"] = fromSpine;
  exports["toSignature"] = toSignature;
  exports["toSpine"] = toSpine;
  exports["genericNumber"] = genericNumber;
  exports["genericInt"] = genericInt;
  exports["genericString"] = genericString;
  exports["genericArray"] = genericArray;
  exports["genericMaybe"] = genericMaybe;
  exports["genericUnit"] = genericUnit;
  exports["eqGeneric"] = eqGeneric;
})(PS["Data.Generic"] = PS["Data.Generic"] || {});
(function(exports) {
    "use strict";
  var path =require("path"); 

  exports.normalize = path.normalize;

  exports.concat = function (segments) {
    return path.join.apply(this, segments);
  };

  exports.basename = path.basename;
})(PS["Node.Path"] = PS["Node.Path"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.Path"];
  exports["basename"] = $foreign.basename;
  exports["concat"] = $foreign.concat;
  exports["normalize"] = $foreign.normalize;
})(PS["Node.Path"] = PS["Node.Path"] || {});
(function(exports) {
    "use strict";
  // module Node.Process

  /* global exports */
  /* global process */

  exports.process = process;
})(PS["Node.Process"] = PS["Node.Process"] || {});
(function(exports) {
  /* global exports, console */
  "use strict";

  // module Control.Monad.Eff.Console

  exports.log = function (s) {
    return function () {
      console.log(s);
      return {};
    };
  };
})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff.Console"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  exports["log"] = $foreign.log;
})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Control.Monad.Eff.Exception

  exports.showErrorImpl = function (err) {
    return err.stack || err.toString();
  };

  exports.error = function (msg) {
    return new Error(msg);
  };

  exports.message = function (e) {
    return e.message;
  };

  exports.stackImpl = function (just) {
    return function (nothing) {
      return function (e) {
        return e.stack ? just(e.stack) : nothing;
      };
    };
  };

  exports.throwException = function (e) {
    return function () {
      throw e;
    };
  };
})(PS["Control.Monad.Eff.Exception"] = PS["Control.Monad.Eff.Exception"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff.Exception"];
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var stack = $foreign.stackImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var showError = new Prelude.Show($foreign.showErrorImpl);
  exports["stack"] = stack;
  exports["showError"] = showError;
  exports["throwException"] = $foreign.throwException;
  exports["message"] = $foreign.message;
  exports["error"] = $foreign.error;
})(PS["Control.Monad.Eff.Exception"] = PS["Control.Monad.Eff.Exception"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports._copyEff = function (m) {
    return function () {
      var r = {};
      for (var k in m) {
        if (m.hasOwnProperty(k)) {
          r[k] = m[k];
        }
      }
      return r;
    };
  };

  exports.empty = {};

  exports.runST = function (f) {
    return f;
  };

  function _collect (f) {
    return function (m) {
      var r = [];
      for (var k in m) {
        if (m.hasOwnProperty(k)) {
          r.push(f(k)(m[k]));
        }
      }
      return r;
    };
  }

  exports._collect = _collect;

  exports.keys = Object.keys || _collect(function (k) {
    return function () { return k; };
  });
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Lazy = PS["Control.Lazy"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Unfoldable = PS["Data.Unfoldable"];        
  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 singleton = function (a) {
      return new Cons(a, Nil.value);
  };
  var fromFoldable = function (dictFoldable) {
      return Data_Foldable.foldr(dictFoldable)(Cons.create)(Nil.value);
  };
  var toList = function (dictFoldable) {
      return fromFoldable(dictFoldable);
  };
  var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
      return function (f) {
          return Data_Foldable.foldl(foldableList)(function (acc) {
              return function ($374) {
                  return Prelude.append(dictMonoid["__superclass_Prelude.Semigroup_0"]())(acc)(f($374));
              };
          })(Data_Monoid.mempty(dictMonoid));
      };
  }, (function () {
      var go = function (__copy_v) {
          return function (__copy_b) {
              return function (__copy_v1) {
                  var v = __copy_v;
                  var b = __copy_b;
                  var v1 = __copy_v1;
                  tco: while (true) {
                      if (v1 instanceof Nil) {
                          return b;
                      };
                      if (v1 instanceof Cons) {
                          var __tco_v = v;
                          var __tco_b = v(b)(v1.value0);
                          var __tco_v1 = v1.value1;
                          v = __tco_v;
                          b = __tco_b;
                          v1 = __tco_v1;
                          continue tco;
                      };
                      throw new Error("Failed pattern match at Data.List line 767, column 3 - line 771, column 3: " + [ v.constructor.name, b.constructor.name, v1.constructor.name ]);
                  };
              };
          };
      };
      return go;
  })(), function (v) {
      return function (b) {
          return function (v1) {
              if (v1 instanceof Nil) {
                  return b;
              };
              if (v1 instanceof Cons) {
                  return v(v1.value0)(Data_Foldable.foldr(foldableList)(v)(b)(v1.value1));
              };
              throw new Error("Failed pattern match at Data.List line 765, column 3 - line 766, column 3: " + [ v.constructor.name, b.constructor.name, v1.constructor.name ]);
          };
      };
  });
  exports["Nil"] = Nil;
  exports["Cons"] = Cons;
  exports["toList"] = toList;
  exports["singleton"] = singleton;
  exports["fromFoldable"] = fromFoldable;
  exports["foldableList"] = foldableList;
})(PS["Data.List"] = PS["Data.List"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.StrMap.ST

  exports["new"] = function () {
    return {};
  };

  exports.poke = function (m) {
    return function (k) {
      return function (v) {
        return function () {
          m[k] = v;
          return m;
        };
      };
    };
  };
})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.StrMap.ST"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_ST = PS["Control.Monad.ST"];
  var Data_Maybe = PS["Data.Maybe"];
  exports["poke"] = $foreign.poke;
  exports["new"] = $foreign["new"];
})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.StrMap"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_List = PS["Data.List"];
  var Control_Monad_ST = PS["Control.Monad.ST"];
  var Data_StrMap_ST = PS["Data.StrMap.ST"];
  var thawST = $foreign._copyEff;
  var pureST = function (f) {
      return Control_Monad_Eff.runPure($foreign.runST(f));
  };
  var mutate = function (f) {
      return function (m) {
          return pureST(function __do() {
              var v = thawST(m)();
              f(v)();
              return v;
          });
      };
  }; 
  var insert = function (k) {
      return function (v) {
          return mutate(function (s) {
              return Data_StrMap_ST.poke(s)(k)(v);
          });
      };
  };                                                          
  var fromFoldable = function (dictFoldable) {
      return function (l) {
          return pureST(function __do() {
              var v = Data_StrMap_ST["new"]();
              Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(dictFoldable)(l)(function (v1) {
                  return Data_StrMap_ST.poke(v)(v1.value0)(v1.value1);
              })();
              return v;
          });
      };
  };
  var fromList = fromFoldable(Data_List.foldableList);
  exports["thawST"] = thawST;
  exports["fromList"] = fromList;
  exports["fromFoldable"] = fromFoldable;
  exports["insert"] = insert;
  exports["keys"] = $foreign.keys;
  exports["empty"] = $foreign.empty;
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
    "use strict";

  // module Unsafe.Coerce

  exports.unsafeCoerce = function(x) { return x; }
})(PS["Unsafe.Coerce"] = PS["Unsafe.Coerce"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Unsafe.Coerce"];
  exports["unsafeCoerce"] = $foreign.unsafeCoerce;
})(PS["Unsafe.Coerce"] = PS["Unsafe.Coerce"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.Process"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var Data_StrMap_1 = PS["Data.StrMap"];
  var Data_StrMap_1 = PS["Data.StrMap"];
  var Data_Posix = PS["Data.Posix"];
  var Data_Posix_Signal_1 = PS["Data.Posix.Signal"];
  var Data_Posix_Signal_1 = PS["Data.Posix.Signal"];
  var Node_Stream = PS["Node.Stream"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var Node_Platform_1 = PS["Node.Platform"];
  var Node_Platform_1 = PS["Node.Platform"];
  var cwd = $foreign.process.cwd;
  exports["cwd"] = cwd;
})(PS["Node.Process"] = PS["Node.Process"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["App.Config"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Node_FS = PS["Node.FS"];
  var Node_Path = PS["Node.Path"];
  var Node_Process = PS["Node.Process"];
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];        
  var WorkerConfig = (function () {
      function WorkerConfig(value0) {
          this.value0 = value0;
      };
      WorkerConfig.create = function (value0) {
          return new WorkerConfig(value0);
      };
      return WorkerConfig;
  })();
  var isForeignWorkerConfig = new Data_Foreign_Class.IsForeign(function (f) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("webservice")(f))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("photoprogramfullpath")(f))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("photoprogram")(f))(function (v2) {
                  return Prelude["return"](Data_Either.applicativeEither)(new WorkerConfig({
                      webServiceHost: v, 
                      photoProgramFullPath: v1, 
                      photoProgramExe: v2
                  }));
              });
          });
      });
  });
  var readConfigFile = function __do() {
      var v = Node_Process.cwd();
      return Prelude["<$>"](Control_Monad_Eff.functorEff)(Data_Foreign_Class.read(isForeignWorkerConfig))($foreign.requireConfigFile(Node_Path.concat([ v, "config.json" ])))();
  };
  exports["WorkerConfig"] = WorkerConfig;
  exports["readConfigFile"] = readConfigFile;
  exports["isForeignWorkerConfig"] = isForeignWorkerConfig;
})(PS["App.Config"] = PS["App.Config"] || {});
(function(exports) {
    "use strict";

  //module App.Model.Date
  /*eslint-env node*/

  exports.toISOString = function iso8601(d){
    return d.toISOString();
  };
})(PS["App.Model.Date"] = PS["App.Model.Date"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.nowImpl = function (ctor) {
    return function () {
      return ctor(new Date());
    };
  };

  exports.jsDateConstructor = function (x) {
    return new Date(x);
  };

  // jshint maxparams: 2
  exports.jsDateMethod = function (method, date) {
    return date[method]();
  };

  // jshint maxparams: 3
  exports.strictJsDate = function (just, nothing, s) {
    var epoch = Date.parse(s);
    if (isNaN(epoch)) return nothing;
    var date = new Date(epoch);
    var s2 = date.toISOString();
    var idx = s2.indexOf(s);
    return idx < 0 ? nothing : just(date);
  };
})(PS["Data.Date"] = PS["Data.Date"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Maybe = PS["Data.Maybe"];
  var Milliseconds = function (x) {
      return x;
  }; 
  var genericMilliseconds = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "Data.Time.Milliseconds" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Milliseconds))(Data_Generic.fromSpine(Data_Generic.genericNumber)(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("Data.Time.Milliseconds", [ {
          sigConstructor: "Data.Time.Milliseconds", 
          sigValues: [ function ($dollarq1) {
              return Data_Generic.toSignature(Data_Generic.genericNumber)(Data_Generic.anyProxy);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("Data.Time.Milliseconds", [ function ($dollarq) {
          return Data_Generic.toSpine(Data_Generic.genericNumber)(v);
      } ]);
  });
  exports["Milliseconds"] = Milliseconds;
  exports["genericMilliseconds"] = genericMilliseconds;
})(PS["Data.Time"] = PS["Data.Time"] || {});
(function(exports) {
  /* globals exports */
  "use strict";     

  exports.isNaN = isNaN;        
  exports.encodeURI = encodeURI;
})(PS["Global"] = PS["Global"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Global"];
  exports["encodeURI"] = $foreign["encodeURI"];
  exports["isNaN"] = $foreign["isNaN"];
})(PS["Global"] = PS["Global"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Date"];
  var Prelude = PS["Prelude"];
  var Type_Proxy = PS["Type.Proxy"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Enum = PS["Data.Enum"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Time = PS["Data.Time"];
  var Data_Generic = PS["Data.Generic"];
  var Global = PS["Global"];
  var DateTime = function (x) {
      return x;
  };
  var toEpochMilliseconds = function (v) {
      return $foreign.jsDateMethod("getTime", v);
  }; 
  var now = $foreign.nowImpl(DateTime);
  var fromJSDate = function (d) {
      var $44 = Global["isNaN"]($foreign.jsDateMethod("getTime", d));
      if ($44) {
          return Data_Maybe.Nothing.value;
      };
      if (!$44) {
          return new Data_Maybe.Just(d);
      };
      throw new Error("Failed pattern match at Data.Date line 61, column 3 - line 66, column 1: " + [ $44.constructor.name ]);
  };
  var fromString = function ($63) {
      return fromJSDate($foreign.jsDateConstructor($63));
  };
  var fromStringStrict = function (s) {
      return Prelude[">>="](Data_Maybe.bindMaybe)($foreign.strictJsDate(Data_Maybe.Just.create, Data_Maybe.Nothing.value, s))(fromJSDate);
  };
  var fromEpochMilliseconds = function ($64) {
      return fromJSDate($foreign.jsDateConstructor($64));
  };
  var genericDate = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "Date" && v.value1.length === 1)) {
          return Prelude[">>="](Data_Maybe.bindMaybe)(Data_Generic.fromSpine(Data_Time.genericMilliseconds)(v.value1[0](Prelude.unit)))(fromEpochMilliseconds);
      };
      return Data_Maybe.Nothing.value;
  }, function (v) {
      return new Data_Generic.SigProd("Date", [ {
          sigConstructor: "Date", 
          sigValues: [ Prelude["const"](Data_Generic.toSignature(Data_Time.genericMilliseconds)((Type_Proxy["Proxy"]).value)) ]
      } ]);
  }, function (d) {
      return new Data_Generic.SProd("Date", [ Prelude["const"](Data_Generic.toSpine(Data_Time.genericMilliseconds)(toEpochMilliseconds(d))) ]);
  });
  exports["now"] = now;
  exports["fromStringStrict"] = fromStringStrict;
  exports["fromString"] = fromString;
  exports["toEpochMilliseconds"] = toEpochMilliseconds;
  exports["fromEpochMilliseconds"] = fromEpochMilliseconds;
  exports["fromJSDate"] = fromJSDate;
  exports["genericDate"] = genericDate;
})(PS["Data.Date"] = PS["Data.Date"] || {});
(function(exports) {
    "use strict";
  var $foreign = PS["App.Model.Date"];
  var Data_Date = PS["Data.Date"];
  var Data_Maybe = PS["Data.Maybe"];
  exports["toISOString"] = $foreign.toISOString;
})(PS["App.Model.Date"] = PS["App.Model.Date"] || {});
(function(exports) {
    "use strict";

  // module Database.AnyDB
  /* eslint-env node*/
  /* eslint "no-underscore-dangle": 0 */

  exports.connect_ = function connect_(conString) {
    return function(success, error) {
      var anyDB = require("any-db");
      anyDB.createConnection(conString, function(err, con) {
        if (err) {
          error(err);
        } else {
          success(con);
        }
      });
    };
  };

  exports.runQuery_ = function runQuery_(queryStr) {
    return function(con) {
      return function(success, error) {
        con.query(queryStr, function(err, result) {
          if (err) {
            error(err);
          } else {
            success(result.rows);
          }
        });
      };
    };
  };

  exports.runQuery = function runQuery(queryStr) {
    return function(params) {
      return function(con) {
        return function(success, error) {
          con.query(queryStr, params, function(err, result) {
            if (err) {return error(err); }
            success(result.rows);
          });
        };
      };
    };
  };

  exports.close = function close(con) {
    return function() {
      con.end();
    };
  };
})(PS["Database.AnyDB"] = PS["Database.AnyDB"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports._makeAff = function (cb) {
    return function(success, error) {
      return cb(function(e) {
        return function() {
          error(e);
        };
      })(function(v) {
        return function() {
          try {
            success(v);
          } catch (err) {
            error(err);
          }
        };
      })();
    }
  }

  exports._pure = function (nonCanceler, v) {
    return function(success, error) {
      try {
        success(v);
      } catch (err) {
        error(err);
      }

      return nonCanceler;
    };
  }

  exports._throwError = function (nonCanceler, e) {
    return function(success, error) {
      error(e);

      return nonCanceler;
    };
  }

  exports._fmap = function (f, aff) {
    return function(success, error) {
      return aff(function(v) {
        try {
          success(f(v));
        } catch (err) {
          error(err);
        }
      }, error);
    };
  }

  exports._bind = function (alwaysCanceler, aff, f) {
    return function(success, error) {
      var canceler1, canceler2;

      var isCanceled    = false;
      var requestCancel = false;

      var onCanceler = function(){};

      canceler1 = aff(function(v) {
        if (requestCancel) {
          isCanceled = true;

          return alwaysCanceler;
        } else {
          canceler2 = f(v)(success, error);

          onCanceler(canceler2);

          return canceler2;
        }
      }, error);

      return function(e) {
        return function(s, f) {
          requestCancel = true;

          if (canceler2 !== undefined) {
            return canceler2(e)(s, f);
          } else {
            return canceler1(e)(function(bool) {
              if (bool || isCanceled) {
                try {
                  s(true);
                } catch (err) {
                  f(err);
                }
              } else {
                onCanceler = function(canceler) {
                  canceler(e)(s, f);
                };
              }
            }, f);
          }
        };
      };
    };
  }

  exports._attempt = function (Left, Right, aff) {
    return function(success, error) {
      return aff(function(v) {
        try {
          success(Right(v));
        } catch (err) {
          error(err);
        }
      }, function(e) {
        try {
          success(Left(e));
        } catch (err) {
          error(err);
        }
      });
    };
  }

  exports._runAff = function (errorT, successT, aff) {
    return function() {
      return aff(function(v) {
        try {
          successT(v)();
        } catch (err) {
          errorT(err)();
        }
      }, function(e) {
        errorT(e)();
      });
    };
  }

  exports._liftEff = function (nonCanceler, e) {
    return function(success, error) {
      try {
        success(e());
      } catch (err) {
        error(err);
      }

      return nonCanceler;
    };
  }
})(PS["Control.Monad.Aff"] = PS["Control.Monad.Aff"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];        
  var MonadEff = function (__superclass_Prelude$dotMonad_0, liftEff) {
      this["__superclass_Prelude.Monad_0"] = __superclass_Prelude$dotMonad_0;
      this.liftEff = liftEff;
  };                                 
  var liftEff = function (dict) {
      return dict.liftEff;
  };
  exports["MonadEff"] = MonadEff;
  exports["liftEff"] = liftEff;
})(PS["Control.Monad.Eff.Class"] = PS["Control.Monad.Eff.Class"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];        
  var MonadError = function (__superclass_Prelude$dotMonad_0, catchError, throwError) {
      this["__superclass_Prelude.Monad_0"] = __superclass_Prelude$dotMonad_0;
      this.catchError = catchError;
      this.throwError = throwError;
  };
  var throwError = function (dict) {
      return dict.throwError;
  };                          
  var catchError = function (dict) {
      return dict.catchError;
  };
  exports["MonadError"] = MonadError;
  exports["catchError"] = catchError;
  exports["throwError"] = throwError;
})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Aff"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Either = PS["Data.Either"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Function = PS["Data.Function"];
  var Data_Monoid = PS["Data.Monoid"];
  var runAff = function (ex) {
      return function (f) {
          return function (aff) {
              return $foreign._runAff(ex, f, aff);
          };
      };
  };
  var makeAff$prime = function (h) {
      return $foreign._makeAff(h);
  };
  var functorAff = new Prelude.Functor(function (f) {
      return function (fa) {
          return $foreign._fmap(f, fa);
      };
  });
  var attempt = function (aff) {
      return $foreign._attempt(Data_Either.Left.create, Data_Either.Right.create, aff);
  };
  var applyAff = new Prelude.Apply(function () {
      return functorAff;
  }, function (ff) {
      return function (fa) {
          return $foreign._bind(alwaysCanceler, ff, function (f) {
              return Prelude["<$>"](functorAff)(f)(fa);
          });
      };
  });
  var applicativeAff = new Prelude.Applicative(function () {
      return applyAff;
  }, function (v) {
      return $foreign._pure(nonCanceler, v);
  });
  var nonCanceler = Prelude["const"](Prelude.pure(applicativeAff)(false));
  var alwaysCanceler = Prelude["const"](Prelude.pure(applicativeAff)(true));
  var makeAff = function (h) {
      return makeAff$prime(function (e) {
          return function (a) {
              return Prelude["<$>"](Control_Monad_Eff.functorEff)(Prelude["const"](nonCanceler))(h(e)(a));
          };
      });
  };                                                       
  var bindAff = new Prelude.Bind(function () {
      return applyAff;
  }, function (fa) {
      return function (f) {
          return $foreign._bind(alwaysCanceler, fa, f);
      };
  });
  var monadAff = new Prelude.Monad(function () {
      return applicativeAff;
  }, function () {
      return bindAff;
  });
  var monadEffAff = new Control_Monad_Eff_Class.MonadEff(function () {
      return monadAff;
  }, function (eff) {
      return $foreign._liftEff(nonCanceler, eff);
  });
  var monadErrorAff = new Control_Monad_Error_Class.MonadError(function () {
      return monadAff;
  }, function (aff) {
      return function (ex) {
          return Prelude[">>="](bindAff)(attempt(aff))(Data_Either.either(ex)(Prelude.pure(applicativeAff)));
      };
  }, function (e) {
      return $foreign._throwError(nonCanceler, e);
  });
  var $$finally = function (aff1) {
      return function (aff2) {
          return Prelude.bind(bindAff)(attempt(aff1))(function (v) {
              return Prelude.bind(bindAff)(aff2)(function () {
                  return Data_Either.either(Control_Monad_Error_Class.throwError(monadErrorAff))(Prelude.pure(applicativeAff))(v);
              });
          });
      };
  };
  exports["runAff"] = runAff;
  exports["nonCanceler"] = nonCanceler;
  exports["makeAff'"] = makeAff$prime;
  exports["makeAff"] = makeAff;
  exports["finally"] = $$finally;
  exports["attempt"] = attempt;
  exports["functorAff"] = functorAff;
  exports["applyAff"] = applyAff;
  exports["applicativeAff"] = applicativeAff;
  exports["bindAff"] = bindAff;
  exports["monadAff"] = monadAff;
  exports["monadEffAff"] = monadEffAff;
  exports["monadErrorAff"] = monadErrorAff;
})(PS["Control.Monad.Aff"] = PS["Control.Monad.Aff"] || {});
(function(exports) {
    "use strict";

  // module Database.AnyDB.SqlValue
  /* eslint-env node*/

  exports.unsafeToSqlValue = function unsafeToSqlValue(x) {
    return x;
  };
})(PS["Database.AnyDB.SqlValue"] = PS["Database.AnyDB.SqlValue"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Database.AnyDB.SqlValue"];
  var Prelude = PS["Prelude"];
  var Data_Int = PS["Data.Int"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Date = PS["Data.Date"];
  var Node_Buffer = PS["Node.Buffer"];        
  var IsSqlValue = function (toSql) {
      this.toSql = toSql;
  };
  var toSql = function (dict) {
      return dict.toSql;
  };
  var isSqlValueString = new IsSqlValue($foreign.unsafeToSqlValue);
  var isSqlValueInt = new IsSqlValue(function ($4) {
      return $foreign.unsafeToSqlValue(Data_Int.toNumber($4));
  });                                                            
  var isSqlValueBuffer = new IsSqlValue($foreign.unsafeToSqlValue);
  exports["IsSqlValue"] = IsSqlValue;
  exports["toSql"] = toSql;
  exports["isSqlValueString"] = isSqlValueString;
  exports["isSqlValueInt"] = isSqlValueInt;
  exports["isSqlValueBuffer"] = isSqlValueBuffer;
})(PS["Database.AnyDB.SqlValue"] = PS["Database.AnyDB.SqlValue"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Database.AnyDB"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Trans = PS["Control.Monad.Trans"];
  var Data_Either = PS["Data.Either"];
  var Data_Array = PS["Data.Array"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Maybe = PS["Data.Maybe"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Data_Traversable = PS["Data.Traversable"];
  var Database_AnyDB_SqlValue = PS["Database.AnyDB.SqlValue"];        
  var Query = function (x) {
      return x;
  };
  var Postgres = (function () {
      function Postgres(value0) {
          this.value0 = value0;
      };
      Postgres.create = function (value0) {
          return new Postgres(value0);
      };
      return Postgres;
  })();
  var Sqlite3 = (function () {
      function Sqlite3(value0) {
          this.value0 = value0;
      };
      Sqlite3.create = function (value0) {
          return new Sqlite3(value0);
      };
      return Sqlite3;
  })();
  var mkConnectionString = function (v) {
      if (v instanceof Postgres) {
          return "postgres://" + (v.value0.user + (":" + (v.value0.password + ("@" + (v.value0.host + (":" + (Prelude.show(Prelude.showInt)(v.value0.port) + ("/" + v.value0.db))))))));
      };
      if (v instanceof Sqlite3) {
          return "sqlite3://" + (function () {
              if (v.value0.memory) {
                  return ":memory:";
              };
              if (!v.value0.memory) {
                  return v.value0.filename;
              };
              throw new Error("Failed pattern match at Database.AnyDB line 71, column 36 - line 74, column 1: " + [ v.value0.memory.constructor.name ]);
          })();
      };
      throw new Error("Failed pattern match at Database.AnyDB line 65, column 1 - line 71, column 1: " + [ v.constructor.name ]);
  };
  var liftError = function (err) {
      return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error(Prelude.show(Data_Foreign.showForeignError)(err)));
  };
  var query = function (dictIsForeign) {
      return function (v) {
          return function (params) {
              return function (con) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)($foreign.runQuery(v)(params)(con))(function (v1) {
                      return Data_Either.either(liftError)(Prelude.pure(Control_Monad_Aff.applicativeAff))(Data_Traversable.sequence(Data_Traversable.traversableArray)(Data_Either.applicativeEither)(Prelude["<$>"](Prelude.functorArray)(Data_Foreign_Class.read(dictIsForeign))(v1)));
                  });
              };
          };
      };
  };
  var queryOne = function (dictIsForeign) {
      return function (v) {
          return function (params) {
              return function (con) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)($foreign.runQuery(v)(params)(con))(function (v1) {
                      return Data_Maybe.maybe(Prelude.pure(Control_Monad_Aff.applicativeAff)(Data_Maybe.Nothing.value))(Data_Either.either(liftError)(function ($59) {
                          return Prelude.pure(Control_Monad_Aff.applicativeAff)(Data_Maybe.Just.create($59));
                      }))(Prelude["<$>"](Data_Maybe.functorMaybe)(Data_Foreign_Class.read(dictIsForeign))(Data_Array["!!"](v1)(0)));
                  });
              };
          };
      };
  };
  var execute_ = function (v) {
      return function (con) {
          return Prelude["void"](Control_Monad_Aff.functorAff)($foreign.runQuery_(v)(con));
      };
  };
  var execute = function (v) {
      return function (params) {
          return function (con) {
              return Prelude["void"](Control_Monad_Aff.functorAff)($foreign.runQuery(v)(params)(con));
          };
      };
  }; 
  var connect = function ($62) {
      return $foreign.connect_(mkConnectionString($62));
  };
  var withConnection = function (info) {
      return function (p) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(connect(info))(function (v) {
              return Control_Monad_Aff["finally"](p(v))(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)($foreign.close(v)));
          });
      };
  };
  exports["Postgres"] = Postgres;
  exports["Sqlite3"] = Sqlite3;
  exports["Query"] = Query;
  exports["withConnection"] = withConnection;
  exports["queryOne"] = queryOne;
  exports["query"] = query;
  exports["execute_"] = execute_;
  exports["execute"] = execute;
  exports["connect"] = connect;
  exports["mkConnectionString"] = mkConnectionString;
})(PS["Database.AnyDB"] = PS["Database.AnyDB"] || {});
(function(exports) {
    "use strict";

  //module App.Model.StrMap

  exports._collect = function _collect (f) {
    return function (m) {
      var r = [];
      for (var k in m) {
        if (m.hasOwnProperty(k)) {
          r.push(f(k)(m[k]));
        }
      }
      return r;
    };
  };
})(PS["App.Model.StrMap"] = PS["App.Model.StrMap"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["App.Model.StrMap"];
  var Prelude = PS["Prelude"];
  var Data_StrMap = PS["Data.StrMap"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Array = PS["Data.Array"];        
  var toArray = $foreign._collect(Data_Tuple.Tuple.create);
  var fromArray = Data_Foldable.foldl(Data_Foldable.foldableArray)(function (acc) {
      return function (v) {
          return Data_StrMap.insert(v.value0)(v.value1)(acc);
      };
  })(Data_StrMap.empty);
  exports["fromArray"] = fromArray;
  exports["toArray"] = toArray;
})(PS["App.Model.StrMap"] = PS["App.Model.StrMap"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_String = PS["Data.String"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Data_Array = PS["Data.Array"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_StrMap = PS["Data.StrMap"];
  var App_Model_StrMap = PS["App.Model.StrMap"];        
  var Char = (function () {
      function Char() {

      };
      Char.value = new Char();
      return Char;
  })();
  var Integer = (function () {
      function Integer() {

      };
      Integer.value = new Integer();
      return Integer;
  })();
  var $$Date = (function () {
      function Date() {

      };
      Date.value = new Date();
      return Date;
  })();
  var Blob = (function () {
      function Blob() {

      };
      Blob.value = new Blob();
      return Blob;
  })();
  var PrimaryKey = (function () {
      function PrimaryKey() {

      };
      PrimaryKey.value = new PrimaryKey();
      return PrimaryKey;
  })();
  var Unique = (function () {
      function Unique() {

      };
      Unique.value = new Unique();
      return Unique;
  })();
  var ColumnDef = (function () {
      function ColumnDef(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ColumnDef.create = function (value0) {
          return function (value1) {
              return new ColumnDef(value0, value1);
          };
      };
      return ColumnDef;
  })();
  var parens = function (s) {
      return " (" + (s + ")");
  };
  var insert = function (v) {
      return function (fs) {
          return function (repl) {
              return function (str) {
                  var sortedValues = Prelude.map(Prelude.functorArray)(Data_Tuple.snd)(Data_Array.sortBy(function (f1) {
                      return function (f2) {
                          return Prelude.compare(Prelude.ordString)(Data_Tuple.fst(f1))(Data_Tuple.fst(f2));
                      };
                  })(App_Model_StrMap.toArray(fs)));
                  var sortedKeys = Data_Array.sort(Prelude.ordString)(Data_StrMap.keys(fs));
                  return Database_AnyDB.Query("INSERT " + ((function () {
                      if (repl) {
                          return " or replace ";
                      };
                      if (!repl) {
                          return "";
                      };
                      throw new Error("Failed pattern match at SQL line 61, column 28 - line 61, column 63: " + [ repl.constructor.name ]);
                  })() + ("INTO " + (v.name + (parens(Data_String.joinWith(", ")(sortedKeys)) + (" VALUES" + (parens(Data_String.joinWith(", ")(Prelude.map(Prelude.functorArray)(function (str2) {
                      return "'" + (str2 + "'");
                  })(sortedValues))) + (";" + str))))))));
              };
          };
      };
  };
  exports["Char"] = Char;
  exports["Integer"] = Integer;
  exports["Date"] = $$Date;
  exports["Blob"] = Blob;
  exports["PrimaryKey"] = PrimaryKey;
  exports["Unique"] = Unique;
  exports["ColumnDef"] = ColumnDef;
  exports["parens"] = parens;
  exports["insert"] = insert;
})(PS["SQL"] = PS["SQL"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Tuple = PS["Data.Tuple"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];        
  var SavedFile = (function () {
      function SavedFile(value0) {
          this.value0 = value0;
      };
      SavedFile.create = function (value0) {
          return new SavedFile(value0);
      };
      return SavedFile;
  })();
  var savedFileTable = {
      name: "FILES", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("name")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("eventid")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("file")(new SQL.ColumnDef(SQL.Blob.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  }; 
  var genericSavedFile = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.SavedFile.SavedFile" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(SavedFile.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 3) {
                  return Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (eventId1) {
                      return function (id1) {
                          return function (name1) {
                              return {
                                  eventId: eventId1, 
                                  id: id1, 
                                  name: name1
                              };
                          };
                      };
                  }))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[0]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[1]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[2]).recValue(Prelude.unit)));
              };
              return Data_Maybe.Nothing.value;
          })(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.SavedFile.SavedFile", [ {
          sigConstructor: "App.Model.SavedFile.SavedFile", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "eventId", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "id", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "name", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.SavedFile.SavedFile", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "eventId", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.eventId);
              }
          }, {
              recLabel: "id", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.id);
              }
          }, {
              recLabel: "name", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.name);
              }
          } ]);
      } ]);
  });
  exports["SavedFile"] = SavedFile;
  exports["savedFileTable"] = savedFileTable;
  exports["genericSavedFile"] = genericSavedFile;
})(PS["App.Model.SavedFile"] = PS["App.Model.SavedFile"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Lens = PS["Data.Lens"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Date = PS["Data.Date"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Array = PS["Data.Array"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Lens_Lens = PS["Data.Lens.Lens"];        
  var PartialEvent = (function () {
      function PartialEvent(value0) {
          this.value0 = value0;
      };
      PartialEvent.create = function (value0) {
          return new PartialEvent(value0);
      };
      return PartialEvent;
  })();
  var partialEventIsForeign = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Prelude["<$>"](Data_Either.functorEither)(Data_Maybe.Just.create)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("id")(obj)))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("computername")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("name")(obj))(function (v2) {
                  return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("datefrom")(obj))(function (v3) {
                      return Prelude.bind(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create(new Data_Foreign.TypeMismatch("ISO 8601 Date", v3)))(Data_Either.Right.create)(Data_Date.fromStringStrict(v3)))(function (v4) {
                          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("dateuntil")(obj))(function (v5) {
                              return Prelude.bind(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create(new Data_Foreign.TypeMismatch("ISO 8601 Date", v5)))(Data_Either.Right.create)(Data_Date.fromStringStrict(v5)))(function (v6) {
                                  return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("profile")(obj))(function (v7) {
                                      return Prelude["return"](Data_Either.applicativeEither)(new PartialEvent({
                                          id: v, 
                                          computername: v1, 
                                          name: v2, 
                                          datefrom: v4, 
                                          dateuntil: v6, 
                                          profile: v7
                                      }));
                                  });
                              });
                          });
                      });
                  });
              });
          });
      });
  });
  var genericPartialEvent = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.Event.PartialEvent" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(PartialEvent.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 6) {
                  return Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (computername1) {
                      return function (datefrom1) {
                          return function (dateuntil1) {
                              return function (id1) {
                                  return function (name1) {
                                      return function (profile1) {
                                          return {
                                              computername: computername1, 
                                              datefrom: datefrom1, 
                                              dateuntil: dateuntil1, 
                                              id: id1, 
                                              name: name1, 
                                              profile: profile1
                                          };
                                      };
                                  };
                              };
                          };
                      };
                  }))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[0]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Date.genericDate)((r.value0[1]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Date.genericDate)((r.value0[2]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericMaybe(Data_Generic.genericInt))((r.value0[3]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[4]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[5]).recValue(Prelude.unit)));
              };
              return Data_Maybe.Nothing.value;
          })(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.Event.PartialEvent", [ {
          sigConstructor: "App.Model.Event.PartialEvent", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "computername", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "datefrom", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Date.genericDate)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "dateuntil", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Date.genericDate)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "id", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericMaybe(Data_Generic.genericInt))(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "name", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "profile", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.Event.PartialEvent", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "computername", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.computername);
              }
          }, {
              recLabel: "datefrom", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Date.genericDate)(v.value0.datefrom);
              }
          }, {
              recLabel: "dateuntil", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Date.genericDate)(v.value0.dateuntil);
              }
          }, {
              recLabel: "id", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericMaybe(Data_Generic.genericInt))(v.value0.id);
              }
          }, {
              recLabel: "name", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.name);
              }
          }, {
              recLabel: "profile", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.profile);
              }
          } ]);
      } ]);
  });                                                                
  var eventsTable = {
      name: "EVENTS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("name")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("datefrom")(new SQL.ColumnDef((SQL["Date"]).value, [  ])), Data_Tuple.Tuple.create("dateuntil")(new SQL.ColumnDef((SQL["Date"]).value, [  ])), Data_Tuple.Tuple.create("profile")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  exports["PartialEvent"] = PartialEvent;
  exports["eventsTable"] = eventsTable;
  exports["genericPartialEvent"] = genericPartialEvent;
  exports["partialEventIsForeign"] = partialEventIsForeign;
})(PS["App.Model.Event"] = PS["App.Model.Event"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Lens = PS["Data.Lens"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Array = PS["Data.Array"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Lens_Lens = PS["Data.Lens.Lens"];        
  var Photobooth = (function () {
      function Photobooth(value0) {
          this.value0 = value0;
      };
      Photobooth.create = function (value0) {
          return new Photobooth(value0);
      };
      return Photobooth;
  })();
  var photoboothsTable = {
      name: "PHOTOBOOTHS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Char.value, [ SQL.Unique.value ])), Data_Tuple.Tuple.create("alias")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("defaultprofile")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  var photoboothIsForeign = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Prelude["<$>"](Data_Either.functorEither)(Data_Maybe.Just.create)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("id")(obj)))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("computername")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("alias")(obj))(function (v2) {
                  return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("defaultprofile")(obj))(function (v3) {
                      return Prelude["return"](Data_Either.applicativeEither)(new Photobooth({
                          id: v, 
                          computername: v1, 
                          alias: v2, 
                          defaultprofile: v3
                      }));
                  });
              });
          });
      });
  });
  var genericPhotobooth = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.Photobooth.Photobooth" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Photobooth.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 4) {
                  return Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (alias1) {
                      return function (computername1) {
                          return function (defaultprofile1) {
                              return function (id1) {
                                  return {
                                      alias: alias1, 
                                      computername: computername1, 
                                      defaultprofile: defaultprofile1, 
                                      id: id1
                                  };
                              };
                          };
                      };
                  }))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[0]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[1]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[2]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericMaybe(Data_Generic.genericInt))((r.value0[3]).recValue(Prelude.unit)));
              };
              return Data_Maybe.Nothing.value;
          })(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.Photobooth.Photobooth", [ {
          sigConstructor: "App.Model.Photobooth.Photobooth", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "alias", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "computername", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "defaultprofile", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "id", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericMaybe(Data_Generic.genericInt))(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.Photobooth.Photobooth", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "alias", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.alias);
              }
          }, {
              recLabel: "computername", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.computername);
              }
          }, {
              recLabel: "defaultprofile", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.defaultprofile);
              }
          }, {
              recLabel: "id", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericMaybe(Data_Generic.genericInt))(v.value0.id);
              }
          } ]);
      } ]);
  });                                                                          
  var eqPhotobooth = new Prelude.Eq(Data_Generic.gEq(genericPhotobooth));
  exports["Photobooth"] = Photobooth;
  exports["photoboothsTable"] = photoboothsTable;
  exports["genericPhotobooth"] = genericPhotobooth;
  exports["eqPhotobooth"] = eqPhotobooth;
  exports["photoboothIsForeign"] = photoboothIsForeign;
})(PS["App.Model.Photobooth"] = PS["App.Model.Photobooth"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Lens = PS["Data.Lens"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Date = PS["Data.Date"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Lens_Lens = PS["Data.Lens.Lens"];        
  var MonthlyStatistic = (function () {
      function MonthlyStatistic(value0) {
          this.value0 = value0;
      };
      MonthlyStatistic.create = function (value0) {
          return new MonthlyStatistic(value0);
      };
      return MonthlyStatistic;
  })();
  var EventStatistic = (function () {
      function EventStatistic(value0) {
          this.value0 = value0;
      };
      EventStatistic.create = function (value0) {
          return new EventStatistic(value0);
      };
      return EventStatistic;
  })();
  var AllStatistics = (function () {
      function AllStatistics(value0) {
          this.value0 = value0;
      };
      AllStatistics.create = function (value0) {
          return new AllStatistics(value0);
      };
      return AllStatistics;
  })();
  var monthlyStatisticIsForeign = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("computername")(obj))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("month")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("pictures")(obj))(function (v2) {
                  return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("prints")(obj))(function (v3) {
                      return Prelude["return"](Data_Either.applicativeEither)(new MonthlyStatistic({
                          computername: v, 
                          month: v1, 
                          pictures: v2, 
                          prints: v3
                      }));
                  });
              });
          });
      });
  });
  var genericMonthlyStatistic = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.Statistic.MonthlyStatistic" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(MonthlyStatistic.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 4) {
                  return Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (computername1) {
                      return function (month1) {
                          return function (pictures1) {
                              return function (prints1) {
                                  return {
                                      computername: computername1, 
                                      month: month1, 
                                      pictures: pictures1, 
                                      prints: prints1
                                  };
                              };
                          };
                      };
                  }))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[0]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[1]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[2]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[3]).recValue(Prelude.unit)));
              };
              return Data_Maybe.Nothing.value;
          })(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.Statistic.MonthlyStatistic", [ {
          sigConstructor: "App.Model.Statistic.MonthlyStatistic", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "computername", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "month", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "pictures", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "prints", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.Statistic.MonthlyStatistic", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "computername", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.computername);
              }
          }, {
              recLabel: "month", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.month);
              }
          }, {
              recLabel: "pictures", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.pictures);
              }
          }, {
              recLabel: "prints", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.prints);
              }
          } ]);
      } ]);
  });                                                                                      
  var genericEventStatistic = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.Statistic.EventStatistic" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(EventStatistic.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 4) {
                  return Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (computername1) {
                      return function (eventId1) {
                          return function (pictures1) {
                              return function (prints1) {
                                  return {
                                      computername: computername1, 
                                      eventId: eventId1, 
                                      pictures: pictures1, 
                                      prints: prints1
                                  };
                              };
                          };
                      };
                  }))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[0]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[1]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[2]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericInt)((r.value0[3]).recValue(Prelude.unit)));
              };
              return Data_Maybe.Nothing.value;
          })(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.Statistic.EventStatistic", [ {
          sigConstructor: "App.Model.Statistic.EventStatistic", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "computername", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "eventId", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "pictures", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "prints", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.Statistic.EventStatistic", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "computername", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericString)(v.value0.computername);
              }
          }, {
              recLabel: "eventId", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.eventId);
              }
          }, {
              recLabel: "pictures", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.pictures);
              }
          }, {
              recLabel: "prints", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.prints);
              }
          } ]);
      } ]);
  });                                                                                  
  var genericAllStatistics = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.Statistic.AllStatistics" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(AllStatistics.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 2) {
                  return Prelude.apply(Data_Maybe.applyMaybe)(Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (eventStatistics1) {
                      return function (monthlyStatistics1) {
                          return {
                              eventStatistics: eventStatistics1, 
                              monthlyStatistics: monthlyStatistics1
                          };
                      };
                  }))(Data_Generic.fromSpine(Data_Generic.genericArray(genericEventStatistic))((r.value0[0]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericArray(genericMonthlyStatistic))((r.value0[1]).recValue(Prelude.unit)));
              };
              return Data_Maybe.Nothing.value;
          })(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.Statistic.AllStatistics", [ {
          sigConstructor: "App.Model.Statistic.AllStatistics", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "eventStatistics", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericArray(genericEventStatistic))(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "monthlyStatistics", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericArray(genericMonthlyStatistic))(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.Statistic.AllStatistics", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "eventStatistics", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericArray(genericEventStatistic))(v.value0.eventStatistics);
              }
          }, {
              recLabel: "monthlyStatistics", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericArray(genericMonthlyStatistic))(v.value0.monthlyStatistics);
              }
          } ]);
      } ]);
  });
  var eventStatisticIsForeign = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("computername")(obj))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("eventid")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("pictures")(obj))(function (v2) {
                  return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("prints")(obj))(function (v3) {
                      return Prelude["return"](Data_Either.applicativeEither)(new EventStatistic({
                          computername: v, 
                          eventId: v1, 
                          pictures: v2, 
                          prints: v3
                      }));
                  });
              });
          });
      });
  });
  exports["AllStatistics"] = AllStatistics;
  exports["MonthlyStatistic"] = MonthlyStatistic;
  exports["EventStatistic"] = EventStatistic;
  exports["genericEventStatistic"] = genericEventStatistic;
  exports["eventStatisticIsForeign"] = eventStatisticIsForeign;
  exports["genericMonthlyStatistic"] = genericMonthlyStatistic;
  exports["monthlyStatisticIsForeign"] = monthlyStatisticIsForeign;
  exports["genericAllStatistics"] = genericAllStatistics;
})(PS["App.Model.Statistic"] = PS["App.Model.Statistic"] || {});
(function(exports) {
    "use strict";
  var App_Model_Date = PS["App.Model.Date"];
  var App_Model_Event = PS["App.Model.Event"];
  var App_Model_NetworkingState = PS["App.Model.NetworkingState"];
  var App_Model_Photobooth = PS["App.Model.Photobooth"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var App_Model_Session = PS["App.Model.Session"];
  var App_Model_Statistic = PS["App.Model.Statistic"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var App_Model_User = PS["App.Model.User"];
  var App_Model_WorkerState = PS["App.Model.WorkerState"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Data_Array = PS["Data.Array"];
  var Data_Date = PS["Data.Date"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_String = PS["Data.String"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Database_AnyDB_SqlValue = PS["Database.AnyDB.SqlValue"];
  var Node_Buffer = PS["Node.Buffer"];
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var upsertSavedFile = function (v) {
      return SQL.insert(App_Model_SavedFile.savedFileTable)(App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(Prelude.show(Prelude.showInt)(v.value0.id)), new Data_Tuple.Tuple("name", v.value0.name), Data_Tuple.Tuple.create("eventId")(Prelude.show(Prelude.showInt)(v.value0.eventId)) ]))(true)("");
  };
  var upsertPartialEvent = function (v) {
      return SQL.insert(App_Model_Event.eventsTable)(App_Model_StrMap.fromArray([ Data_Maybe.maybe(Data_Monoid.mempty(Data_Tuple.monoidTuple(Data_Monoid.monoidString)(Data_Monoid.monoidString)))(function (s) {
          return Data_Tuple.Tuple.create("id")(Prelude.show(Prelude.showInt)(s));
      })(v.value0.id), new Data_Tuple.Tuple("computername", v.value0.computername), new Data_Tuple.Tuple("name", v.value0.name), Data_Tuple.Tuple.create("datefrom")(App_Model_Date.toISOString(v.value0.datefrom)), Data_Tuple.Tuple.create("dateuntil")(App_Model_Date.toISOString(v.value0.dateuntil)), Data_Tuple.Tuple.create("profile")(v.value0.profile) ]))(true)("");
  };
  var upsertPB = function (v) {
      return SQL.insert(App_Model_Photobooth.photoboothsTable)(App_Model_StrMap.fromArray([ Data_Maybe.maybe(Data_Monoid.mempty(Data_Tuple.monoidTuple(Data_Monoid.monoidString)(Data_Monoid.monoidString)))(function (s) {
          return Data_Tuple.Tuple.create("id")(Prelude.show(Prelude.showInt)(s));
      })(v.value0.id), new Data_Tuple.Tuple("computername", v.value0.computername), new Data_Tuple.Tuple("alias", v.value0.alias), new Data_Tuple.Tuple("defaultprofile", v.value0.defaultprofile) ]))(true)("");
  };
  var queryPhotobooth = function (conn) {
      return function (cname) {
          var q = Database_AnyDB.Query("Select * from PHOTOBOOTHS " + "where computername = ?");
          return Database_AnyDB.queryOne(App_Model_Photobooth.photoboothIsForeign)(q)([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(conn);
      };
  };
  var queryAllStatistics = function (conn) {
      return function (cname) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.query(App_Model_Statistic.eventStatisticIsForeign)("select * from eventstatistics where computername = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(conn))(function (v) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.query(App_Model_Statistic.monthlyStatisticIsForeign)("select * from monthlystatistics where computername = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(conn))(function (v1) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(new App_Model_Statistic.AllStatistics({
                      eventStatistics: v, 
                      monthlyStatistics: v1
                  }));
              });
          });
      };
  };
  var networkingConnectionInfo = new Database_AnyDB.Sqlite3({
      filename: "networkingdb", 
      memory: false
  });
  exports["queryPhotobooth"] = queryPhotobooth;
  exports["queryAllStatistics"] = queryAllStatistics;
  exports["upsertSavedFile"] = upsertSavedFile;
  exports["upsertPartialEvent"] = upsertPartialEvent;
  exports["upsertPB"] = upsertPB;
  exports["networkingConnectionInfo"] = networkingConnectionInfo;
})(PS["App.DB"] = PS["App.DB"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Either = PS["Data.Either"];
  var Data_Generic = PS["Data.Generic"];
  var Data_String = PS["Data.String"];
  var Data_Maybe = PS["Data.Maybe"];        
  var OPTIONS = (function () {
      function OPTIONS() {

      };
      OPTIONS.value = new OPTIONS();
      return OPTIONS;
  })();
  var GET = (function () {
      function GET() {

      };
      GET.value = new GET();
      return GET;
  })();
  var HEAD = (function () {
      function HEAD() {

      };
      HEAD.value = new HEAD();
      return HEAD;
  })();
  var POST = (function () {
      function POST() {

      };
      POST.value = new POST();
      return POST;
  })();
  var PUT = (function () {
      function PUT() {

      };
      PUT.value = new PUT();
      return PUT;
  })();
  var DELETE = (function () {
      function DELETE() {

      };
      DELETE.value = new DELETE();
      return DELETE;
  })();
  var TRACE = (function () {
      function TRACE() {

      };
      TRACE.value = new TRACE();
      return TRACE;
  })();
  var CONNECT = (function () {
      function CONNECT() {

      };
      CONNECT.value = new CONNECT();
      return CONNECT;
  })();
  var PROPFIND = (function () {
      function PROPFIND() {

      };
      PROPFIND.value = new PROPFIND();
      return PROPFIND;
  })();
  var PROPPATCH = (function () {
      function PROPPATCH() {

      };
      PROPPATCH.value = new PROPPATCH();
      return PROPPATCH;
  })();
  var MKCOL = (function () {
      function MKCOL() {

      };
      MKCOL.value = new MKCOL();
      return MKCOL;
  })();
  var COPY = (function () {
      function COPY() {

      };
      COPY.value = new COPY();
      return COPY;
  })();
  var MOVE = (function () {
      function MOVE() {

      };
      MOVE.value = new MOVE();
      return MOVE;
  })();
  var LOCK = (function () {
      function LOCK() {

      };
      LOCK.value = new LOCK();
      return LOCK;
  })();
  var UNLOCK = (function () {
      function UNLOCK() {

      };
      UNLOCK.value = new UNLOCK();
      return UNLOCK;
  })();
  var PATCH = (function () {
      function PATCH() {

      };
      PATCH.value = new PATCH();
      return PATCH;
  })();
  var showMethod = new Prelude.Show(function (v) {
      if (v instanceof OPTIONS) {
          return "OPTIONS";
      };
      if (v instanceof GET) {
          return "GET";
      };
      if (v instanceof HEAD) {
          return "HEAD";
      };
      if (v instanceof POST) {
          return "POST";
      };
      if (v instanceof PUT) {
          return "PUT";
      };
      if (v instanceof DELETE) {
          return "DELETE";
      };
      if (v instanceof TRACE) {
          return "TRACE";
      };
      if (v instanceof CONNECT) {
          return "CONNECT";
      };
      if (v instanceof PROPFIND) {
          return "PROPFIND";
      };
      if (v instanceof PROPPATCH) {
          return "PROPPATCH";
      };
      if (v instanceof MKCOL) {
          return "MKCOL";
      };
      if (v instanceof COPY) {
          return "COPY";
      };
      if (v instanceof MOVE) {
          return "MOVE";
      };
      if (v instanceof LOCK) {
          return "LOCK";
      };
      if (v instanceof UNLOCK) {
          return "UNLOCK";
      };
      if (v instanceof PATCH) {
          return "PATCH";
      };
      throw new Error("Failed pattern match at Data.HTTP.Method line 63, column 3 - line 64, column 3: " + [ v.constructor.name ]);
  });
  var runCustomMethod = function (v) {
      return v;
  };
  var print = Data_Either.either(Prelude.show(showMethod))(runCustomMethod);
  exports["OPTIONS"] = OPTIONS;
  exports["GET"] = GET;
  exports["HEAD"] = HEAD;
  exports["POST"] = POST;
  exports["PUT"] = PUT;
  exports["DELETE"] = DELETE;
  exports["TRACE"] = TRACE;
  exports["CONNECT"] = CONNECT;
  exports["PROPFIND"] = PROPFIND;
  exports["PROPPATCH"] = PROPPATCH;
  exports["MKCOL"] = MKCOL;
  exports["COPY"] = COPY;
  exports["MOVE"] = MOVE;
  exports["LOCK"] = LOCK;
  exports["UNLOCK"] = UNLOCK;
  exports["PATCH"] = PATCH;
  exports["print"] = print;
  exports["runCustomMethod"] = runCustomMethod;
  exports["showMethod"] = showMethod;
})(PS["Data.HTTP.Method"] = PS["Data.HTTP.Method"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Nullable

  exports["null"] = null;

  exports.notNull = function(x) {
      return x;
  };
})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Nullable"];
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Function = PS["Data.Function"];        
  var toNullable = Data_Maybe.maybe($foreign["null"])($foreign.notNull);
  exports["toNullable"] = toNullable;
})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];        
  var $greater$eq$greater = function (dictBind) {
      return function (f) {
          return function (g) {
              return function (a) {
                  return Prelude[">>="](dictBind)(f(a))(g);
              };
          };
      };
  };
  var $eq$less$less = function (dictBind) {
      return function (f) {
          return function (m) {
              return Prelude[">>="](dictBind)(m)(f);
          };
      };
  };
  var $less$eq$less = function (dictBind) {
      return function (f) {
          return function (g) {
              return function (a) {
                  return $eq$less$less(dictBind)(f)(g(a));
              };
          };
      };
  };
  exports["<=<"] = $less$eq$less;
  exports[">=>"] = $greater$eq$greater;
})(PS["Control.Bind"] = PS["Control.Bind"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Control.Monad.Eff.Unsafe

  exports.unsafeInterleaveEff = function (f) {
    return f;
  };
})(PS["Control.Monad.Eff.Unsafe"] = PS["Control.Monad.Eff.Unsafe"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff.Unsafe"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];        
  var unsafePerformEff = function ($0) {
      return Control_Monad_Eff.runPure($foreign.unsafeInterleaveEff($0));
  };
  exports["unsafePerformEff"] = unsafePerformEff;
  exports["unsafeInterleaveEff"] = $foreign.unsafeInterleaveEff;
})(PS["Control.Monad.Eff.Unsafe"] = PS["Control.Monad.Eff.Unsafe"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff_Unsafe = PS["Control.Monad.Eff.Unsafe"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];        
  var unsafeThrowException = function ($0) {
      return Control_Monad_Eff_Unsafe.unsafePerformEff(Control_Monad_Eff_Exception.throwException($0));
  };
  var unsafeThrow = function ($1) {
      return unsafeThrowException(Control_Monad_Eff_Exception.error($1));
  };
  exports["unsafeThrow"] = unsafeThrow;
  exports["unsafeThrowException"] = unsafeThrowException;
})(PS["Control.Monad.Eff.Exception.Unsafe"] = PS["Control.Monad.Eff.Exception.Unsafe"] || {});
(function(exports) {
  /* globals exports, JSON */
  "use strict";

  // module Global.Unsafe

  exports.unsafeStringify = function (x) {
    return JSON.stringify(x);
  };
})(PS["Global.Unsafe"] = PS["Global.Unsafe"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Global.Unsafe"];
  exports["unsafeStringify"] = $foreign.unsafeStringify;
})(PS["Global.Unsafe"] = PS["Global.Unsafe"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Array = PS["Data.Array"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Function = PS["Data.Function"];
  var Data_Nullable = PS["Data.Nullable"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_List = PS["Data.List"];
  var Data_StrMap = PS["Data.StrMap"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Monad_Eff_Exception_Unsafe = PS["Control.Monad.Eff.Exception.Unsafe"];
  var Global_Unsafe = PS["Global.Unsafe"];
  var Type_Proxy = PS["Type.Proxy"];        
  var TaggedObject = (function () {
      function TaggedObject(value0) {
          this.value0 = value0;
      };
      TaggedObject.create = function (value0) {
          return new TaggedObject(value0);
      };
      return TaggedObject;
  })();
  var toForeignGeneric = function (dictGeneric) {
      return function (v) {
          var go = function (v1) {
              return function (v2) {
                  if (v2 instanceof Data_Generic.SNumber) {
                      return Data_Foreign.toForeign(v2.value0);
                  };
                  if (v2 instanceof Data_Generic.SInt) {
                      return Data_Foreign.toForeign(v2.value0);
                  };
                  if (v2 instanceof Data_Generic.SChar) {
                      return Data_Foreign.toForeign(v2.value0);
                  };
                  if (v2 instanceof Data_Generic.SString) {
                      return Data_Foreign.toForeign(v2.value0);
                  };
                  if (v2 instanceof Data_Generic.SBoolean) {
                      return Data_Foreign.toForeign(v2.value0);
                  };
                  if (v1 instanceof Data_Generic.SigArray && v2 instanceof Data_Generic.SArray) {
                      return Data_Foreign.toForeign(Prelude.map(Prelude.functorArray)(function ($167) {
                          return go(v1.value0(Prelude.unit))((function (v3) {
                              return v3(Prelude.unit);
                          })($167));
                      })(v2.value0));
                  };
                  if (v1 instanceof Data_Generic.SigRecord && v2 instanceof Data_Generic.SRecord) {
                      var pair = function (sig) {
                          return function (sp) {
                              if (sig.recLabel === sp.recLabel) {
                                  return new Data_Tuple.Tuple(sig.recLabel, go(sig.recValue(Prelude.unit))(sp.recValue(Prelude.unit)));
                              };
                              if (Prelude.otherwise) {
                                  return Control_Monad_Eff_Exception_Unsafe.unsafeThrow("Record fields do not match signature");
                              };
                              throw new Error("Failed pattern match at Data.Foreign.Generic line 135, column 5 - line 136, column 5: " + [ sig.constructor.name, sp.constructor.name ]);
                          };
                      };
                      var pairs = Data_Array.zipWith(pair)(Data_Array.sortBy(Data_Function.on(Prelude.compare(Prelude.ordString))(function (v3) {
                          return v3.recLabel;
                      }))(v1.value0))(Data_Array.sortBy(Data_Function.on(Prelude.compare(Prelude.ordString))(function (v3) {
                          return v3.recLabel;
                      }))(v2.value0));
                      return Data_Foreign.toForeign(Data_StrMap.fromList(Data_List.toList(Data_Foldable.foldableArray)(pairs)));
                  };
                  if (v1 instanceof Data_Generic.SigProd && (v1.value0 === "Data.Maybe.Maybe" && (v2 instanceof Data_Generic.SProd && (v2.value0 === "Data.Maybe.Nothing" && (v2.value1.length === 0 && v.maybeAsNull))))) {
                      return Data_Foreign.toForeign(Data_Nullable.toNullable(Data_Maybe.Nothing.value));
                  };
                  if (v1 instanceof Data_Generic.SigProd && (v1.value0 === "Data.Maybe.Maybe" && (v1.value1.length === 2 && ((v1.value1[0]).sigValues.length === 1 && (v2 instanceof Data_Generic.SProd && (v2.value0 === "Data.Maybe.Just" && (v2.value1.length === 1 && v.maybeAsNull))))))) {
                      return go((v1.value1[0]).sigValues[0](Prelude.unit))(v2.value1[0](Prelude.unit));
                  };
                  if (v1 instanceof Data_Generic.SigProd && (v1.value0 === "Data.Tuple.Tuple" && (v1.value1.length === 1 && ((v1.value1[0]).sigValues.length === 2 && (v2 instanceof Data_Generic.SProd && (v2.value0 === "Data.Tuple.Tuple" && (v2.value1.length === 2 && v.tupleAsArray))))))) {
                      return Data_Foreign.toForeign([ go((v1.value1[0]).sigValues[0](Prelude.unit))(v2.value1[0](Prelude.unit)), go((v1.value1[0]).sigValues[1](Prelude.unit))(v2.value1[1](Prelude.unit)) ]);
                  };
                  if (v1 instanceof Data_Generic.SigProd && (v1.value1.length === 1 && ((v1.value1[0]).sigValues.length === 1 && (v2 instanceof Data_Generic.SProd && (v2.value1.length === 1 && v.unwrapNewtypes))))) {
                      return go((v1.value1[0]).sigValues[0](Prelude.unit))(v2.value1[0](Prelude.unit));
                  };
                  if (v1 instanceof Data_Generic.SigProd && v2 instanceof Data_Generic.SProd) {
                      var $81 = Data_Foldable.find(Data_Foldable.foldableArray)(function (alt) {
                          return alt.sigConstructor === v2.value0;
                      })(v1.value1);
                      if ($81 instanceof Data_Maybe.Nothing) {
                          return Control_Monad_Eff_Exception_Unsafe.unsafeThrow("No signature for data constructor " + v2.value0);
                      };
                      if ($81 instanceof Data_Maybe.Just) {
                          var $82 = Data_Array.zipWith(function (sig) {
                              return function (sp) {
                                  return go(sig(Prelude.unit))(sp(Prelude.unit));
                              };
                          })($81.value0.sigValues)(v2.value1);
                          if ($82.length === 0) {
                              return Data_Foreign.toForeign(Data_StrMap.fromList(Data_List.singleton(new Data_Tuple.Tuple(v.sumEncoding.value0.tagFieldName, Data_Foreign.toForeign(v2.value0)))));
                          };
                          if ($82.length === 1 && v.unwrapSingleArgumentConstructors) {
                              return Data_Foreign.toForeign(Data_StrMap.fromList(Data_List.toList(Data_Foldable.foldableArray)([ new Data_Tuple.Tuple(v.sumEncoding.value0.tagFieldName, Data_Foreign.toForeign(v2.value0)), new Data_Tuple.Tuple(v.sumEncoding.value0.contentsFieldName, $82[0]) ])));
                          };
                          return Data_Foreign.toForeign(Data_StrMap.fromList(Data_List.toList(Data_Foldable.foldableArray)([ new Data_Tuple.Tuple(v.sumEncoding.value0.tagFieldName, Data_Foreign.toForeign(v2.value0)), new Data_Tuple.Tuple(v.sumEncoding.value0.contentsFieldName, Data_Foreign.toForeign($82)) ])));
                      };
                      throw new Error("Failed pattern match at Data.Foreign.Generic line 149, column 9 - line 161, column 3: " + [ $81.constructor.name ]);
                  };
                  return Control_Monad_Eff_Exception_Unsafe.unsafeThrow("Invalid spine for signature");
              };
          };
          return function ($168) {
              return go(Data_Generic.toSignature(dictGeneric)((Type_Proxy["Proxy"]).value))(Data_Generic.toSpine(dictGeneric)($168));
          };
      };
  };
  var toJSONGeneric = function (dictGeneric) {
      return function (opts) {
          return function ($169) {
              return Global_Unsafe.unsafeStringify(toForeignGeneric(dictGeneric)(opts)($169));
          };
      };
  };
  var readGeneric = function (dictGeneric) {
      return function (v) {
          var go = function (v1) {
              return function (f) {
                  if (v1 instanceof Data_Generic.SigNumber) {
                      return Prelude.map(Data_Either.functorEither)(Data_Generic.SNumber.create)(Data_Foreign.readNumber(f));
                  };
                  if (v1 instanceof Data_Generic.SigInt) {
                      return Prelude.map(Data_Either.functorEither)(Data_Generic.SInt.create)(Data_Foreign.readInt(f));
                  };
                  if (v1 instanceof Data_Generic.SigChar) {
                      return Prelude.map(Data_Either.functorEither)(Data_Generic.SChar.create)(Data_Foreign.readChar(f));
                  };
                  if (v1 instanceof Data_Generic.SigString) {
                      return Prelude.map(Data_Either.functorEither)(Data_Generic.SString.create)(Data_Foreign.readString(f));
                  };
                  if (v1 instanceof Data_Generic.SigBoolean) {
                      return Prelude.map(Data_Either.functorEither)(Data_Generic.SBoolean.create)(Data_Foreign.readBoolean(f));
                  };
                  if (v1 instanceof Data_Generic.SigArray) {
                      return Prelude.bind(Data_Either.bindEither)(Data_Foreign.readArray(f))(function (v2) {
                          return Prelude.bind(Data_Either.bindEither)(Data_Traversable["for"](Data_Either.applicativeEither)(Data_Traversable.traversableArray)(v2)(function (f2) {
                              return Prelude.bind(Data_Either.bindEither)(go(v1.value0(Prelude.unit))(f2))(function (v3) {
                                  return Prelude["return"](Data_Either.applicativeEither)(Prelude["const"](v3));
                              });
                          }))(function (v3) {
                              return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SArray(v3));
                          });
                      });
                  };
                  if (v1 instanceof Data_Generic.SigRecord) {
                      return Prelude.bind(Data_Either.bindEither)(Data_Traversable["for"](Data_Either.applicativeEither)(Data_Traversable.traversableArray)(v1.value0)(function (prop) {
                          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Index["!"](Data_Foreign_Index.indexString)(f)(prop.recLabel))(function (v2) {
                              return Prelude.bind(Data_Either.bindEither)(go(prop.recValue(Prelude.unit))(v2))(function (v3) {
                                  return Prelude["return"](Data_Either.applicativeEither)({
                                      recLabel: prop.recLabel, 
                                      recValue: Prelude["const"](v3)
                                  });
                              });
                          });
                      }))(function (v2) {
                          return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SRecord(v2));
                      });
                  };
                  if (v1 instanceof Data_Generic.SigProd && (v1.value1.length === 1 && ((v1.value1[0]).sigValues.length === 1 && v.unwrapNewtypes))) {
                      return Prelude.bind(Data_Either.bindEither)(go((v1.value1[0]).sigValues[0](Prelude.unit))(f))(function (v2) {
                          return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SProd((v1.value1[0]).sigConstructor, [ function (v3) {
                              return v2;
                          } ]));
                      });
                  };
                  if (v1 instanceof Data_Generic.SigProd && (v1.value0 === "Data.Maybe.Maybe" && (v1.value1.length === 2 && ((v1.value1[0]).sigValues.length === 1 && v.maybeAsNull)))) {
                      var $117 = Data_Foreign.isNull(f) || Data_Foreign.isUndefined(f);
                      if ($117) {
                          return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SProd("Data.Maybe.Nothing", [  ]));
                      };
                      if (!$117) {
                          return Prelude.bind(Data_Either.bindEither)(go((v1.value1[0]).sigValues[0](Prelude.unit))(f))(function (v2) {
                              return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SProd("Data.Maybe.Just", [ function (v3) {
                                  return v2;
                              } ]));
                          });
                      };
                      throw new Error("Failed pattern match at Data.Foreign.Generic line 89, column 5 - line 93, column 3: " + [ $117.constructor.name ]);
                  };
                  if (v1 instanceof Data_Generic.SigProd && (v1.value0 === "Data.Tuple.Tuple" && (v1.value1.length === 1 && ((v1.value1[0]).sigValues.length === 2 && v.tupleAsArray)))) {
                      return Prelude.bind(Data_Either.bindEither)(Data_Foreign.readArray(f))(function (v2) {
                          if (v2.length === 2) {
                              return Prelude.bind(Data_Either.bindEither)(go((v1.value1[0]).sigValues[0](Prelude.unit))(v2[0]))(function (v3) {
                                  return Prelude.bind(Data_Either.bindEither)(go((v1.value1[0]).sigValues[1](Prelude.unit))(v2[1]))(function (v4) {
                                      return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SProd("Data.Tuple.Tuple", [ function (v5) {
                                          return v3;
                                      }, function (v5) {
                                          return v4;
                                      } ]));
                                  });
                              });
                          };
                          return new Data_Either.Left(new Data_Foreign.TypeMismatch("array of length 2", "array"));
                      });
                  };
                  if (v1 instanceof Data_Generic.SigProd) {
                      return Prelude.bind(Data_Either.bindEither)(Prelude[">>="](Data_Either.bindEither)(Data_Foreign_Index.prop(v.sumEncoding.value0.tagFieldName)(f))(Data_Foreign.readString))(function (v2) {
                          var $142 = Data_Foldable.find(Data_Foldable.foldableArray)(function (alt) {
                              return alt.sigConstructor === v2;
                          })(v1.value1);
                          if ($142 instanceof Data_Maybe.Nothing) {
                              return new Data_Either.Left(new Data_Foreign.TypeMismatch("one of " + Prelude.show(Prelude.showArray(Prelude.showString))(Prelude.map(Prelude.functorArray)(function (v3) {
                                  return v3.sigConstructor;
                              })(v1.value1)), v2));
                          };
                          if ($142 instanceof Data_Maybe.Just && $142.value0.sigValues.length === 0) {
                              return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SProd(v2, [  ]));
                          };
                          if ($142 instanceof Data_Maybe.Just && ($142.value0.sigValues.length === 1 && v.unwrapSingleArgumentConstructors)) {
                              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Index.prop(v.sumEncoding.value0.contentsFieldName)(f))(function (v3) {
                                  return Prelude.bind(Data_Either.bindEither)(go($142.value0.sigValues[0](Prelude.unit))(v3))(function (v4) {
                                      return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SProd(v2, [ function (v5) {
                                          return v4;
                                      } ]));
                                  });
                              });
                          };
                          if ($142 instanceof Data_Maybe.Just) {
                              return Prelude.bind(Data_Either.bindEither)(Prelude[">>="](Data_Either.bindEither)(Data_Foreign_Index.prop(v.sumEncoding.value0.contentsFieldName)(f))(Data_Foreign.readArray))(function (v3) {
                                  return Prelude.bind(Data_Either.bindEither)(Data_Array.zipWithA(Data_Either.applicativeEither)(function (k) {
                                      return go(k(Prelude.unit));
                                  })($142.value0.sigValues)(v3))(function (v4) {
                                      return Prelude["return"](Data_Either.applicativeEither)(new Data_Generic.SProd(v2, Prelude.map(Prelude.functorArray)(Prelude["const"])(v4)));
                                  });
                              });
                          };
                          throw new Error("Failed pattern match at Data.Foreign.Generic line 105, column 9 - line 118, column 1: " + [ $142.constructor.name ]);
                      });
                  };
                  throw new Error("Failed pattern match at Data.Foreign.Generic line 68, column 3 - line 69, column 3: " + [ v1.constructor.name, f.constructor.name ]);
              };
          };
          var fromSpineUnsafe = function (sp) {
              var $160 = Data_Generic.fromSpine(dictGeneric)(sp);
              if ($160 instanceof Data_Maybe.Nothing) {
                  return Control_Monad_Eff_Exception_Unsafe.unsafeThrow("Invalid spine for signature");
              };
              if ($160 instanceof Data_Maybe.Just) {
                  return $160.value0;
              };
              throw new Error("Failed pattern match at Data.Foreign.Generic line 63, column 5 - line 67, column 3: " + [ $160.constructor.name ]);
          };
          return function ($170) {
              return Prelude.map(Data_Either.functorEither)(fromSpineUnsafe)(go(Data_Generic.toSignature(dictGeneric)((Type_Proxy["Proxy"]).value))($170));
          };
      };
  };
  var readJSONGeneric = function (dictGeneric) {
      return function (opts) {
          return Control_Bind[">=>"](Data_Either.bindEither)(Data_Foreign.parseJSON)(readGeneric(dictGeneric)(opts));
      };
  };
  var defaultOptions = {
      sumEncoding: new TaggedObject({
          tagFieldName: "tag", 
          contentsFieldName: "contents"
      }), 
      unwrapNewtypes: false, 
      unwrapSingleArgumentConstructors: true, 
      maybeAsNull: true, 
      tupleAsArray: false
  };
  exports["TaggedObject"] = TaggedObject;
  exports["toJSONGeneric"] = toJSONGeneric;
  exports["readJSONGeneric"] = readJSONGeneric;
  exports["toForeignGeneric"] = toForeignGeneric;
  exports["readGeneric"] = readGeneric;
  exports["defaultOptions"] = defaultOptions;
})(PS["Data.Foreign.Generic"] = PS["Data.Foreign.Generic"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var mediaTypeToString = function (v) {
      return v;
  };
  exports["mediaTypeToString"] = mediaTypeToString;
})(PS["Data.MediaType"] = PS["Data.MediaType"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Data_MediaType = PS["Data.MediaType"];           
  var applicationJSON = "application/json";
  exports["applicationJSON"] = applicationJSON;
})(PS["Data.MediaType.Common"] = PS["Data.MediaType.Common"] || {});
(function(exports) {
    "use strict";
  exports.tupleRegexImpl = function tupleRegexImpl(tuple){
    return function(just){
      return function(nothing){
        var regex = /^\((.*)\,(.*)\)$/
        return function(string){
          var results = string.match(regex);
          return results[1] && results[2] ? just(tuple(results[1])(results[2])) : nothing;
        }
      }
    }
  }
})(PS["Data.Serializable"] = PS["Data.Serializable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Serializable"];
  var Prelude = PS["Prelude"];
  var App_Model_Date = PS["App.Model.Date"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Data_Date_1 = PS["Data.Date"];
  var Data_Date_1 = PS["Data.Date"];
  var Data_Either = PS["Data.Either"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_String = PS["Data.String"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];        
  var Serializable = function (deserialize, serialize) {
      this.deserialize = deserialize;
      this.serialize = serialize;
  };
  var serialize = function (dict) {
      return dict.serialize;
  };
  var serializableUnit = new Serializable(function (s) {
      var $7 = s === "unit";
      if ($7) {
          return new Data_Either.Right(Prelude.unit);
      };
      if (!$7) {
          return Data_Either.Left.create(Control_Monad_Eff_Exception.error("Unable to deserialize " + (s + " to Unit")));
      };
      throw new Error("Failed pattern match at Data.Serializable line 74, column 19 - line 77, column 1: " + [ $7.constructor.name ]);
  }, function (s) {
      return "unit";
  });
  var serializableString = new Serializable(function ($16) {
      return Data_Either.Right.create(Prelude.id(Prelude.categoryFn)($16));
  }, Prelude.id(Prelude.categoryFn));
  var serializableDate = new Serializable(function (a) {
      return Data_Maybe.maybe(Data_Either.Left.create(Control_Monad_Eff_Exception.error("Unable to deserialize " + (a + " to Date"))))(Data_Either.Right.create)(Data_Date_1.fromStringStrict(a));
  }, App_Model_Date.toISOString);
  var deserialize = function (dict) {
      return dict.deserialize;
  };
  var serializableTuple = function (dictSerializable) {
      return function (dictSerializable1) {
          return new Serializable(function (s) {
              return Prelude.bind(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create(Control_Monad_Eff_Exception.error("Unable to deserialize " + (s + " to Tuple"))))(Data_Either.Right.create)($foreign.tupleRegexImpl(Data_Tuple.Tuple.create)(Data_Maybe.Just.create)(Data_Maybe.Nothing.value)(s)))(function (v) {
                  return Prelude.bind(Data_Either.bindEither)(deserialize(dictSerializable)(v.value0))(function (v1) {
                      return Prelude.bind(Data_Either.bindEither)(deserialize(dictSerializable1)(v.value1))(function (v2) {
                          return Prelude["return"](Data_Either.applicativeEither)(new Data_Tuple.Tuple(v1, v2));
                      });
                  });
              });
          }, function (v) {
              return "(" + (serialize(dictSerializable)(v.value0) + ("," + (serialize(dictSerializable1)(v.value1) + ")")));
          });
      };
  };
  exports["Serializable"] = Serializable;
  exports["deserialize"] = deserialize;
  exports["serialize"] = serialize;
  exports["serializableString"] = serializableString;
  exports["serializableDate"] = serializableDate;
  exports["serializableTuple"] = serializableTuple;
  exports["serializableUnit"] = serializableUnit;
})(PS["Data.Serializable"] = PS["Data.Serializable"] || {});
(function(exports) {
  /* global exports */
  /* global XMLHttpRequest */
  /* global module */
  "use strict";

  // module Network.HTTP.Affjax

  // jshint maxparams: 5
  exports._ajax = function (mkHeader, options, canceler, errback, callback) {
    var platformSpecific = { };
    if (typeof module !== "undefined" && module.require) {
      // We are on node.js
      platformSpecific.newXHR = function () {
        var XHR = module.require("xhr2");
        return new XHR();
      };

      platformSpecific.fixupUrl = function (url) {
        var urllib = module.require("url");
        var u = urllib.parse(url);
        u.protocol = u.protocol || "http:";
        u.hostname = u.hostname || "localhost";
        return urllib.format(u);
      };

      platformSpecific.getResponse = function (xhr) {
        return xhr.response;
      };
    } else {
      // We are in the browser
      platformSpecific.newXHR = function () {
        return new XMLHttpRequest();
      };

      platformSpecific.fixupUrl = function (url) {
        return url || "/";
      };

      platformSpecific.getResponse = function (xhr) {
        return xhr.response;
      };
    }

    return function () {
      var xhr = platformSpecific.newXHR();
      var fixedUrl = platformSpecific.fixupUrl(options.url);
      xhr.open(options.method || "GET", fixedUrl, true, options.username, options.password);
      if (options.headers) {
        try {
          for (var i = 0, header; (header = options.headers[i]) != null; i++) {
            xhr.setRequestHeader(header.field, header.value);
          }
        }
        catch (e) {
          errback(e)();
        }
      }
      xhr.onerror = function () {
        errback(new Error("AJAX request failed: " + options.method + " " + options.url))();
      };
      xhr.onload = function () {
        callback({
          status: xhr.status,
          headers: xhr.getAllResponseHeaders().split("\n")
            .filter(function (header) {
              return header.length > 0;
            })
            .map(function (header) {
              var i = header.indexOf(":");
              return mkHeader(header.substring(0, i))(header.substring(i + 2));
            }),
          response: platformSpecific.getResponse(xhr)
        })();
      };
      xhr.responseType = options.responseType;
      xhr.withCredentials = options.withCredentials;
      xhr.send(options.content);
      return canceler(xhr);
    };
  };

  // jshint maxparams: 4
  exports._cancelAjax = function (xhr, cancelError, errback, callback) {
    return function () {
      try { xhr.abort(); } catch (e) { return callback(false)(); }
      return callback(true)();
    };
  };
})(PS["Network.HTTP.Affjax"] = PS["Network.HTTP.Affjax"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
  var Data_ArrayBuffer_Types = PS["Data.ArrayBuffer.Types"];
  var Data_FormURLEncoded_1 = PS["Data.FormURLEncoded"];
  var Data_FormURLEncoded_1 = PS["Data.FormURLEncoded"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_MediaType = PS["Data.MediaType"];
  var Data_MediaType_Common = PS["Data.MediaType.Common"];
  var Data_Tuple = PS["Data.Tuple"];
  var DOM_File_Types = PS["DOM.File.Types"];
  var DOM_Node_Types = PS["DOM.Node.Types"];
  var DOM_XHR_Types = PS["DOM.XHR.Types"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];        
  var Requestable = function (toRequest) {
      this.toRequest = toRequest;
  };
  var toRequest = function (dict) {
      return dict.toRequest;
  }; 
  var defaultToRequest = function ($0) {
      return Data_Tuple.Tuple.create(Data_Maybe.Nothing.value)(Unsafe_Coerce.unsafeCoerce($0));
  };                                                                
  var requestableString = new Requestable(defaultToRequest);
  exports["Requestable"] = Requestable;
  exports["toRequest"] = toRequest;
  exports["requestableString"] = requestableString;
})(PS["Network.HTTP.Affjax.Request"] = PS["Network.HTTP.Affjax.Request"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
  var Data_ArrayBuffer_Types = PS["Data.ArrayBuffer.Types"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_MediaType = PS["Data.MediaType"];
  var Data_MediaType_Common = PS["Data.MediaType.Common"];
  var Data_Tuple = PS["Data.Tuple"];
  var DOM_File_Types = PS["DOM.File.Types"];
  var DOM_Node_Types = PS["DOM.Node.Types"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];        
  var ArrayBufferResponse = (function () {
      function ArrayBufferResponse() {

      };
      ArrayBufferResponse.value = new ArrayBufferResponse();
      return ArrayBufferResponse;
  })();
  var BlobResponse = (function () {
      function BlobResponse() {

      };
      BlobResponse.value = new BlobResponse();
      return BlobResponse;
  })();
  var DocumentResponse = (function () {
      function DocumentResponse() {

      };
      DocumentResponse.value = new DocumentResponse();
      return DocumentResponse;
  })();
  var JSONResponse = (function () {
      function JSONResponse() {

      };
      JSONResponse.value = new JSONResponse();
      return JSONResponse;
  })();
  var StringResponse = (function () {
      function StringResponse() {

      };
      StringResponse.value = new StringResponse();
      return StringResponse;
  })();
  var Respondable = function (fromResponse, responseType) {
      this.fromResponse = fromResponse;
      this.responseType = responseType;
  }; 
  var responseTypeToString = function (v) {
      if (v instanceof ArrayBufferResponse) {
          return "arraybuffer";
      };
      if (v instanceof BlobResponse) {
          return "blob";
      };
      if (v instanceof DocumentResponse) {
          return "document";
      };
      if (v instanceof JSONResponse) {
          return "text";
      };
      if (v instanceof StringResponse) {
          return "text";
      };
      throw new Error("Failed pattern match at Network.HTTP.Affjax.Response line 50, column 1 - line 51, column 1: " + [ v.constructor.name ]);
  };
  var responseType = function (dict) {
      return dict.responseType;
  };                                                                                                                                                                 
  var responsableString = new Respondable(Data_Foreign.readString, new Data_Tuple.Tuple(Data_Maybe.Nothing.value, StringResponse.value));                               
  var fromResponse = function (dict) {
      return dict.fromResponse;
  };
  exports["ArrayBufferResponse"] = ArrayBufferResponse;
  exports["BlobResponse"] = BlobResponse;
  exports["DocumentResponse"] = DocumentResponse;
  exports["JSONResponse"] = JSONResponse;
  exports["StringResponse"] = StringResponse;
  exports["Respondable"] = Respondable;
  exports["fromResponse"] = fromResponse;
  exports["responseType"] = responseType;
  exports["responseTypeToString"] = responseTypeToString;
  exports["responsableString"] = responsableString;
})(PS["Network.HTTP.Affjax.Response"] = PS["Network.HTTP.Affjax.Response"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_MediaType = PS["Data.MediaType"];        
  var Accept = (function () {
      function Accept(value0) {
          this.value0 = value0;
      };
      Accept.create = function (value0) {
          return new Accept(value0);
      };
      return Accept;
  })();
  var ContentType = (function () {
      function ContentType(value0) {
          this.value0 = value0;
      };
      ContentType.create = function (value0) {
          return new ContentType(value0);
      };
      return ContentType;
  })();
  var RequestHeader = (function () {
      function RequestHeader(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      RequestHeader.create = function (value0) {
          return function (value1) {
              return new RequestHeader(value0, value1);
          };
      };
      return RequestHeader;
  })();
  var requestHeaderValue = function (v) {
      if (v instanceof Accept) {
          return Data_MediaType.mediaTypeToString(v.value0);
      };
      if (v instanceof ContentType) {
          return Data_MediaType.mediaTypeToString(v.value0);
      };
      if (v instanceof RequestHeader) {
          return v.value1;
      };
      throw new Error("Failed pattern match at Network.HTTP.RequestHeader line 29, column 1 - line 30, column 1: " + [ v.constructor.name ]);
  };
  var requestHeaderName = function (v) {
      if (v instanceof Accept) {
          return "Accept";
      };
      if (v instanceof ContentType) {
          return "Content-Type";
      };
      if (v instanceof RequestHeader) {
          return v.value0;
      };
      throw new Error("Failed pattern match at Network.HTTP.RequestHeader line 24, column 1 - line 25, column 1: " + [ v.constructor.name ]);
  };
  exports["Accept"] = Accept;
  exports["ContentType"] = ContentType;
  exports["RequestHeader"] = RequestHeader;
  exports["requestHeaderValue"] = requestHeaderValue;
  exports["requestHeaderName"] = requestHeaderName;
})(PS["Network.HTTP.RequestHeader"] = PS["Network.HTTP.RequestHeader"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];        
  var ResponseHeader = (function () {
      function ResponseHeader(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ResponseHeader.create = function (value0) {
          return function (value1) {
              return new ResponseHeader(value0, value1);
          };
      };
      return ResponseHeader;
  })();
  var responseHeader = function (field) {
      return function (value) {
          return new ResponseHeader(field, value);
      };
  };
  exports["responseHeader"] = responseHeader;
})(PS["Network.HTTP.ResponseHeader"] = PS["Network.HTTP.ResponseHeader"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Network.HTTP.Affjax"];
  var Prelude = PS["Prelude"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Aff_AVar = PS["Control.Monad.Aff.AVar"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Eff_Ref = PS["Control.Monad.Eff.Ref"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Data_Array = PS["Data.Array"];
  var Data_Either = PS["Data.Either"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Function = PS["Data.Function"];
  var Data_HTTP_Method_1 = PS["Data.HTTP.Method"];
  var Data_HTTP_Method_1 = PS["Data.HTTP.Method"];
  var Data_Int = PS["Data.Int"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_MediaType = PS["Data.MediaType"];
  var Data_Nullable = PS["Data.Nullable"];
  var Data_Tuple = PS["Data.Tuple"];
  var $$Math = PS["Math"];
  var DOM_XHR_Types = PS["DOM.XHR.Types"];
  var Network_HTTP_Affjax_Request = PS["Network.HTTP.Affjax.Request"];
  var Network_HTTP_Affjax_Response = PS["Network.HTTP.Affjax.Response"];
  var Network_HTTP_RequestHeader = PS["Network.HTTP.RequestHeader"];
  var Network_HTTP_ResponseHeader = PS["Network.HTTP.ResponseHeader"];
  var Network_HTTP_StatusCode = PS["Network.HTTP.StatusCode"];
  var cancelAjax = function (xhr) {
      return function (err) {
          return Control_Monad_Aff.makeAff(function (eb) {
              return function (cb) {
                  return $foreign._cancelAjax(xhr, err, eb, cb);
              };
          });
      };
  };
  var affjax$prime = function (dictRequestable) {
      return function (dictRespondable) {
          return function (req) {
              return function (eb) {
                  return function (cb) {
                      var responseSettings = Network_HTTP_Affjax_Response.responseType(dictRespondable);
                      var requestSettings = (function () {
                          var $49 = Prelude["<$>"](Data_Maybe.functorMaybe)(Network_HTTP_Affjax_Request.toRequest(dictRequestable))(req.content);
                          if ($49 instanceof Data_Maybe.Nothing) {
                              return new Data_Tuple.Tuple(Data_Maybe.Nothing.value, Data_Maybe.Nothing.value);
                          };
                          if ($49 instanceof Data_Maybe.Just) {
                              return new Data_Tuple.Tuple($49.value0.value0, new Data_Maybe.Just($49.value0.value1));
                          };
                          throw new Error("Failed pattern match at Network.HTTP.Affjax line 238, column 21 - line 242, column 3: " + [ $49.constructor.name ]);
                      })();
                      var fromResponse$prime = (function () {
                          var $53 = Data_Tuple.snd(responseSettings);
                          if ($53 instanceof Network_HTTP_Affjax_Response.JSONResponse) {
                              return Control_Bind["<=<"](Data_Either.bindEither)(Network_HTTP_Affjax_Response.fromResponse(dictRespondable))(Control_Bind["<=<"](Data_Either.bindEither)(Data_Foreign.parseJSON)(Data_Foreign.readString));
                          };
                          return Network_HTTP_Affjax_Response.fromResponse(dictRespondable);
                      })();
                      var cb$prime = function (res) {
                          var $56 = Prelude["<$>"](Data_Either.functorEither)(function (v) {
                              var $54 = {};
                              for (var $55 in res) {
                                  if (res.hasOwnProperty($55)) {
                                      $54[$55] = res[$55];
                                  };
                              };
                              $54.response = v;
                              return $54;
                          })(fromResponse$prime(res.response));
                          if ($56 instanceof Data_Either.Left) {
                              return eb(Control_Monad_Eff_Exception.error(Prelude.show(Data_Foreign.showForeignError)($56.value0)));
                          };
                          if ($56 instanceof Data_Either.Right) {
                              return cb($56.value0);
                          };
                          throw new Error("Failed pattern match at Network.HTTP.Affjax line 257, column 13 - line 261, column 3: " + [ $56.constructor.name ]);
                      };
                      var addHeader = function (h) {
                          return function (hs) {
                              if (h instanceof Data_Maybe.Just && !Data_Foldable.any(Data_Foldable.foldableArray)(Prelude.booleanAlgebraBoolean)(Data_Function.on(Prelude.eq(Prelude.eqString))(Network_HTTP_RequestHeader.requestHeaderName)(h.value0))(hs)) {
                                  return Data_Array.snoc(hs)(h.value0);
                              };
                              return hs;
                          };
                      };
                      var headers = addHeader(Prelude["<$>"](Data_Maybe.functorMaybe)(Network_HTTP_RequestHeader.ContentType.create)(Data_Tuple.fst(requestSettings)))(addHeader(Prelude["<$>"](Data_Maybe.functorMaybe)(Network_HTTP_RequestHeader.Accept.create)(Data_Tuple.fst(responseSettings)))(req.headers));
                      var req$prime = {
                          method: Data_HTTP_Method_1.print(req.method), 
                          url: req.url, 
                          headers: Prelude["<$>"](Prelude.functorArray)(function (h) {
                              return {
                                  field: Network_HTTP_RequestHeader.requestHeaderName(h), 
                                  value: Network_HTTP_RequestHeader.requestHeaderValue(h)
                              };
                          })(headers), 
                          content: Data_Nullable.toNullable(Data_Tuple.snd(requestSettings)), 
                          responseType: Network_HTTP_Affjax_Response.responseTypeToString(Data_Tuple.snd(responseSettings)), 
                          username: Data_Nullable.toNullable(req.username), 
                          password: Data_Nullable.toNullable(req.password), 
                          withCredentials: req.withCredentials
                      };
                      return $foreign._ajax(Network_HTTP_ResponseHeader.responseHeader, req$prime, cancelAjax, eb, cb$prime);
                  };
              };
          };
      };
  };
  var affjax = function (dictRequestable) {
      return function (dictRespondable) {
          return function ($74) {
              return Control_Monad_Aff["makeAff'"](affjax$prime(dictRequestable)(dictRespondable)($74));
          };
      };
  };
  exports["affjax"] = affjax;
})(PS["Network.HTTP.Affjax"] = PS["Network.HTTP.Affjax"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Data_Either = PS["Data.Either"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var DOM_File_Types = PS["DOM.File.Types"];
  var Data_Foreign_Generic = PS["Data.Foreign.Generic"];
  var Data_Generic = PS["Data.Generic"];
  var Data_HTTP_Method = PS["Data.HTTP.Method"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_MediaType_Common = PS["Data.MediaType.Common"];
  var Data_Serializable = PS["Data.Serializable"];
  var Debug_Trace = PS["Debug.Trace"];
  var Global = PS["Global"];
  var Network_HTTP_Affjax = PS["Network.HTTP.Affjax"];
  var Network_HTTP_RequestHeader = PS["Network.HTTP.RequestHeader"];
  var Prelude = PS["Prelude"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var Network_HTTP_Affjax_Request = PS["Network.HTTP.Affjax.Request"];
  var Network_HTTP_Affjax_Response = PS["Network.HTTP.Affjax.Response"];
  var Endpoint = (function () {
      function Endpoint(value0) {
          this.value0 = value0;
      };
      Endpoint.create = function (value0) {
          return new Endpoint(value0);
      };
      return Endpoint;
  })();
  var parseOrThrow = function (dictGeneric) {
      return function (s) {
          return Data_Either.either(function (e) {
              return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Failed to parse: " + s));
          })(Prelude["return"](Control_Monad_Aff.applicativeAff))(Data_Foreign_Generic.readJSONGeneric(dictGeneric)(Data_Foreign_Generic.defaultOptions)(s));
      };
  };
  var execEndpoint_ = function (dictSerializable) {
      return function (dictGeneric) {
          return function (dictGeneric1) {
              return function (s) {
                  return function (v) {
                      return function (a) {
                          return function (b) {
                              if (v.value0.method instanceof Data_HTTP_Method.GET) {
                                  var url = Global["encodeURI"](s + (v.value0.url + ("?params=" + Data_Serializable.serialize(dictSerializable)(a))));
                                  var opts = {
                                      method: new Data_Either.Left(Data_HTTP_Method.GET.value), 
                                      url: url, 
                                      headers: [ new Network_HTTP_RequestHeader.ContentType(Data_MediaType_Common.applicationJSON) ], 
                                      content: Data_Maybe.Nothing.value, 
                                      username: Data_Maybe.Nothing.value, 
                                      password: Data_Maybe.Nothing.value, 
                                      withCredentials: false
                                  };
                                  return Prelude[">>="](Control_Monad_Aff.bindAff)(Network_HTTP_Affjax.affjax(Network_HTTP_Affjax_Request.requestableString)(Network_HTTP_Affjax_Response.responsableString)(opts))(function ($30) {
                                      return parseOrThrow(dictGeneric1)((function (v1) {
                                          return v1.response;
                                      })($30));
                                  });
                              };
                              var opts = {
                                  method: new Data_Either.Left(v.value0.method), 
                                  url: Global["encodeURI"](s + (v.value0.url + ("?params=" + Data_Serializable.serialize(dictSerializable)(a)))), 
                                  headers: [ new Network_HTTP_RequestHeader.ContentType(Data_MediaType_Common.applicationJSON) ], 
                                  content: Data_Maybe.Just.create(Data_Foreign_Generic.toJSONGeneric(dictGeneric)(Data_Foreign_Generic.defaultOptions)(b)), 
                                  username: Data_Maybe.Nothing.value, 
                                  password: Data_Maybe.Nothing.value, 
                                  withCredentials: false
                              };
                              return Prelude[">>="](Control_Monad_Aff.bindAff)(Network_HTTP_Affjax.affjax(Network_HTTP_Affjax_Request.requestableString)(Network_HTTP_Affjax_Response.responsableString)(opts))(function ($31) {
                                  return parseOrThrow(dictGeneric1)((function (v1) {
                                      return v1.response;
                                  })($31));
                              });
                          };
                      };
                  };
              };
          };
      };
  };
  exports["Endpoint"] = Endpoint;
  exports["parseOrThrow"] = parseOrThrow;
  exports["execEndpoint_"] = execEndpoint_;
})(PS["Endpoint.Client"] = PS["Endpoint.Client"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_HTTP_Method = PS["Data.HTTP.Method"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Date = PS["Data.Date"];
  var Data_Maybe = PS["Data.Maybe"];
  var App_Model_Photobooth = PS["App.Model.Photobooth"];
  var App_Model_Event = PS["App.Model.Event"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var App_Model_Statistic = PS["App.Model.Statistic"];
  var App_Model_Date = PS["App.Model.Date"];
  var App_Model_Session = PS["App.Model.Session"];
  var Endpoint_Client = PS["Endpoint.Client"];
  var postStatistics = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.POST.value, 
      url: "/api/statistics"
  });
  var getProfileFiles = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/profiles/files"
  });
  var getPhotobooth = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/photobooths/cname"
  });
  var getNewFiles = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/newfiles"
  });
  var getNewEvents = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/newevents"
  });
  exports["getProfileFiles"] = getProfileFiles;
  exports["postStatistics"] = postStatistics;
  exports["getNewFiles"] = getNewFiles;
  exports["getNewEvents"] = getNewEvents;
  exports["getPhotobooth"] = getPhotobooth;
})(PS["App.Endpoint"] = PS["App.Endpoint"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Global = PS["Global"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var Data_Char = PS["Data.Char"];
  var Data_String = PS["Data.String"];
  var Data_Int = PS["Data.Int"];
  var semiringPerm = new Prelude.Semiring(function (v) {
      return function (v1) {
          return {
              r: v.r || v1.r, 
              w: v.w || v1.w, 
              x: v.x || v1.x
          };
      };
  }, function (v) {
      return function (v1) {
          return {
              r: v.r && v1.r, 
              w: v.w && v1.w, 
              x: v.x && v1.x
          };
      };
  }, {
      r: true, 
      w: true, 
      x: true
  }, {
      r: false, 
      w: false, 
      x: false
  });
  var permToInt = function (v) {
      return ((function () {
          if (v.r) {
              return 4;
          };
          if (!v.r) {
              return 0;
          };
          throw new Error("Failed pattern match at Node.FS.Perms line 158, column 8 - line 158, column 26: " + [ v.r.constructor.name ]);
      })() + (function () {
          if (v.w) {
              return 2;
          };
          if (!v.w) {
              return 0;
          };
          throw new Error("Failed pattern match at Node.FS.Perms line 159, column 8 - line 159, column 26: " + [ v.w.constructor.name ]);
      })() | 0) + (function () {
          if (v.x) {
              return 1;
          };
          if (!v.x) {
              return 0;
          };
          throw new Error("Failed pattern match at Node.FS.Perms line 160, column 8 - line 160, column 26: " + [ v.x.constructor.name ]);
      })() | 0;
  };
  var permToString = function ($95) {
      return Prelude.show(Prelude.showInt)(permToInt($95));
  };
  var permsToString = function (v) {
      return "0" + (permToString(v.u) + (permToString(v.g) + permToString(v.o)));
  };                                    
  var mkPerms = function (u) {
      return function (g) {
          return function (o) {
              return {
                  u: u, 
                  g: g, 
                  o: o
              };
          };
      };
  }; 
  var all = Prelude.one(semiringPerm);
  exports["permsToString"] = permsToString;
  exports["mkPerms"] = mkPerms;
  exports["all"] = all;
  exports["semiringPerm"] = semiringPerm;
})(PS["Node.FS.Perms"] = PS["Node.FS.Perms"] || {});
(function(exports) {
  /* global require */
  /* global exports */
  "use strict";                                  

  exports.statsMethod = function (m, s) {
    return s[m]();
  }
})(PS["Node.FS.Stats"] = PS["Node.FS.Stats"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.FS.Stats"];
  var Prelude = PS["Prelude"];
  var Data_Date = PS["Data.Date"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];        
  var Stats = (function () {
      function Stats(value0) {
          this.value0 = value0;
      };
      Stats.create = function (value0) {
          return new Stats(value0);
      };
      return Stats;
  })();
  var isDirectory = function (v) {
      return $foreign.statsMethod("isDirectory", v.value0);
  };
  exports["Stats"] = Stats;
  exports["isDirectory"] = isDirectory;
})(PS["Node.FS.Stats"] = PS["Node.FS.Stats"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.Encoding"];
  var Prelude = PS["Prelude"];        
  var ASCII = (function () {
      function ASCII() {

      };
      ASCII.value = new ASCII();
      return ASCII;
  })();
  var UTF8 = (function () {
      function UTF8() {

      };
      UTF8.value = new UTF8();
      return UTF8;
  })();
  var UTF16LE = (function () {
      function UTF16LE() {

      };
      UTF16LE.value = new UTF16LE();
      return UTF16LE;
  })();
  var UCS2 = (function () {
      function UCS2() {

      };
      UCS2.value = new UCS2();
      return UCS2;
  })();
  var Base64 = (function () {
      function Base64() {

      };
      Base64.value = new Base64();
      return Base64;
  })();
  var Binary = (function () {
      function Binary() {

      };
      Binary.value = new Binary();
      return Binary;
  })();
  var Hex = (function () {
      function Hex() {

      };
      Hex.value = new Hex();
      return Hex;
  })();
  var showEncoding = new Prelude.Show(function (v) {
      if (v instanceof ASCII) {
          return "ascii";
      };
      if (v instanceof UTF8) {
          return "utf8";
      };
      if (v instanceof UTF16LE) {
          return "utf16le";
      };
      if (v instanceof UCS2) {
          return "ucs2";
      };
      if (v instanceof Base64) {
          return "base64";
      };
      if (v instanceof Binary) {
          return "binary";
      };
      if (v instanceof Hex) {
          return "hex";
      };
      throw new Error("Failed pattern match at Node.Encoding line 18, column 3 - line 19, column 3: " + [ v.constructor.name ]);
  });
  exports["ASCII"] = ASCII;
  exports["UTF8"] = UTF8;
  exports["UTF16LE"] = UTF16LE;
  exports["UCS2"] = UCS2;
  exports["Base64"] = Base64;
  exports["Binary"] = Binary;
  exports["Hex"] = Hex;
  exports["showEncoding"] = showEncoding;
})(PS["Node.Encoding"] = PS["Node.Encoding"] || {});
(function(exports) {
  /* global require */
  /* global exports */
  "use strict";

  // module Node.FS.Async

  exports.handleCallbackImpl = function (left, right, f) {
    return function (err, value) {
      if (err) {
        f(left(err))();
      } else {
        f(right(value))();
      }
    };
  };
})(PS["Node.FS.Async"] = PS["Node.FS.Async"] || {});
(function(exports) {
    "use strict";
  // module Node.FS.Internal

  exports.unsafeRequireFS = require("fs");
})(PS["Node.FS.Internal"] = PS["Node.FS.Internal"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.FS.Internal"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];        
  var mkEff = Unsafe_Coerce.unsafeCoerce;
  exports["mkEff"] = mkEff;
  exports["unsafeRequireFS"] = $foreign.unsafeRequireFS;
})(PS["Node.FS.Internal"] = PS["Node.FS.Internal"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.FS.Async"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Unsafe = PS["Control.Monad.Eff.Unsafe"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Data_Date = PS["Data.Date"];
  var Data_Time = PS["Data.Time"];
  var Data_Either = PS["Data.Either"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Nullable = PS["Data.Nullable"];
  var Node_Buffer = PS["Node.Buffer"];
  var Data_Int = PS["Data.Int"];
  var Node_Encoding = PS["Node.Encoding"];
  var Node_FS = PS["Node.FS"];
  var Node_FS_Stats = PS["Node.FS.Stats"];
  var Node_Path = PS["Node.Path"];
  var Node_FS_Perms = PS["Node.FS.Perms"];
  var Node_FS_Internal = PS["Node.FS.Internal"];        
  var handleCallback = function (cb) {
      return $foreign.handleCallbackImpl(Data_Either.Left.create, Data_Either.Right.create, cb);
  };
  var fs = Node_FS_Internal.unsafeRequireFS;
  var mkdir$prime = function (file) {
      return function (perms) {
          return function (cb) {
              return Node_FS_Internal.mkEff(function (v) {
                  return fs.mkdir(file, Node_FS_Perms.permsToString(perms), handleCallback(cb));
              });
          };
      };
  };
  var mkdir = Prelude.flip(mkdir$prime)(Node_FS_Perms.mkPerms(Node_FS_Perms.all)(Node_FS_Perms.all)(Node_FS_Perms.all));
  var readFile = function (file) {
      return function (cb) {
          return Node_FS_Internal.mkEff(function (v) {
              return fs.readFile(file, {}, handleCallback(cb));
          });
      };
  };
  var readdir = function (file) {
      return function (cb) {
          return Node_FS_Internal.mkEff(function (v) {
              return fs.readdir(file, handleCallback(cb));
          });
      };
  };
  var rmdir = function (file) {
      return function (cb) {
          return Node_FS_Internal.mkEff(function (v) {
              return fs.rmdir(file, handleCallback(cb));
          });
      };
  };
  var stat = function (file) {
      return function (cb) {
          return Node_FS_Internal.mkEff(function (v) {
              return fs.stat(file, handleCallback(function ($58) {
                  return cb(Prelude["<$>"](Data_Either.functorEither)(Node_FS_Stats.Stats.create)($58));
              }));
          });
      };
  };
  var unlink = function (file) {
      return function (cb) {
          return Node_FS_Internal.mkEff(function (v) {
              return fs.unlink(file, handleCallback(cb));
          });
      };
  };
  var writeFile = function (file) {
      return function (buff) {
          return function (cb) {
              return Node_FS_Internal.mkEff(function (v) {
                  return fs.writeFile(file, buff, {}, handleCallback(cb));
              });
          };
      };
  };
  var exists = function (file) {
      return function (cb) {
          return Node_FS_Internal.mkEff(function (v) {
              return fs.exists(file, function (b) {
                  return Control_Monad_Eff.runPure(Control_Monad_Eff_Unsafe.unsafeInterleaveEff(cb(b)));
              });
          });
      };
  };
  var appendTextFile = function (encoding) {
      return function (file) {
          return function (buff) {
              return function (cb) {
                  return Node_FS_Internal.mkEff(function (v) {
                      return fs.appendFile(file, buff, {
                          encoding: Prelude.show(Node_Encoding.showEncoding)(encoding)
                      }, handleCallback(cb));
                  });
              };
          };
      };
  };
  var appendFile = function (file) {
      return function (buff) {
          return function (cb) {
              return Node_FS_Internal.mkEff(function (v) {
                  return fs.appendFile(file, buff, {}, handleCallback(cb));
              });
          };
      };
  };
  exports["exists"] = exists;
  exports["appendTextFile"] = appendTextFile;
  exports["appendFile"] = appendFile;
  exports["writeFile"] = writeFile;
  exports["readFile"] = readFile;
  exports["readdir"] = readdir;
  exports["mkdir"] = mkdir;
  exports["rmdir"] = rmdir;
  exports["unlink"] = unlink;
  exports["stat"] = stat;
})(PS["Node.FS.Async"] = PS["Node.FS.Async"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Node_Path = PS["Node.Path"];
  var Node_FS_Perms = PS["Node.FS.Perms"];
  var Node_FS_Stats = PS["Node.FS.Stats"];
  var Data_Date = PS["Data.Date"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Either = PS["Data.Either"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Node_Buffer = PS["Node.Buffer"];
  var Node_Encoding = PS["Node.Encoding"];
  var Node_FS = PS["Node.FS"];
  var Node_FS_Async = PS["Node.FS.Async"];        
  var toAff = function (p) {
      return Control_Monad_Aff.makeAff(function (e) {
          return function (a) {
              return p(Data_Either.either(e)(a));
          };
      });
  };
  var toAff1 = function (f) {
      return function (a) {
          return toAff(f(a));
      };
  };
  var unlink = toAff1(Node_FS_Async.unlink);
  var toAff2 = function (f) {
      return function (a) {
          return function (b) {
              return toAff(f(a)(b));
          };
      };
  };                                            
  var writeFile = toAff2(Node_FS_Async.writeFile);
  var toAff3 = function (f) {
      return function (a) {
          return function (b) {
              return function (c) {
                  return toAff(f(a)(b)(c));
              };
          };
      };
  };                                          
  var stat = toAff1(Node_FS_Async.stat);
  var rmdir = toAff1(Node_FS_Async.rmdir);      
  var readdir = toAff1(Node_FS_Async.readdir);          
  var readFile = toAff1(Node_FS_Async.readFile);    
  var mkdir = toAff1(Node_FS_Async.mkdir);      
  var exists = function (file) {
      return Control_Monad_Aff.makeAff(function (v) {
          return function (a) {
              return Node_FS_Async.exists(file)(a);
          };
      });
  };                                      
  var appendTextFile = toAff3(Node_FS_Async.appendTextFile);
  exports["exists"] = exists;
  exports["appendTextFile"] = appendTextFile;
  exports["writeFile"] = writeFile;
  exports["readFile"] = readFile;
  exports["readdir"] = readdir;
  exports["mkdir"] = mkdir;
  exports["rmdir"] = rmdir;
  exports["unlink"] = unlink;
  exports["stat"] = stat;
})(PS["Node.FS.Aff"] = PS["Node.FS.Aff"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Traversable = PS["Data.Traversable"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Node_Buffer = PS["Node.Buffer"];
  var Node_FS = PS["Node.FS"];
  var Node_FS_Aff = PS["Node.FS.Aff"];
  var Node_FS_Stats = PS["Node.FS.Stats"];
  var Node_Path = PS["Node.Path"];        
  var safeMkdir = function (f) {
      return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.exists(f))(function (doesExist) {
          var $5 = !doesExist;
          if ($5) {
              return Node_FS_Aff.mkdir(f);
          };
          if (!$5) {
              return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
          };
          throw new Error("Failed pattern match at App.FS line 14, column 43 - line 14, column 91: " + [ $5.constructor.name ]);
      });
  };
  var rmdirRecur = function (d) {
      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.exists(d))(function (v) {
          var $7 = !v;
          if ($7) {
              return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
          };
          if (!$7) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(d))(function (v1) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (f) {
                      var path = Node_Path.concat([ d, f ]);
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.stat(path))(function (v2) {
                          var $10 = Node_FS_Stats.isDirectory(v2);
                          if ($10) {
                              return rmdirRecur(path);
                          };
                          if (!$10) {
                              return Node_FS_Aff.unlink(path);
                          };
                          throw new Error("Failed pattern match at App.FS line 25, column 39 - line 25, column 94: " + [ $10.constructor.name ]);
                      });
                  })(v1))(function () {
                      return Node_FS_Aff.rmdir(d);
                  });
              });
          };
          throw new Error("Failed pattern match at App.FS line 20, column 3 - line 28, column 1: " + [ $7.constructor.name ]);
      });
  };
  var overWriteFile = function (f) {
      return function (b) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.exists(f))(function (v) {
              return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                  if (v) {
                      return Node_FS_Aff.unlink(f);
                  };
                  if (!v) {
                      return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                  };
                  throw new Error("Failed pattern match at App.FS line 31, column 3 - line 33, column 3: " + [ v.constructor.name ]);
              })())(function () {
                  return Node_FS_Aff.writeFile(f)(b);
              });
          });
      };
  };
  var mkTempEventDir = function (i) {
      return Node_Path.concat([ "clientprofiles", "tmp_event_" + Prelude.show(Prelude.showInt)(i) ]);
  };
  var mkEventDir = function (i) {
      return Node_Path.concat([ "clientprofiles", "event_" + Prelude.show(Prelude.showInt)(i) ]);
  };
  var defaultDir = Node_Path.concat([ "clientprofiles", "default" ]);
  var copyDir = function (from) {
      return function (to) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(rmdirRecur(to))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(from))(function (v) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.mkdir(to))(function () {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (f) {
                          return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.readFile(Node_Path.concat([ from, f ])))(Node_FS_Aff.writeFile(Node_Path.concat([ to, f ])));
                      })(v))(function () {
                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                      });
                  });
              });
          });
      };
  };
  exports["defaultDir"] = defaultDir;
  exports["mkTempEventDir"] = mkTempEventDir;
  exports["mkEventDir"] = mkEventDir;
  exports["copyDir"] = copyDir;
  exports["overWriteFile"] = overWriteFile;
  exports["rmdirRecur"] = rmdirRecur;
  exports["safeMkdir"] = safeMkdir;
})(PS["App.FS"] = PS["App.FS"] || {});
(function(exports) {
    "use strict";
  var http =require("http");
  var fs =require("fs"); 

  exports._downloadFile = function(name){
    return function(url){
      return function(errcb){
        return function(successcb){
          return function(){
            var file = fs.createWriteStream(name);
            http.get(url, function(response) {
              response.pipe(file);
              file.on("finish", function() {
                file.close(function(x){
                  successcb(x)();
                });
              });
            }).on("error", function(err){
              fs.unlink(file);
              errcb(err)();
            });
          };
        };
      };
    };
  };
})(PS["App.Networking"] = PS["App.Networking"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Control.Monad.Eff.Random

  exports.random = Math.random;
})(PS["Control.Monad.Eff.Random"] = PS["Control.Monad.Eff.Random"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff.Random"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Int = PS["Data.Int"];
  var randomInt = function (low) {
      return function (high) {
          return function __do() {
              var v = $foreign.random();
              var asNumber = ((Data_Int.toNumber(high) - Data_Int.toNumber(low)) + 1) * v + Data_Int.toNumber(low);
              return Data_Int.floor(asNumber);
          };
      };
  };
  exports["randomInt"] = randomInt;
})(PS["Control.Monad.Eff.Random"] = PS["Control.Monad.Eff.Random"] || {});
(function(exports) {
    "use strict";

  //module Data.Int.Extended

  exports.pInt = function pInt(nothing){
    return function(just){
      return function(str){
        var i = parseInt(str);
        if (isNaN(i)){
          return nothing;
        } else {
          return just(i);
        }
      };
    };
  };
})(PS["Data.Int.Extended"] = PS["Data.Int.Extended"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Int.Extended"];
  var Data_Maybe = PS["Data.Maybe"];        
  var safeParseInt = function (str) {
      return $foreign.pInt(Data_Maybe.Nothing.value)(Data_Maybe.Just.create)(str);
  };
  exports["safeParseInt"] = safeParseInt;
})(PS["Data.Int.Extended"] = PS["Data.Int.Extended"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_String = PS["Data.String"];        
  var startsWith = function (big) {
      return function (small) {
          return Data_String.take(Data_String.length(small))(big) === small;
      };
  };
  exports["startsWith"] = startsWith;
})(PS["Data.String.Extended"] = PS["Data.String.Extended"] || {});
(function(exports) {
    "use strict";

  // module Database.AnyDB.Transaction
  /* eslint-env node*/

  exports.beginTransaction = function beginTransaction(con) {
    return function(success, error) {
      var begin = require("any-db-transaction");
      begin(con, function(err, tx) {
        if (err) {
          error(err);
        } else {
          success(tx, error);
        }
      });
    };
  };

  exports.commitTransaction = function commitTransaction(tx) {
    return function(success, error) {
      tx.commit(success, error);
    };
  };
})(PS["Database.AnyDB.Transaction"] = PS["Database.AnyDB.Transaction"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Database.AnyDB.Transaction"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Database_AnyDB = PS["Database.AnyDB"];        
  var withTransaction = function (p) {
      return function (con) {
          return Prelude.bind(Control_Monad_Aff.bindAff)($foreign.beginTransaction(con))(function (v) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(p(con))(function (v1) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)($foreign.commitTransaction(v))(function () {
                      return Prelude["return"](Control_Monad_Aff.applicativeAff)(v1);
                  });
              });
          });
      };
  };
  exports["withTransaction"] = withTransaction;
})(PS["Database.AnyDB.Transaction"] = PS["Database.AnyDB.Transaction"] || {});
(function(exports) {
    "use strict";

  // module Node.OS

  exports.hostname = function(){
    var os = require("os");
    return os.hostname();
  };
})(PS["Node.OS"] = PS["Node.OS"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.OS"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  exports["hostname"] = $foreign.hostname;
})(PS["Node.OS"] = PS["Node.OS"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["App.Networking"];
  var App_Config = PS["App.Config"];
  var App_DB = PS["App.DB"];
  var App_Endpoint = PS["App.Endpoint"];
  var App_FS = PS["App.FS"];
  var App_Model_Date = PS["App.Model.Date"];
  var App_Model_Event = PS["App.Model.Event"];
  var App_Model_Photobooth = PS["App.Model.Photobooth"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Eff_Random = PS["Control.Monad.Eff.Random"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var DOM_File_Types = PS["DOM.File.Types"];
  var Data_Array = PS["Data.Array"];
  var Data_Date = PS["Data.Date"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Int_Extended = PS["Data.Int.Extended"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var Data_String = PS["Data.String"];
  var Data_String_Extended = PS["Data.String.Extended"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Database_AnyDB_SqlValue = PS["Database.AnyDB.SqlValue"];
  var Database_AnyDB_Transaction = PS["Database.AnyDB.Transaction"];
  var Network_HTTP_Affjax = PS["Network.HTTP.Affjax"];
  var Node_Buffer = PS["Node.Buffer"];
  var Node_Encoding = PS["Node.Encoding"];
  var Node_FS = PS["Node.FS"];
  var Node_FS_Aff = PS["Node.FS.Aff"];
  var Node_FS_Stats = PS["Node.FS.Stats"];
  var Node_OS = PS["Node.OS"];
  var Node_Path = PS["Node.Path"];
  var Prelude = PS["Prelude"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Endpoint_Client = PS["Endpoint.Client"];
  var Data_Serializable = PS["Data.Serializable"];
  var Data_Generic = PS["Data.Generic"];
  var App_Model_Statistic = PS["App.Model.Statistic"];        
  var WrappedId = (function () {
      function WrappedId(value0) {
          this.value0 = value0;
      };
      WrappedId.create = function (value0) {
          return new WrappedId(value0);
      };
      return WrappedId;
  })();
  var NamedBuffer = (function () {
      function NamedBuffer(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      NamedBuffer.create = function (value0) {
          return function (value1) {
              return new NamedBuffer(value0, value1);
          };
      };
      return NamedBuffer;
  })();
  var LastUpdated = (function () {
      function LastUpdated(value0) {
          this.value0 = value0;
      };
      LastUpdated.create = function (value0) {
          return new LastUpdated(value0);
      };
      return LastUpdated;
  })();
  var unwrap = function (v) {
      return v.value0;
  };
  var saveFile = function (c) {
      return function (i) {
          return function (b) {
              return Database_AnyDB.execute("update files set file = ? where id = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueBuffer)(b), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(i) ])(c);
          };
      };
  };
  var readLastUpdated = function (ms) {
      var $38 = Data_Maybe_Unsafe.fromJust(ms);
      return $38.value0;
  };
  var logfile = "networkinglog.txt";
  var logToFile = function (s) {
      return Prelude[">>="](Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Data_Date.now))(function (n) {
          return Node_FS_Aff.appendTextFile(Node_Encoding.UTF8.value)(logfile)(App_Model_Date.toISOString(n) + (" " + (s + "\n")));
      });
  };
  var isForeignWrappedId = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("id")(obj))(function (v) {
          return Prelude["return"](Data_Either.applicativeEither)(new WrappedId(v));
      });
  });
  var isForeignNamedBuffer = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.foreignIsForeign)(Data_Foreign_Index.indexString)("file")(obj))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("name")(obj))(function (v1) {
              return Prelude["return"](Data_Either.applicativeEither)(NamedBuffer.create(v1)(Data_Foreign.unsafeFromForeign(v)));
          });
      });
  });
  var isForeignLastUpdated = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("lastupdatedon")(obj))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create(new Data_Foreign.TypeMismatch("Well formed date", v)))(Data_Either.Right.create)(Data_Date.fromString(Data_String.replace(" ")("T")(v) + ".000")))(function (v1) {
              return Prelude["return"](Data_Either.applicativeEither)(new LastUpdated(v1));
          });
      });
  });
  var getLastUpdateFiles = Database_AnyDB.Query("select coalesce(max(updatedon), '2010-01-01 00:00:00') as lastupdatedon from files");
  var getLastUpdateEvents = Database_AnyDB.Query("select coalesce(max(updatedon), '2010-01-01 00:00:00') as lastupdatedon from events");
  var getFilesForEvent = function (c) {
      return function (i) {
          return Database_AnyDB.query(isForeignNamedBuffer)("select file, name from files where eventid = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(i) ])(c);
      };
  };
  var getEventsByCname = Database_AnyDB.Query("select * from events where computername = ?");
  var getEmptyFileEntries = Database_AnyDB.Query("select id from files where file is NULL");
  var downloadFolder = function (baseurl) {
      return function (cname) {
          return function (profile) {
              return function (target) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Endpoint_Client.execEndpoint_(Data_Serializable.serializableTuple(Data_Serializable.serializableString)(Data_Serializable.serializableString))(Data_Generic.genericUnit)(Data_Generic.genericArray(Data_Generic.genericString))(baseurl)(App_Endpoint.getProfileFiles)(new Data_Tuple.Tuple(cname, profile))(Prelude.unit))(function (v) {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (filename) {
                          return Control_Monad_Aff.makeAff($foreign._downloadFile(Node_Path.concat([ target, Node_Path.basename(filename) ]))(baseurl + ("/" + filename)));
                      })(v))(function () {
                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                      });
                  });
              };
          };
      };
  };
  var downloadFileById = function (s) {
      return function (i) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Random.randomInt(0)(100000)))(function (v) {
              var tempfile = "./temp" + Prelude.show(Prelude.showInt)(v);
              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff.makeAff($foreign._downloadFile(tempfile)(s + ("/api/files/" + Prelude.show(Prelude.showInt)(i)))))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readFile(tempfile))(function (v1) {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.unlink(tempfile))(function () {
                          return Prelude.pure(Control_Monad_Aff.applicativeAff)(v1);
                      });
                  });
              });
          });
      };
  };
  var main = Control_Monad_Aff.runAff(function (e) {
      var m = Prelude.show(Control_Monad_Eff_Exception.showError)(e) + (Control_Monad_Eff_Exception.message(e) + Data_Maybe.maybe("")(Prelude.id(Prelude.categoryFn))(Control_Monad_Eff_Exception.stack(e)));
      return Control_Apply["*>"](Control_Monad_Eff.applyEff)(Control_Monad_Eff_Console.log(m))(Control_Monad_Aff.runAff(function (v) {
          return Prelude.pure(Control_Monad_Eff.applicativeEff)(Prelude.unit);
      })(function (v) {
          return Prelude.pure(Control_Monad_Eff.applicativeEff)(Prelude.unit);
      })(logToFile(m)));
  })(Prelude["const"](Control_Monad_Eff_Console.log("Everything synced!")))(Database_AnyDB.withConnection(App_DB.networkingConnectionInfo)(function (conn) {
      return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Started networkingscript"))(function () {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.stat(logfile))(function (v) {
              var $51 = v.value0.size > 5.0e7;
              if ($51) {
                  return Node_FS_Aff.unlink(logfile);
              };
              if (!$51) {
                  return Prelude.pure(Control_Monad_Aff.applicativeAff)(Prelude.unit);
              };
              throw new Error("Failed pattern match at App.Networking line 61, column 41 - line 63, column 5: " + [ $51.constructor.name ]);
          }))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(App_Config.readConfigFile))(function (v) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Either.either(function ($103) {
                      return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error(Prelude.show(Data_Foreign.showForeignError)($103)));
                  })(Prelude.pure(Control_Monad_Aff.applicativeAff))(v))(function (v1) {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Node_OS.hostname))(function (v2) {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Initial SQL Done"))(function () {
                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_DB.queryPhotobooth(conn)(v2))(function (v3) {
                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Endpoint_Client.execEndpoint_(Data_Serializable.serializableString)(Data_Generic.genericUnit)(Data_Generic.genericMaybe(App_Model_Photobooth.genericPhotobooth))(v1.value0.webServiceHost)(App_Endpoint.getPhotobooth)(v2)(Prelude.unit))(function (v4) {
                                      return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                                          if (v4 instanceof Data_Maybe.Nothing) {
                                              return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No photobooth instance found for: " + v2));
                                          };
                                          if (v4 instanceof Data_Maybe.Just) {
                                              return Database_AnyDB.execute_(App_DB.upsertPB(v4.value0))(conn);
                                          };
                                          throw new Error("Failed pattern match at App.Networking line 78, column 5 - line 81, column 5: " + [ v4.constructor.name ]);
                                      })())(function () {
                                          return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                                              var $64 = Prelude["/="](Data_Maybe.eqMaybe(App_Model_Photobooth.eqPhotobooth))(v3)(v4);
                                              if ($64) {
                                                  return App_FS.rmdirRecur(App_FS.defaultDir);
                                              };
                                              if (!$64) {
                                                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                                              };
                                              throw new Error("Failed pattern match at App.Networking line 81, column 5 - line 82, column 5: " + [ $64.constructor.name ]);
                                          })())(function () {
                                              return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Synced Photobooth(s)"))(function () {
                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne(isForeignLastUpdated)(getLastUpdateEvents)([  ])(conn))(function (v5) {
                                                      var lastUpdatedEvents = readLastUpdated(v5);
                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Endpoint_Client.execEndpoint_(Data_Serializable.serializableTuple(Data_Serializable.serializableString)(Data_Serializable.serializableDate))(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_Event.genericPartialEvent))(v1.value0.webServiceHost)(App_Endpoint.getNewEvents)(new Data_Tuple.Tuple(v2, lastUpdatedEvents))(Prelude.unit))(function (v6) {
                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (v7) {
                                                              if (v7.value0.id instanceof Data_Maybe.Just) {
                                                                  return App_FS.rmdirRecur(App_FS.mkEventDir(v7.value0.id.value0));
                                                              };
                                                              throw new Error("Failed pattern match at App.Networking line 88, column 15 - line 88, column 74: " + [ v7.constructor.name ]);
                                                          })(v6))(function () {
                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB_Transaction.withTransaction(function (tc) {
                                                                  return Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (pe) {
                                                                      return Database_AnyDB.execute_(App_DB.upsertPartialEvent(pe))(conn);
                                                                  })(v6);
                                                              })(conn))(function () {
                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Synced Events"))(function () {
                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne(isForeignLastUpdated)(getLastUpdateFiles)([  ])(conn))(function (v7) {
                                                                          var lastUpdatedFiles = readLastUpdated(v7);
                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Endpoint_Client.execEndpoint_(Data_Serializable.serializableTuple(Data_Serializable.serializableString)(Data_Serializable.serializableDate))(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_SavedFile.genericSavedFile))(v1.value0.webServiceHost)(App_Endpoint.getNewFiles)(new Data_Tuple.Tuple(v2, lastUpdatedFiles))(Prelude.unit))(function (v8) {
                                                                              var eventIdsWithNewFiles = Prelude["<$>"](Prelude.functorArray)(function (v9) {
                                                                                  return v9.value0.eventId;
                                                                              })(v8);
                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (i) {
                                                                                  return App_FS.rmdirRecur(App_FS.mkEventDir(i));
                                                                              })(eventIdsWithNewFiles))(function () {
                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB_Transaction.withTransaction(function (tc) {
                                                                                      return Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (sf) {
                                                                                          return Database_AnyDB.execute_(App_DB.upsertSavedFile(sf))(conn);
                                                                                      })(v8);
                                                                                  })(conn))(function () {
                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Synced Files"))(function () {
                                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.query(isForeignWrappedId)(getEmptyFileEntries)([  ])(conn))(function (v9) {
                                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(v9)(function (v10) {
                                                                                                  return Prelude[">>="](Control_Monad_Aff.bindAff)(downloadFileById(v1.value0.webServiceHost)(v10.value0))(function (b) {
                                                                                                      return saveFile(conn)(v10.value0)(b);
                                                                                                  });
                                                                                              }))(function () {
                                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Synced File contents"))(function () {
                                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(App_DB.queryAllStatistics(conn)(v2))(function (v10) {
                                                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Endpoint_Client.execEndpoint_(Data_Serializable.serializableUnit)(App_Model_Statistic.genericAllStatistics)(Data_Generic.genericUnit)(v1.value0.webServiceHost)(App_Endpoint.postStatistics)(Prelude.unit)(v10))(function () {
                                                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Synced statistics"))(function () {
                                                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(Node_Path.normalize("clientprofiles")))(function () {
                                                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.exists(App_FS.defaultDir))(function (v11) {
                                                                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                                                                                                                              var $81 = !v11;
                                                                                                                              if ($81) {
                                                                                                                                  if (v4 instanceof Data_Maybe.Nothing) {
                                                                                                                                      return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                                                                                                                                  };
                                                                                                                                  if (v4 instanceof Data_Maybe.Just) {
                                                                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.mkdir(App_FS.defaultDir))(function () {
                                                                                                                                          return downloadFolder(v1.value0.webServiceHost)(v2)(v4.value0.value0.defaultprofile)(App_FS.defaultDir);
                                                                                                                                      });
                                                                                                                                  };
                                                                                                                                  throw new Error("Failed pattern match at App.Networking line 115, column 13 - line 120, column 8: " + [ v4.constructor.name ]);
                                                                                                                              };
                                                                                                                              if (!$81) {
                                                                                                                                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                                                                                                                              };
                                                                                                                              throw new Error("Failed pattern match at App.Networking line 114, column 5 - line 125, column 5: " + [ $81.constructor.name ]);
                                                                                                                          })())(function () {
                                                                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.query(App_Model_Event.partialEventIsForeign)(getEventsByCname)([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(v2) ])(conn))(function (v12) {
                                                                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude["<$>"](Control_Monad_Aff.functorAff)(Data_Array.filter(Prelude.flip(Data_String_Extended.startsWith)("event_")))(Node_FS_Aff.readdir(Node_Path.normalize("clientprofiles"))))(function (v13) {
                                                                                                                                      var eventIdsFromFolders = Prelude["<$>"](Prelude.functorArray)(function ($104) {
                                                                                                                                          return (function (i) {
                                                                                                                                              return Data_Maybe.maybe(-1)(Prelude.id(Prelude.categoryFn))(Data_Int_Extended.safeParseInt(i));
                                                                                                                                          })(Data_String.drop(6)($104));
                                                                                                                                      })(v13);
                                                                                                                                      var missingEvents = Data_Array.filter(function (v14) {
                                                                                                                                          if (v14.value0.id instanceof Data_Maybe.Just) {
                                                                                                                                              return Data_Maybe.isNothing(Data_Array.elemIndex(Prelude.eqInt)(v14.value0.id.value0)(eventIdsFromFolders));
                                                                                                                                          };
                                                                                                                                          throw new Error("Failed pattern match at App.Networking line 128, column 33 - line 128, column 110: " + [ v14.constructor.name ]);
                                                                                                                                      })(v12);
                                                                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Making event folders for: " + Data_String.joinWith(", ")(Prelude["<$>"](Prelude.functorArray)(function (v14) {
                                                                                                                                          return v14.value0.name;
                                                                                                                                      })(missingEvents))))(function () {
                                                                                                                                          return Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(missingEvents)(function (v14) {
                                                                                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No id for PartialEvent")))(Prelude["return"](Control_Monad_Aff.applicativeAff))(v14.value0.id))(function (v15) {
                                                                                                                                                  var target = App_FS.mkEventDir(v15);
                                                                                                                                                  var temptarget = App_FS.mkTempEventDir(v15);
                                                                                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.rmdirRecur(temptarget))(function () {
                                                                                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.mkdir(temptarget))(function () {
                                                                                                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(downloadFolder(v1.value0.webServiceHost)(v2)(v14.value0.profile)(temptarget))(function () {
                                                                                                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(getFilesForEvent(conn)(v15))(function (v16) {
                                                                                                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(v16)(function (v17) {
                                                                                                                                                                      return App_FS.overWriteFile(Node_Path.concat([ temptarget, v17.value0 ]))(v17.value1);
                                                                                                                                                                  }))(function () {
                                                                                                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(temptarget))(function (v17) {
                                                                                                                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.copyDir(temptarget)(target))(function () {
                                                                                                                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.rmdirRecur(temptarget))(function () {
                                                                                                                                                                                  return logToFile("Made folder for event " + Prelude.show(Prelude.showInt)(v15));
                                                                                                                                                                              });
                                                                                                                                                                          });
                                                                                                                                                                      });
                                                                                                                                                                  });
                                                                                                                                                              });
                                                                                                                                                          });
                                                                                                                                                      });
                                                                                                                                                  });
                                                                                                                                              });
                                                                                                                                          });
                                                                                                                                      });
                                                                                                                                  });
                                                                                                                              });
                                                                                                                          });
                                                                                                                      });
                                                                                                                  });
                                                                                                              });
                                                                                                          });
                                                                                                      });
                                                                                                  });
                                                                                              });
                                                                                          });
                                                                                      });
                                                                                  });
                                                                              });
                                                                          });
                                                                      });
                                                                  });
                                                              });
                                                          });
                                                      });
                                                  });
                                              });
                                          });
                                      });
                                  });
                              });
                          });
                      });
                  });
              });
          });
      });
  }));
  var blobToBuffer = Unsafe_Coerce.unsafeCoerce;
  exports["NamedBuffer"] = NamedBuffer;
  exports["WrappedId"] = WrappedId;
  exports["LastUpdated"] = LastUpdated;
  exports["readLastUpdated"] = readLastUpdated;
  exports["saveFile"] = saveFile;
  exports["downloadFileById"] = downloadFileById;
  exports["getFilesForEvent"] = getFilesForEvent;
  exports["blobToBuffer"] = blobToBuffer;
  exports["downloadFolder"] = downloadFolder;
  exports["getEventsByCname"] = getEventsByCname;
  exports["getEmptyFileEntries"] = getEmptyFileEntries;
  exports["getLastUpdateFiles"] = getLastUpdateFiles;
  exports["getLastUpdateEvents"] = getLastUpdateEvents;
  exports["unwrap"] = unwrap;
  exports["main"] = main;
  exports["logToFile"] = logToFile;
  exports["logfile"] = logfile;
  exports["isForeignLastUpdated"] = isForeignLastUpdated;
  exports["isForeignWrappedId"] = isForeignWrappedId;
  exports["isForeignNamedBuffer"] = isForeignNamedBuffer;
  exports["_downloadFile"] = $foreign._downloadFile;
})(PS["App.Networking"] = PS["App.Networking"] || {});
PS["App.Networking"].main();