server.js

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

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

  //bla
  exports.toISOString = function iso8601(d){
    return d.toISOString();
  };
  exports.dateToSqlForComparing = function(d){
    return d.toISOString().replace("T", " ").substr(0, 19);
  };
})(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) {
  /* 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;
    };
  };

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

  //- 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 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 Show = function (show) {
      this.show = show;
  };
  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 pure = function (dict) {
      return dict.pure;
  };
  var $$return = function (dictApplicative) {
      return pure(dictApplicative);
  };
  var otherwise = true;
  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 eq = function (dict) {
      return dict.eq;
  };
  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 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 bottom = function (dict) {
      return dict.bottom;
  };
  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));
                  });
              });
          };
      };
  };
  exports["LT"] = LT;
  exports["GT"] = GT;
  exports["EQ"] = EQ;
  exports["Show"] = Show;
  exports["Bounded"] = Bounded;
  exports["Ord"] = Ord;
  exports["Eq"] = Eq;
  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["bottom"] = bottom;
  exports["top"] = top;
  exports["unsafeCompare"] = unsafeCompare;
  exports["compare"] = compare;
  exports["eq"] = eq;
  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["eqString"] = eqString;
  exports["ordString"] = ordString;
  exports["boundedInt"] = boundedInt;
  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 $$Proxy = (function () {
      function Proxy() {

      };
      Proxy.value = new Proxy();
      return Proxy;
  })();
  exports["Proxy"] = $$Proxy;
})(PS["Type.Proxy"] = PS["Type.Proxy"] || {});
(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) {
  // 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";

  exports.runFn4 = function (fn) {
    return function (a) {
      return function (b) {
        return function (c) {
          return function (d) {
            return fn(a, b, c, d);
          };
        };
      };
    };
  };
})(PS["Data.Function"] = PS["Data.Function"] || {});
(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;
  exports["runFn4"] = $foreign.runFn4;
})(PS["Data.Function"] = PS["Data.Function"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];        
  var Alt = function (__superclass_Prelude$dotFunctor_0, alt) {
      this["__superclass_Prelude.Functor_0"] = __superclass_Prelude$dotFunctor_0;
      this.alt = alt;
  };                                         
  var alt = function (dict) {
      return dict.alt;
  };
  var $less$bar$greater = function (dictAlt) {
      return alt(dictAlt);
  };
  exports["Alt"] = Alt;
  exports["<|>"] = $less$bar$greater;
  exports["alt"] = alt;
})(PS["Control.Alt"] = PS["Control.Alt"] || {});
(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 mempty = function (dict) {
      return dict.mempty;
  };
  exports["Monoid"] = Monoid;
  exports["mempty"] = mempty;
})(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 functorMaybe = new Prelude.Functor(function (v) {
      return function (v1) {
          if (v1 instanceof Just) {
              return new Just(v(v1.value0));
          };
          return Nothing.value;
      };
  });
  var fromMaybe = function (a) {
      return maybe(a)(Prelude.id(Prelude.categoryFn));
  };
  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["fromMaybe"] = fromMaybe;
  exports["maybe"] = maybe;
  exports["functorMaybe"] = functorMaybe;
  exports["applyMaybe"] = applyMaybe;
  exports["applicativeMaybe"] = applicativeMaybe;
  exports["bindMaybe"] = bindMaybe;
})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
(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 $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 foldableMaybe = new Foldable(function (dictMonoid) {
      return function (f) {
          return function (v) {
              if (v instanceof Data_Maybe.Nothing) {
                  return Data_Monoid.mempty(dictMonoid);
              };
              if (v instanceof Data_Maybe.Just) {
                  return f(v.value0);
              };
              throw new Error("Failed pattern match at Data.Foldable line 108, column 3 - line 109, column 3: " + [ f.constructor.name, v.constructor.name ]);
          };
      };
  }, function (v) {
      return function (z) {
          return function (v1) {
              if (v1 instanceof Data_Maybe.Nothing) {
                  return z;
              };
              if (v1 instanceof Data_Maybe.Just) {
                  return v(z)(v1.value0);
              };
              throw new Error("Failed pattern match at Data.Foldable line 106, column 3 - line 107, column 3: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
          };
      };
  }, function (v) {
      return function (z) {
          return function (v1) {
              if (v1 instanceof Data_Maybe.Nothing) {
                  return z;
              };
              if (v1 instanceof Data_Maybe.Just) {
                  return v(v1.value0)(z);
              };
              throw new Error("Failed pattern match at Data.Foldable line 104, column 3 - line 105, column 3: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
          };
      };
  });
  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);
      };
  };
  exports["Foldable"] = Foldable;
  exports["find"] = find;
  exports["for_"] = for_;
  exports["traverse_"] = traverse_;
  exports["foldMapDefaultR"] = foldMapDefaultR;
  exports["foldMap"] = foldMap;
  exports["foldl"] = foldl;
  exports["foldr"] = foldr;
  exports["foldableArray"] = foldableArray;
  exports["foldableMaybe"] = foldableMaybe;
})(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 foldableEither = new Data_Foldable.Foldable(function (dictMonoid) {
      return function (f) {
          return function (v) {
              if (v instanceof Left) {
                  return Data_Monoid.mempty(dictMonoid);
              };
              if (v instanceof Right) {
                  return f(v.value0);
              };
              throw new Error("Failed pattern match at Data.Either line 206, column 3 - line 207, column 3: " + [ f.constructor.name, v.constructor.name ]);
          };
      };
  }, function (v) {
      return function (z) {
          return function (v1) {
              if (v1 instanceof Left) {
                  return z;
              };
              if (v1 instanceof Right) {
                  return v(z)(v1.value0);
              };
              throw new Error("Failed pattern match at Data.Either line 204, column 3 - line 205, column 3: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
          };
      };
  }, function (v) {
      return function (z) {
          return function (v1) {
              if (v1 instanceof Left) {
                  return z;
              };
              if (v1 instanceof Right) {
                  return v(v1.value0)(z);
              };
              throw new Error("Failed pattern match at Data.Either line 202, column 3 - line 203, column 3: " + [ v.constructor.name, z.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);
  var altEither = new Control_Alt.Alt(function () {
      return functorEither;
  }, function (v) {
      return function (v1) {
          if (v instanceof Left) {
              return v1;
          };
          return v;
      };
  });
  exports["Left"] = Left;
  exports["Right"] = Right;
  exports["either"] = either;
  exports["functorEither"] = functorEither;
  exports["applyEither"] = applyEither;
  exports["applicativeEither"] = applicativeEither;
  exports["altEither"] = altEither;
  exports["bindEither"] = bindEither;
  exports["foldableEither"] = foldableEither;
})(PS["Data.Either"] = PS["Data.Either"] || {});
(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 fst = function (v) {
      return v.value0;
  };
  exports["Tuple"] = Tuple;
  exports["snd"] = snd;
  exports["fst"] = fst;
})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.replicate = function (n) {
    return function (v) {
      if (n < 1) return [];
      var r = new Array(n);
      for (var i = 0; i < n; i++) r[i] = v;
      return r;
    };
  };

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

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

  //------------------------------------------------------------------------------
  // Extending arrays ------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.cons = function (e) {
    return function (l) {
      return [e].concat(l);
    };
  };

  //------------------------------------------------------------------------------
  // Non-indexed reads -----------------------------------------------------------
  //------------------------------------------------------------------------------

  exports["uncons'"] = function (empty) {
    return function (next) {
      return function (xs) {
        return xs.length === 0 ? empty({}) : next(xs[0])(xs.slice(1));
      };
    };
  };

  //------------------------------------------------------------------------------
  // 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.concat = function (xss) {
    var result = [];
    for (var i = 0, l = xss.length; i < l; i++) {
      var xs = xss[i];
      for (var j = 0, m = xs.length; j < m; j++) {
        result.push(xs[j]);
      }
    }
    return result;
  };

  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) {
  /* 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) {
  // 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 $colon = $foreign.cons;   
  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 zip = $foreign.zipWith(Data_Tuple.Tuple.create);
  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 filterM = function (dictMonad) {
      return function (p) {
          return $foreign["uncons'"](function (v) {
              return Prelude.pure(dictMonad["__superclass_Prelude.Applicative_0"]())([  ]);
          })(function (x) {
              return function (xs) {
                  return Prelude.bind(dictMonad["__superclass_Prelude.Bind_1"]())(p(x))(function (v) {
                      return Prelude.bind(dictMonad["__superclass_Prelude.Bind_1"]())(filterM(dictMonad)(p)(xs))(function (v1) {
                          return Prelude["return"](dictMonad["__superclass_Prelude.Applicative_0"]())((function () {
                              if (v) {
                                  return $colon(x)(v1);
                              };
                              if (!v) {
                                  return v1;
                              };
                              throw new Error("Failed pattern match at Data.Array line 390, column 5 - line 396, column 1: " + [ v.constructor.name ]);
                          })());
                      });
                  });
              };
          });
      };
  };
  exports["zip"] = zip;
  exports["zipWithA"] = zipWithA;
  exports["sortBy"] = sortBy;
  exports["sort"] = sort;
  exports["filterM"] = filterM;
  exports["index"] = index;
  exports["!!"] = $bang$bang;
  exports["zipWith"] = $foreign.zipWith;
  exports["filter"] = $foreign.filter;
  exports["length"] = $foreign.length;
  exports["replicate"] = $foreign.replicate;
})(PS["Data.Array"] = PS["Data.Array"] || {});
(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.split = function (sep) {
    return function (s) {
      return s.split(sep);
    };
  };

  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["split"] = $foreign.split;
})(PS["Data.String"] = PS["Data.String"] || {});
(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 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 ]);
      });
  };
  var genericTuple = function (dictGeneric) {
      return function (dictGeneric1) {
          return new Generic(function (v) {
              if (v instanceof SProd && (v.value0 === "Data.Tuple.Tuple" && v.value1.length === 2)) {
                  return Prelude["<*>"](Data_Maybe.applyMaybe)(Prelude["<$>"](Data_Maybe.functorMaybe)(Data_Tuple.Tuple.create)(fromSpine(dictGeneric)(v.value1[0](Prelude.unit))))(fromSpine(dictGeneric1)(v.value1[1](Prelude.unit)));
              };
              return Data_Maybe.Nothing.value;
          }, function (x) {
              var sndProxy = function (v) {
                  return anyProxy;
              };
              var fstProxy = function (v) {
                  return anyProxy;
              };
              return new SigProd("Data.Tuple.Tuple", [ {
                  sigConstructor: "Data.Tuple.Tuple", 
                  sigValues: [ function (u) {
                      return toSignature(dictGeneric)(fstProxy(x));
                  }, function (u) {
                      return toSignature(dictGeneric1)(sndProxy(x));
                  } ]
              } ]);
          }, function (v) {
              return new SProd("Data.Tuple.Tuple", [ function (u) {
                  return toSpine(dictGeneric)(v.value0);
              }, function (u) {
                  return toSpine(dictGeneric1)(v.value1);
              } ]);
          });
      };
  };
  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["fromSpine"] = fromSpine;
  exports["toSignature"] = toSignature;
  exports["toSpine"] = toSpine;
  exports["genericNumber"] = genericNumber;
  exports["genericInt"] = genericInt;
  exports["genericString"] = genericString;
  exports["genericArray"] = genericArray;
  exports["genericTuple"] = genericTuple;
  exports["genericMaybe"] = genericMaybe;
  exports["genericUnit"] = genericUnit;
})(PS["Data.Generic"] = PS["Data.Generic"] || {});
(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.decodeURI = decodeURI;
})(PS["Global"] = PS["Global"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Global"];
  exports["decodeURI"] = $foreign["decodeURI"];
  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 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["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["dateToSqlForComparing"] = $foreign.dateToSqlForComparing;
  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";

  // 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.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";

  exports.ceil = Math.ceil;
})(PS["Math"] = PS["Math"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Math"];
  exports["ceil"] = $foreign.ceil;
})(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 ceil = function ($3) {
      return unsafeClamp($$Math.ceil($3));
  };
  exports["ceil"] = ceil;
  exports["fromNumber"] = fromNumber;
  exports["toNumber"] = $foreign.toNumber;
})(PS["Data.Int"] = PS["Data.Int"] || {});
(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";

  // 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 numberIsForeign = new IsForeign(Data_Foreign.readNumber);
  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["numberIsForeign"] = numberIsForeign;
  exports["intIsForeign"] = intIsForeign;
})(PS["Data.Foreign.Class"] = PS["Data.Foreign.Class"] || {});
(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) {
  /* global exports */
  "use strict";

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

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

  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"];
  exports["throwException"] = $foreign.throwException;
  exports["message"] = $foreign.message;
  exports["error"] = $foreign.error;
})(PS["Control.Monad.Eff.Exception"] = PS["Control.Monad.Eff.Exception"] || {});
(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;
  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 queryOne_ = function (dictIsForeign) {
      return function (v) {
          return function (con) {
              return Prelude.bind(Control_Monad_Aff.bindAff)($foreign.runQuery_(v)(con))(function (v1) {
                  return Data_Maybe.maybe(Prelude.pure(Control_Monad_Aff.applicativeAff)(Data_Maybe.Nothing.value))(Data_Either.either(liftError)(function ($60) {
                      return Prelude.pure(Control_Monad_Aff.applicativeAff)(Data_Maybe.Just.create($60));
                  }))(Prelude["<$>"](Data_Maybe.functorMaybe)(Data_Foreign_Class.read(dictIsForeign))(Data_Array["!!"](v1)(0)));
              });
          };
      };
  };
  var query_ = function (dictIsForeign) {
      return function (v) {
          return function (con) {
              return Prelude.bind(Control_Monad_Aff.bindAff)($foreign.runQuery_(v)(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 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["queryOne"] = queryOne;
  exports["query_"] = query_;
  exports["query"] = query;
  exports["execute_"] = execute_;
  exports["execute"] = execute;
  exports["connect"] = connect;
  exports["mkConnectionString"] = mkConnectionString;
})(PS["Database.AnyDB"] = PS["Database.AnyDB"] || {});
(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;
  };

  // jshint maxparams: 4
  exports._lookup = function (no, yes, k, m) {
    return k in m ? yes(m[k]) : no;
  };

  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 lookup = Data_Function.runFn4($foreign._lookup)(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);
  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["lookup"] = lookup;
  exports["insert"] = insert;
  exports["keys"] = $foreign.keys;
  exports["empty"] = $foreign.empty;
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(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 update = function (v) {
      return function (i) {
          return function (fs) {
              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));
                  var fields = Data_Array.zip(sortedKeys)(sortedValues);
                  return Database_AnyDB.Query("UPDATE " + (v.name + (" SET " + (Data_String.joinWith(", ")(Prelude.map(Prelude.functorArray)(function (v1) {
                      return v1.value0 + (" = '" + (v1.value1 + "'"));
                  })(fields)) + (" WHERE id = " + (Prelude.show(Prelude.showInt)(i) + str))))));
              };
          };
      };
  }; 
  var selectStar = function (v) {
      return function (s) {
          return Database_AnyDB.Query("SELECT * FROM " + (v.name + (" " + s)));
      };
  };
  var selectStarId = function (t) {
      return function (i) {
          return selectStar(t)("WHERE id = " + Prelude.show(Prelude.showInt)(i));
      };
  };
  var selectLastInserted = function (t) {
      return selectStar(t)("WHERE id = last_insert_rowid()");
  };
  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["selectLastInserted"] = selectLastInserted;
  exports["selectStarId"] = selectStarId;
  exports["selectStar"] = selectStar;
  exports["update"] = update;
  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 savedFileIsForeign = 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.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("name")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("eventid")(obj))(function (v2) {
                  return Prelude["return"](Data_Either.applicativeEither)(new SavedFile({
                      id: v, 
                      name: v1, 
                      eventId: v2
                  }));
              });
          });
      });
  });
  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;
  exports["savedFileIsForeign"] = savedFileIsForeign;
})(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 Event = (function () {
      function Event(value0) {
          this.value0 = value0;
      };
      Event.create = function (value0) {
          return new Event(value0);
      };
      return Event;
  })();
  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 mkEvent = function (v) {
      return function (im) {
          return new Event({
              id: v.value0.id, 
              computername: v.value0.computername, 
              name: v.value0.name, 
              datefrom: v.value0.datefrom, 
              dateuntil: v.value0.dateuntil, 
              profile: v.value0.profile, 
              files: im
          });
      };
  };
  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 genericEvent = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.Event.Event" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Event.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 7) {
                  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)(Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (computername1) {
                      return function (datefrom1) {
                          return function (dateuntil1) {
                              return function (files1) {
                                  return function (id1) {
                                      return function (name1) {
                                          return function (profile1) {
                                              return {
                                                  computername: computername1, 
                                                  datefrom: datefrom1, 
                                                  dateuntil: dateuntil1, 
                                                  files: files1, 
                                                  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.genericArray(App_Model_SavedFile.genericSavedFile))((r.value0[3]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericMaybe(Data_Generic.genericInt))((r.value0[4]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[5]).recValue(Prelude.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)((r.value0[6]).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.Event", [ {
          sigConstructor: "App.Model.Event.Event", 
          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: "files", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericArray(App_Model_SavedFile.genericSavedFile))(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.Event", [ 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: "files", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericArray(App_Model_SavedFile.genericSavedFile))(v.value0.files);
              }
          }, {
              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["Event"] = Event;
  exports["eventsTable"] = eventsTable;
  exports["mkEvent"] = mkEvent;
  exports["genericEvent"] = genericEvent;
  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);
              }
          } ]);
      } ]);
  });
  exports["Photobooth"] = Photobooth;
  exports["photoboothsTable"] = photoboothsTable;
  exports["genericPhotobooth"] = genericPhotobooth;
  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_Class = PS["Data.Foreign.Class"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Date = PS["Data.Date"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];        
  var Session = (function () {
      function Session(value0) {
          this.value0 = value0;
      };
      Session.create = function (value0) {
          return new Session(value0);
      };
      return Session;
  })();
  var sessionsTable = {
      name: "SESSIONS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("id")(new SQL.ColumnDef(SQL.Integer.value, [ SQL.PrimaryKey.value ])), Data_Tuple.Tuple.create("userId")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("createdOn")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  var sessionIsForeign = 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.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("userId")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("createdOn")(obj))(function (v2) {
                  return Prelude.bind(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create(new Data_Foreign.TypeMismatch("ISO 8601 Date", v2)))(Data_Either.Right.create)(Data_Date.fromStringStrict(v2)))(function (v3) {
                      return Prelude["return"](Data_Either.applicativeEither)(new Session({
                          id: v, 
                          userId: v1, 
                          createdOn: v3
                      }));
                  });
              });
          });
      });
  });
  var genericSession = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.Session.Session" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Session.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 (createdOn1) {
                      return function (id1) {
                          return function (userId1) {
                              return {
                                  createdOn: createdOn1, 
                                  id: id1, 
                                  userId: userId1
                              };
                          };
                      };
                  }))(Data_Generic.fromSpine(Data_Date.genericDate)((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)));
              };
              return Data_Maybe.Nothing.value;
          })(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.Session.Session", [ {
          sigConstructor: "App.Model.Session.Session", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "createdOn", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Date.genericDate)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "id", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              }, {
                  recLabel: "userId", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.Session.Session", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "createdOn", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Date.genericDate)(v.value0.createdOn);
              }
          }, {
              recLabel: "id", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.id);
              }
          }, {
              recLabel: "userId", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0.userId);
              }
          } ]);
      } ]);
  });
  exports["Session"] = Session;
  exports["sessionsTable"] = sessionsTable;
  exports["genericSession"] = genericSession;
  exports["sessionIsForeign"] = sessionIsForeign;
})(PS["App.Model.Session"] = PS["App.Model.Session"] || {});
(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 monthlyStatisticsTable = {
      name: "MONTHLYSTATISTICS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("month")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("pictures")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("prints")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  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 eventStatisticsTable = {
      name: "EVENTSTATISTICS", 
      columns: App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("computername")(new SQL.ColumnDef(SQL.Char.value, [  ])), Data_Tuple.Tuple.create("eventid")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("pictures")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("prints")(new SQL.ColumnDef(SQL.Integer.value, [  ])), Data_Tuple.Tuple.create("updatedon")(new SQL.ColumnDef((SQL["Date"]).value, [  ])) ])
  };
  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["monthlyStatisticsTable"] = monthlyStatisticsTable;
  exports["eventStatisticsTable"] = eventStatisticsTable;
  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 SQL = PS["SQL"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Tuple = PS["Data.Tuple"];
  var Prelude = PS["Prelude"];
  var Data_Either = PS["Data.Either"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];        

  /**
 * ----------------------------------------
 */  
  var User = (function () {
      function User(value0) {
          this.value0 = value0;
      };
      User.create = function (value0) {
          return new User(value0);
      };
      return User;
  })();
  var userIsForeign = 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.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("name")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("password")(obj))(function (v2) {
                  return Prelude["return"](Data_Either.applicativeEither)(new User({
                      id: v, 
                      name: v1, 
                      password: v2
                  }));
              });
          });
      });
  });
  exports["User"] = User;
  exports["userIsForeign"] = userIsForeign;
})(PS["App.Model.User"] = PS["App.Model.User"] || {});
(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) {
    "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) {
    "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 MyFile = function (x) {
      return x;
  };
  var upsertMonthlyStatistic = function (v) {
      return SQL.insert(App_Model_Statistic.monthlyStatisticsTable)(App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("month")(Prelude.show(Prelude.showInt)(v.value0.month)), Data_Tuple.Tuple.create("computername")(v.value0.computername), Data_Tuple.Tuple.create("pictures")(Prelude.show(Prelude.showInt)(v.value0.pictures)), Data_Tuple.Tuple.create("prints")(Prelude.show(Prelude.showInt)(v.value0.prints)) ]))(true)("");
  };
  var upsertEventStatistic = function (v) {
      return SQL.insert(App_Model_Statistic.eventStatisticsTable)(App_Model_StrMap.fromArray([ Data_Tuple.Tuple.create("eventId")(Prelude.show(Prelude.showInt)(v.value0.eventId)), Data_Tuple.Tuple.create("computername")(v.value0.computername), Data_Tuple.Tuple.create("pictures")(Prelude.show(Prelude.showInt)(v.value0.pictures)), Data_Tuple.Tuple.create("prints")(Prelude.show(Prelude.showInt)(v.value0.prints)) ]))(true)("");
  };
  var updatePB = function (v) {
      return function (v1) {
          if (v1.value0.id instanceof Data_Maybe.Nothing) {
              return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("updatePhotobooth impossible without id!"));
          };
          if (v1.value0.id instanceof Data_Maybe.Just) {
              var query = SQL.update(App_Model_Photobooth.photoboothsTable)(v1.value0.id.value0)(App_Model_StrMap.fromArray([ new Data_Tuple.Tuple("alias", v1.value0.alias), new Data_Tuple.Tuple("defaultprofile", v1.value0.defaultprofile) ]))("");
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(query)(v))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne_(App_Model_Photobooth.photoboothIsForeign)(SQL.selectStarId(App_Model_Photobooth.photoboothsTable)(v1.value0.id.value0))(v))(function (v2) {
                      return Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Failed to update Photobooth")))(Prelude["return"](Control_Monad_Aff.applicativeAff))(v2);
                  });
              });
          };
          throw new Error("Failed pattern match at App.DB line 214, column 1 - line 216, column 1: " + [ v.constructor.name, v1.constructor.name ]);
      };
  };
  var unpack = function (v) {
      return v;
  };
  var tryLogin = function (conn) {
      return function (username) {
          return function (password) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne(App_Model_User.userIsForeign)("select * from users WHERE name = ? AND password = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(username), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(password) ])(conn))(function (v) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Username or PW not found")))(Prelude["return"](Control_Monad_Aff.applicativeAff))(v))(function (v1) {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Data_Date.now))(function (v2) {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute("insert into SESSIONS (userId, createdOn) VALUES (?, ?)")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(v1.value0.id), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(App_Model_Date.toISOString(v2)) ])(conn))(function () {
                              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne_(App_Model_Session.sessionIsForeign)(SQL.selectLastInserted(App_Model_Session.sessionsTable))(conn))(function (v3) {
                                  return Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Failed to make new session")))(Prelude["return"](Control_Monad_Aff.applicativeAff))(v3);
                              });
                          });
                      });
                  });
              });
          };
      };
  };
  var selectFilesForEvents = function (v) {
      return function (v1) {
          if (v.length === 0) {
              return Prelude["return"](Control_Monad_Aff.applicativeAff)([  ]);
          };
          var qs = Data_String.joinWith(", ")(Data_Array.replicate(Data_Array.length(v))("?"));
          return Database_AnyDB.query(App_Model_SavedFile.savedFileIsForeign)(SQL.selectStar(App_Model_SavedFile.savedFileTable)("WHERE eventid in (" + (qs + ")")))(Prelude.map(Prelude.functorArray)(Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt))(v))(v1);
      };
  };
  var selectFilesForEvent = function (i) {
      return function (conn) {
          return Database_AnyDB.query(App_Model_SavedFile.savedFileIsForeign)(SQL.selectStar(App_Model_SavedFile.savedFileTable)("WHERE eventid = ?"))([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(i) ])(conn);
      };
  };
  var updateEvent = function (v) {
      return function (v1) {
          if (v1.value0.id instanceof Data_Maybe.Nothing) {
              return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("updateEvent impossible without id"));
          };
          if (v1.value0.id instanceof Data_Maybe.Just) {
              var query = SQL.update(App_Model_Event.eventsTable)(v1.value0.id.value0)(App_Model_StrMap.fromArray([ new Data_Tuple.Tuple("computername", v1.value0.computername), new Data_Tuple.Tuple("name", v1.value0.name), Data_Tuple.Tuple.create("datefrom")(App_Model_Date.toISOString(v1.value0.datefrom)), Data_Tuple.Tuple.create("dateuntil")(App_Model_Date.toISOString(v1.value0.dateuntil)), new Data_Tuple.Tuple("profile", v1.value0.profile) ]))("");
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(query)(v))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne_(App_Model_Event.partialEventIsForeign)(SQL.selectStarId(App_Model_Event.eventsTable)(v1.value0.id.value0))(v))(function (v2) {
                      if (v2 instanceof Data_Maybe.Nothing) {
                          return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Failed to update Event"));
                      };
                      if (v2 instanceof Data_Maybe.Just && v2.value0.value0.id instanceof Data_Maybe.Nothing) {
                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(App_Model_Event.mkEvent(v2.value0)([  ]));
                      };
                      if (v2 instanceof Data_Maybe.Just && v2.value0.value0.id instanceof Data_Maybe.Just) {
                          return Prelude[">>="](Control_Monad_Aff.bindAff)(selectFilesForEvent(v2.value0.value0.id.value0)(v))(function (ims) {
                              return Prelude["return"](Control_Monad_Aff.applicativeAff)(App_Model_Event.mkEvent(v2.value0)(ims));
                          });
                      };
                      throw new Error("Failed pattern match at App.DB line 242, column 7 - line 247, column 1: " + [ v2.constructor.name ]);
                  });
              });
          };
          throw new Error("Failed pattern match at App.DB line 230, column 1 - line 232, column 1: " + [ v.constructor.name, v1.constructor.name ]);
      };
  };
  var saveFileToDb = function (conn) {
      return function (v) {
          return function (buffer) {
              var query = Database_AnyDB.Query("INSERT INTO " + (App_Model_SavedFile.savedFileTable.name + " (name, eventid, File) VALUES (?, ?, ?)"));
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute(query)([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(v.value1), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(v.value0), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueBuffer)(buffer) ])(conn))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne_(App_Model_SavedFile.savedFileIsForeign)(SQL.selectLastInserted(App_Model_SavedFile.savedFileTable))(conn))(function (v1) {
                      return Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Failed to save File")))(Prelude["return"](Control_Monad_Aff.applicativeAff))(v1);
                  });
              });
          };
      };
  };
  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 queryNewFiles = function (conn) {
      return function (v) {
          var q = Database_AnyDB.Query("Select f.* from FILES f " + ("Join Events e on e.id = f.eventid " + ("where e.computername = ? " + "and f.updatedon > ? ")));
          return Database_AnyDB.query(App_Model_SavedFile.savedFileIsForeign)(q)([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(v.value0), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(App_Model_Date.dateToSqlForComparing(v.value1)) ])(conn);
      };
  };
  var queryNewEvents = function (conn) {
      return function (v) {
          var q = Database_AnyDB.Query("Select * from EVENTS " + ("where computername = ? " + "and updatedon > ?"));
          return Database_AnyDB.query(App_Model_Event.partialEventIsForeign)(q)([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(v.value0), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(App_Model_Date.dateToSqlForComparing(v.value1)) ])(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 mainConnectionInfo = new Database_AnyDB.Sqlite3({
      filename: "klikhutdb", 
      memory: false
  });
  var insertPB = function (v) {
      return SQL.insert(App_Model_Photobooth.photoboothsTable)(App_Model_StrMap.fromArray([ new Data_Tuple.Tuple("computername", v.value0.computername), new Data_Tuple.Tuple("alias", v.value0.alias), new Data_Tuple.Tuple("defaultprofile", v.value0.defaultprofile) ]))(false)("");
  };
  var newPB = function (conn) {
      return function (pb) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(insertPB(pb))(conn))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne_(App_Model_Photobooth.photoboothIsForeign)(SQL.selectLastInserted(App_Model_Photobooth.photoboothsTable))(conn))(function (v) {
                  return Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Failed to create Photobooth")))(Prelude["return"](Control_Monad_Aff.applicativeAff))(v);
              });
          });
      };
  };
  var insertEvent = function (v) {
      return SQL.insert(App_Model_Event.eventsTable)(App_Model_StrMap.fromArray([ 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) ]))(false)("");
  };
  var newEvent = function (conn) {
      return function (ev) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.execute_(insertEvent(ev))(conn))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne_(App_Model_Event.partialEventIsForeign)(SQL.selectLastInserted(App_Model_Event.eventsTable))(conn))(function (v) {
                  if (v instanceof Data_Maybe.Nothing) {
                      return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Failed to create Event"));
                  };
                  if (v instanceof Data_Maybe.Just && v.value0.value0.id instanceof Data_Maybe.Nothing) {
                      return Prelude["return"](Control_Monad_Aff.applicativeAff)(App_Model_Event.mkEvent(v.value0)([  ]));
                  };
                  if (v instanceof Data_Maybe.Just && v.value0.value0.id instanceof Data_Maybe.Just) {
                      return Prelude[">>="](Control_Monad_Aff.bindAff)(selectFilesForEvent(v.value0.value0.id.value0)(conn))(function (ims) {
                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(App_Model_Event.mkEvent(v.value0)(ims));
                      });
                  };
                  throw new Error("Failed pattern match at App.DB line 183, column 5 - line 188, column 1: " + [ v.constructor.name ]);
              });
          });
      };
  };
  var foreignMyFile = 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["return"](Data_Either.applicativeEither)(MyFile(Data_Foreign.unsafeFromForeign(v)));
      });
  });
  var getFileById = function (conn) {
      return function (id) {
          return Prelude[">>="](Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne(foreignMyFile)("select file from files where id = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(id) ])(conn))(function (mf) {
              return Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No file found")))(function ($137) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(unpack($137));
              })(mf);
          });
      };
  };
  var deletePB = function (c) {
      return function (cname) {
          return Control_Apply["*>"](Control_Monad_Aff.applyAff)(Control_Apply["*>"](Control_Monad_Aff.applyAff)(Control_Apply["*>"](Control_Monad_Aff.applyAff)(Database_AnyDB.execute("DELETE FROM photobooths where computername = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(c))(Database_AnyDB.execute("DELETE FROM events where computername = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(c)))(Database_AnyDB.execute("DELETE FROM eventstatistics where computername = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(c)))(Database_AnyDB.execute("DELETE FROM monthlystatistics where computername = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(c));
      };
  };
  var allPhotobooths = function (conn) {
      return Database_AnyDB.query_(App_Model_Photobooth.photoboothIsForeign)(SQL.selectStar(App_Model_Photobooth.photoboothsTable)(""))(conn);
  };
  var addStatistics = function (c) {
      return function (v) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (s) {
              return Database_AnyDB.execute_(upsertMonthlyStatistic(s))(c);
          })(v.value0.monthlyStatistics))(function (v1) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (s) {
                  return Database_AnyDB.execute_(upsertEventStatistic(s))(c);
              })(v.value0.eventStatistics))(function (v2) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
              });
          });
      };
  };
  var addFilesToEvents = function (conn) {
      return function (partialEvs) {
          var ids = Prelude["<$>"](Prelude.functorArray)(function (v) {
              return Data_Maybe.fromMaybe(-1)(v.value0.id);
          })(partialEvs);
          return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
              var $129 = Data_Array.length(ids) > -1;
              if ($129) {
                  return selectFilesForEvents(ids)(conn);
              };
              if (!$129) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)([  ]);
              };
              throw new Error("Failed pattern match at App.DB line 153, column 12 - line 154, column 3: " + [ $129.constructor.name ]);
          })())(function (v) {
              var createEvent = function (v1) {
                  return App_Model_Event.mkEvent(v1)(Data_Array.filter(function (v2) {
                      return v2.value0.eventId === Data_Maybe.fromMaybe(0)(v1.value0.id);
                  })(v));
              };
              return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude["<$>"](Prelude.functorArray)(createEvent)(partialEvs));
          });
      };
  };
  var queryEvents = function (conn) {
      return function (cname) {
          return Prelude[">>="](Control_Monad_Aff.bindAff)(Database_AnyDB.query(App_Model_Event.partialEventIsForeign)("Select * from EVENTS WHERE computername = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname) ])(conn))(addFilesToEvents(conn));
      };
  };
  var queryEventsByIds = function (conn) {
      return function (ids) {
          var is = Data_String.joinWith(",")(Prelude["<$>"](Prelude.functorArray)(Prelude.show(Prelude.showInt))(ids));
          var q = "Select * from EVENTS WHERE id in (" + (is + ")");
          return Prelude[">>="](Control_Monad_Aff.bindAff)(Database_AnyDB.query_(App_Model_Event.partialEventIsForeign)(q)(conn))(addFilesToEvents(conn));
      };
  };
  var queryEventsPaged = function (conn) {
      return function (i) {
          return function (cname) {
              var params = [ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(cname), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(20), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(20 * i | 0) ];
              return Prelude[">>="](Control_Monad_Aff.bindAff)(Database_AnyDB.query(App_Model_Event.partialEventIsForeign)("Select * from EVENTS WHERE computername = ? order by id desc limit ? offset ?")(params)(conn))(addFilesToEvents(conn));
          };
      };
  };
  exports["MyFile"] = MyFile;
  exports["tryLogin"] = tryLogin;
  exports["getFileById"] = getFileById;
  exports["unpack"] = unpack;
  exports["addStatistics"] = addStatistics;
  exports["queryNewFiles"] = queryNewFiles;
  exports["queryPhotobooth"] = queryPhotobooth;
  exports["queryNewEvents"] = queryNewEvents;
  exports["queryAllStatistics"] = queryAllStatistics;
  exports["upsertMonthlyStatistic"] = upsertMonthlyStatistic;
  exports["upsertEventStatistic"] = upsertEventStatistic;
  exports["selectFilesForEvents"] = selectFilesForEvents;
  exports["selectFilesForEvent"] = selectFilesForEvent;
  exports["saveFileToDb"] = saveFileToDb;
  exports["updateEvent"] = updateEvent;
  exports["deletePB"] = deletePB;
  exports["updatePB"] = updatePB;
  exports["insertEvent"] = insertEvent;
  exports["newEvent"] = newEvent;
  exports["insertPB"] = insertPB;
  exports["newPB"] = newPB;
  exports["addFilesToEvents"] = addFilesToEvents;
  exports["queryEventsByIds"] = queryEventsByIds;
  exports["queryEventsPaged"] = queryEventsPaged;
  exports["queryEvents"] = queryEvents;
  exports["allPhotobooths"] = allPhotobooths;
  exports["mainConnectionInfo"] = mainConnectionInfo;
  exports["foreignMyFile"] = foreignMyFile;
})(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 GET = (function () {
      function GET() {

      };
      GET.value = new GET();
      return GET;
  })();
  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;
  })();
  exports["GET"] = GET;
  exports["POST"] = POST;
  exports["PUT"] = PUT;
  exports["DELETE"] = DELETE;
})(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);
              };
          };
      };
  };
  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) {
    "use strict";
  exports.parseIntImpl = function parseIntImpl(just){
    return function(nothing){
      return function(a){
        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt
        return (/^(\-|\+)?([0-9]+)$/.test(a)) ? just(Number(a)) : nothing;
      }
    }
  }
  exports.toString = function toString(a){
    return a.toString();
  }
  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 $$parseInt = $foreign.parseIntImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var serializableInt = new Serializable(function (a) {
      return Data_Maybe.maybe(Data_Either.Left.create(Control_Monad_Eff_Exception.error("Unable to deserialize " + (a + " to Int"))))(Data_Either.Right.create)($$parseInt(a));
  }, $foreign.toString);
  var deserialize = function (dict) {
      return dict.deserialize;
  };
  var serializableArray = function (dictSerializable) {
      return new Serializable(function (s) {
          return Data_Traversable.traverse(Data_Traversable.traversableArray)(Data_Either.applicativeEither)(deserialize(dictSerializable))(Data_String.split(";")(s));
      }, function (arr) {
          return Data_String.joinWith(";")(Prelude["<$>"](Prelude.functorArray)(serialize(dictSerializable))(arr));
      });
  };
  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["serializableInt"] = serializableInt;
  exports["serializableString"] = serializableString;
  exports["serializableDate"] = serializableDate;
  exports["serializableTuple"] = serializableTuple;
  exports["serializableUnit"] = serializableUnit;
  exports["serializableArray"] = serializableArray;
})(PS["Data.Serializable"] = PS["Data.Serializable"] || {});
(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 FileUploadEndpoint = (function () {
      function FileUploadEndpoint(value0) {
          this.value0 = value0;
      };
      FileUploadEndpoint.create = function (value0) {
          return new FileUploadEndpoint(value0);
      };
      return FileUploadEndpoint;
  })();
  var Endpoint = (function () {
      function Endpoint(value0) {
          this.value0 = value0;
      };
      Endpoint.create = function (value0) {
          return new Endpoint(value0);
      };
      return Endpoint;
  })();
  exports["FileUploadEndpoint"] = FileUploadEndpoint;
  exports["Endpoint"] = Endpoint;
})(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 putPhotobooths = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.PUT.value, 
      url: "/api/photobooths"
  });
  var putEvents = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.PUT.value, 
      url: "/api/events"
  });
  var postStatistics = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.POST.value, 
      url: "/api/statistics"
  });
  var postPhotobooths = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.POST.value, 
      url: "/api/photobooths"
  });
  var postEvents = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.POST.value, 
      url: "/api/events"
  });
  var login = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.POST.value, 
      url: "/api/login"
  });
  var getStatistics = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/statistics/cname"
  });
  var getProfiles = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/profiles/all"
  });
  var getProfileFiles = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/profiles/files"
  });
  var getPhotobooths = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/photobooths/all"
  });
  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"
  });
  var getEventsPaged = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/events/paged"
  });
  var getEventsByIds = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/events/byids"
  });
  var getEvents = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.GET.value, 
      url: "/api/events/cname"
  });
  var deletePhotobooth = new Endpoint_Client.Endpoint({
      method: Data_HTTP_Method.DELETE.value, 
      url: "/api/photobooths"
  });
  var attachFile = new Endpoint_Client.FileUploadEndpoint({
      url: "/api/attachfiletoevent"
  });
  exports["login"] = login;
  exports["getProfileFiles"] = getProfileFiles;
  exports["getProfiles"] = getProfiles;
  exports["postStatistics"] = postStatistics;
  exports["getStatistics"] = getStatistics;
  exports["getNewFiles"] = getNewFiles;
  exports["getNewEvents"] = getNewEvents;
  exports["attachFile"] = attachFile;
  exports["getEventsByIds"] = getEventsByIds;
  exports["getEventsPaged"] = getEventsPaged;
  exports["putEvents"] = putEvents;
  exports["postEvents"] = postEvents;
  exports["getEvents"] = getEvents;
  exports["deletePhotobooth"] = deletePhotobooth;
  exports["putPhotobooths"] = putPhotobooths;
  exports["postPhotobooths"] = postPhotobooths;
  exports["getPhotobooths"] = getPhotobooths;
  exports["getPhotobooth"] = getPhotobooth;
})(PS["App.Endpoint"] = PS["App.Endpoint"] || {});
(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) {
    "use strict";
  var path =require("path"); 

  exports.normalize = path.normalize;

  exports.concat = function (segments) {
    return path.join.apply(this, segments);
  };
})(PS["Node.Path"] = PS["Node.Path"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.Path"];
  exports["concat"] = $foreign.concat;
  exports["normalize"] = $foreign.normalize;
})(PS["Node.Path"] = PS["Node.Path"] || {});
(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) {
  /* 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 readdir = function (file) {
      return function (cb) {
          return Node_FS_Internal.mkEff(function (v) {
              return fs.readdir(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));
              }));
          });
      };
  };
  exports["readdir"] = readdir;
  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 stat = toAff1(Node_FS_Async.stat);        
  var readdir = toAff1(Node_FS_Async.readdir);
  exports["readdir"] = readdir;
  exports["stat"] = stat;
})(PS["Node.FS.Aff"] = PS["Node.FS.Aff"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Node.Yargs

  exports.yargs = function() {
      return require('yargs');
  };

  exports.setupWith = function(setup) {
      return function(y) {
          return function() {
              return setup(y);
          };
      };
  };

  exports.argv = function(y) {
      return function() {
          return y.argv;
      };
  }
})(PS["Node.Yargs"] = PS["Node.Yargs"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Function = PS["Data.Function"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var usage = function (msg) {
      return Unsafe_Coerce.unsafeCoerce(function (y) {
          return y.usage(msg);
      });
  };
  var semigroupYargsSetup = new Prelude.Semigroup(function (s1) {
      return function (s2) {
          return Unsafe_Coerce.unsafeCoerce(function (y) {
              return Unsafe_Coerce.unsafeCoerce(s2)(Unsafe_Coerce.unsafeCoerce(s1)(y));
          });
      };
  });
  var requiresArg = function (key) {
      return Unsafe_Coerce.unsafeCoerce(function (y) {
          return y.requiresArg(key);
      });
  };
  var monoidYargsSetup = new Data_Monoid.Monoid(function () {
      return semigroupYargsSetup;
  }, Unsafe_Coerce.unsafeCoerce(function (y) {
      return y;
  }));
  var example = function (cmd) {
      return function (desc) {
          return Unsafe_Coerce.unsafeCoerce(function (y) {
              return y.example(cmd, desc);
          });
      };
  };
  var describe = function (key) {
      return function (desc) {
          return Unsafe_Coerce.unsafeCoerce(function (y) {
              return y.describe(key, desc);
          });
      };
  };
  var demand = function (key) {
      return function (msg) {
          return Unsafe_Coerce.unsafeCoerce(function (y) {
              return y.demand(key, msg);
          });
      };
  };
  var alias = function (key) {
      return function (a) {
          return Unsafe_Coerce.unsafeCoerce(function (y) {
              return y.alias(key, a);
          });
      };
  };
  exports["describe"] = describe;
  exports["requiresArg"] = requiresArg;
  exports["demand"] = demand;
  exports["alias"] = alias;
  exports["example"] = example;
  exports["usage"] = usage;
  exports["semigroupYargsSetup"] = semigroupYargsSetup;
  exports["monoidYargsSetup"] = monoidYargsSetup;
})(PS["Node.Yargs.Setup"] = PS["Node.Yargs.Setup"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.Yargs"];
  var Prelude = PS["Prelude"];
  var Data_Foreign = PS["Data.Foreign"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Node_Yargs_Setup = PS["Node.Yargs.Setup"];        
  var runYargs = function (setup) {
      return Prelude[">>="](Control_Monad_Eff.bindEff)(Prelude[">>="](Control_Monad_Eff.bindEff)($foreign.yargs)($foreign.setupWith(setup)))($foreign.argv);
  };
  exports["runYargs"] = runYargs;
})(PS["Node.Yargs"] = PS["Node.Yargs"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Either = PS["Data.Either"];
  var Data_Foldable = PS["Data.Foldable"];
  var Node_Yargs = PS["Node.Yargs"];
  var Node_Yargs_Setup = PS["Node.Yargs.Setup"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Unsafe = PS["Control.Monad.Eff.Unsafe"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Alt = PS["Control.Alt"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Arg = function (arg) {
      this.arg = arg;
  };
  var unY = function (v) {
      return v;
  };
  var runY = function (setup) {
      return function (v) {
          return function __do() {
              var v1 = Node_Yargs.runYargs(Prelude["<>"](Node_Yargs_Setup.semigroupYargsSetup)(setup)(v.setup))();
              var $13 = v.read(v1);
              if ($13 instanceof Data_Either.Left) {
                  return Control_Monad_Eff_Exception.throwException(Control_Monad_Eff_Exception.error(Prelude.show(Data_Foreign.showForeignError)($13.value0)))();
              };
              if ($13 instanceof Data_Either.Right) {
                  return Control_Monad_Eff_Unsafe.unsafeInterleaveEff($13.value0)();
              };
              throw new Error("Failed pattern match at Node.Yargs.Applicative line 51, column 3 - line 55, column 1: " + [ $13.constructor.name ]);
          };
      };
  };
  var functorY = new Prelude.Functor(function (f) {
      return function (v) {
          return {
              setup: v.setup, 
              read: function (value) {
                  return Prelude["<$>"](Data_Either.functorEither)(f)(v.read(value));
              }
          };
      };
  });
  var argNumber = new Arg(function (key) {
      return {
          setup: Data_Monoid.mempty(Node_Yargs_Setup.monoidYargsSetup), 
          read: Data_Foreign_Class.readProp(Data_Foreign_Class.numberIsForeign)(Data_Foreign_Index.indexString)(key)
      };
  });
  var arg = function (dict) {
      return dict.arg;
  };
  var yarg = function (dictArg) {
      return function (key) {
          return function (aliases) {
              return function (desc) {
                  return function (required) {
                      return function (needArg) {
                          var y = unY(arg(dictArg)(key));
                          return {
                              setup: Prelude["<>"](Node_Yargs_Setup.semigroupYargsSetup)(y.setup)(Prelude["<>"](Node_Yargs_Setup.semigroupYargsSetup)(Data_Foldable.foldMap(Data_Foldable.foldableArray)(Node_Yargs_Setup.monoidYargsSetup)(function (a) {
                                  return Node_Yargs_Setup.alias(key)(a);
                              })(aliases))(Prelude["<>"](Node_Yargs_Setup.semigroupYargsSetup)(Data_Foldable.foldMap(Data_Either.foldableEither)(Node_Yargs_Setup.monoidYargsSetup)(function (m) {
                                  return Node_Yargs_Setup.demand(key)(m);
                              })(required))(Prelude["<>"](Node_Yargs_Setup.semigroupYargsSetup)(Data_Foldable.foldMap(Data_Foldable.foldableMaybe)(Node_Yargs_Setup.monoidYargsSetup)(function (s) {
                                  return Node_Yargs_Setup.describe(key)(s);
                              })(desc))((function () {
                                  if (needArg) {
                                      return Node_Yargs_Setup.requiresArg(key);
                                  };
                                  if (!needArg) {
                                      return Data_Monoid.mempty(Node_Yargs_Setup.monoidYargsSetup);
                                  };
                                  throw new Error("Failed pattern match at Node.Yargs.Applicative line 96, column 17 - line 101, column 8: " + [ needArg.constructor.name ]);
                              })())))), 
                              read: (function () {
                                  if (required instanceof Data_Either.Left) {
                                      return function (value) {
                                          return Control_Alt["<|>"](Data_Either.altEither)(y.read(value))(Prelude.pure(Data_Either.applicativeEither)(required.value0));
                                      };
                                  };
                                  return y.read;
                              })()
                          };
                      };
                  };
              };
          };
      };
  };
  exports["Arg"] = Arg;
  exports["yarg"] = yarg;
  exports["arg"] = arg;
  exports["runY"] = runY;
  exports["functorY"] = functorY;
  exports["argNumber"] = argNumber;
})(PS["Node.Yargs.Applicative"] = PS["Node.Yargs.Applicative"] || {});
(function(exports) {
    "use strict";

  //module Server.Core
  /*eslint-env node*/

  exports.makeApp = function makeApp(){
    var app = require("express")();
    var compression = require("compression");
    app.use(compression());
    return app;
  };

  exports.listen = function listen(app){
    return function(port){
      return function(){
        var server = require("http").createServer(app);
        server.listen(port);
        return server;
      };
    };
  };

  exports.get = function get(app){
    return function (url){
      return function(mware){
        return function(handler){
          return function(){
            var cb = function(req, res){ return handler(req)(res)(); };
            var args = mware ? [url, mware, cb] : [url, cb];
            app.get.apply(app, args);
          };
        };
      };
    };
  };
  exports.delete = function get(app){
    return function (url){
      return function(mware){
        return function(handler){
          return function(){
            var cb = function(req, res){ return handler(req)(res)(); };
            var args = mware ? [url, mware, cb] : [url, cb];
            app.delete.apply(app, args);
          };
        };
      };
    };
  };


  exports.post = function get(app){
    return function (url){
      return function(mware){
        return function(handler){
          return function(){
            var cb = function(req, res){ return handler(req)(res)(); };
            var args = mware ? [url, mware, cb] : [url, cb];
            app.post.apply(app, args);
          };
        };
      };
    };
  };

  exports.put = function get(app){
    return function (url){
      return function(mware){
        return function(handler){
          return function(){
            var cb = function(req, res){ return handler(req)(res)(); };
            var args = mware ? [url, mware, cb] : [url, cb];
            app.put.apply(app, args);
          };
        };
      };
    };
  };

  exports.hostStatic = function(app){
    return function(root){
      return function(){
        app.use(require("express").static(root));
      };
    };
  };
  var bodyParser =require("body-parser");
  exports.bufferParser = bodyParser.raw({type: "*/*", limit: "5MB"});
  exports.rawParser = bodyParser.text({type: "*/*"});
  exports.noParser = null;

  exports.mkConvert = function mkConvert(constr){
    return function(unit){
      return function convert(req){
        return constr(req.url)(!req.body ? unit : req.body)(req.params)(req.path)(req.query)(req.headers);
      };
    };
  };

  exports.mkBufferConvert = function mkBufferConvert(constr){
    return function convert(req){
      return constr(req.url)(req.body)(req.params)(req.path)(req.query)(req.headers);
    };
  };

  exports.sendStr = function sendStr(res){
    return function(string){
      return function(){
        res.send(string);
      };
    };
  };
  exports.sendBuffer = function sendBuffer(res){
    return function(buffer){
      return function(){
        res.send(buffer);
      };
    };
  };
  exports.getParamsImpl = function getParamsImpl(just){
    return function(nothing){
      var regex = /\?params=(.*)$/;
      return function(url){
        var matches = url.match(regex);
        return matches[1] ? just(matches[1]) : nothing;
      };
    };
  };
})(PS["Server.Core"] = PS["Server.Core"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Server.Core"];
  var App_Endpoint = PS["App.Endpoint"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  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 Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var DOM_File_Types = PS["DOM.File.Types"];
  var Data_Either = PS["Data.Either"];
  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_Serializable = PS["Data.Serializable"];
  var Data_StrMap = PS["Data.StrMap"];
  var Global = PS["Global"];
  var Node_Buffer = PS["Node.Buffer"];
  var Prelude = PS["Prelude"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var Data_Foreign = PS["Data.Foreign"];
  var Endpoint_Client = PS["Endpoint.Client"];        
  var parseBody = function (dictGeneric) {
      return function (dictMonadError) {
          return function (a) {
              return Data_Either.either(function (err) {
                  return Control_Monad_Error_Class.throwError(dictMonadError)(Control_Monad_Eff_Exception.error(Prelude.show(Data_Foreign.showForeignError)(err)));
              })(function (p) {
                  return Prelude["return"]((dictMonadError["__superclass_Prelude.Monad_0"]())["__superclass_Prelude.Applicative_0"]())((function () {
                      var $27 = {};
                      for (var $28 in a) {
                          if (a.hasOwnProperty($28)) {
                              $27[$28] = a[$28];
                          };
                      };
                      $27.body = p;
                      return $27;
                  })());
              })(Data_Foreign_Generic.readJSONGeneric(dictGeneric)(Data_Foreign_Generic.defaultOptions)(a.body));
          };
      };
  };
  var mapBody = function (f) {
      return function (v) {
          var $31 = {};
          for (var $32 in v) {
              if (v.hasOwnProperty($32)) {
                  $31[$32] = v[$32];
              };
          };
          $31.body = f(v.body);
          return $31;
      };
  };
  var getParams = $foreign.getParamsImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var parseQueryParams = function (dictSerializable) {
      return function (dictMonadError) {
          return function (v) {
              return Data_Either.either(Control_Monad_Error_Class.throwError(dictMonadError))(Prelude["return"]((dictMonadError["__superclass_Prelude.Monad_0"]())["__superclass_Prelude.Applicative_0"]()))(Data_Maybe.maybe(Data_Either.Left.create(Control_Monad_Eff_Exception.error("No params found")))(function (s) {
                  return Data_Serializable.deserialize(dictSerializable)(s);
              })(getParams(Global["decodeURI"](v.url))));
          };
      };
  };
  var convertBlob = $foreign.mkBufferConvert(function (v) {
      return function (v1) {
          return function (v2) {
              return function (v3) {
                  return function (v4) {
                      return function (v5) {
                          return {
                              url: v, 
                              body: v1, 
                              params: v2, 
                              path: v3, 
                              query: v4, 
                              headers: v5
                          };
                      };
                  };
              };
          };
      };
  });
  var convert = $foreign.mkConvert(function (v) {
      return function (v1) {
          return function (v2) {
              return function (v3) {
                  return function (v4) {
                      return function (v5) {
                          return {
                              url: v, 
                              body: v1, 
                              params: v2, 
                              path: v3, 
                              query: v4, 
                              headers: v5
                          };
                      };
                  };
              };
          };
      };
  })(Data_Foreign_Generic.toJSONGeneric(Data_Generic.genericUnit)(Data_Foreign_Generic.defaultOptions)(Prelude.unit));
  var hostEndpoint = function (dictSerializable) {
      return function (dictGeneric) {
          return function (dictGeneric1) {
              return function (app) {
                  return function (v) {
                      return function (h) {
                          var handler = function (req) {
                              return function (res) {
                                  return Control_Monad_Aff.runAff(function (err) {
                                      return function __do() {
                                          Control_Monad_Eff_Console.log("Failed hostEndpoint on " + (v.value0.url + Control_Monad_Eff_Exception.message(err)))();
                                          return $foreign.sendStr(res)(Control_Monad_Eff_Exception.message(err))();
                                      };
                                  })(function (a) {
                                      return $foreign.sendStr(res)(Data_Foreign_Generic.toJSONGeneric(dictGeneric1)(Data_Foreign_Generic.defaultOptions)(a));
                                  })((function () {
                                      var i = convert(req);
                                      return Prelude.bind(Control_Monad_Aff.bindAff)(parseQueryParams(dictSerializable)(Control_Monad_Aff.monadErrorAff)(i))(function (v1) {
                                          return Prelude.bind(Control_Monad_Aff.bindAff)(parseBody(dictGeneric)(Control_Monad_Aff.monadErrorAff)(i))(function (v2) {
                                              return h(v1)(v2);
                                          });
                                      });
                                  })());
                              };
                          };
                          var register = function (f) {
                              return function (parser) {
                                  return f(app)(v.value0.url)(parser)(handler);
                              };
                          };
                          if (v.value0.method instanceof Data_HTTP_Method.GET) {
                              return register($foreign.get)($foreign.noParser);
                          };
                          if (v.value0.method instanceof Data_HTTP_Method.POST) {
                              return register($foreign.post)($foreign.rawParser);
                          };
                          if (v.value0.method instanceof Data_HTTP_Method.PUT) {
                              return register($foreign.put)($foreign.rawParser);
                          };
                          if (v.value0.method instanceof Data_HTTP_Method.DELETE) {
                              return register($foreign["delete"])($foreign.noParser);
                          };
                          throw new Error("Failed pattern match at Server.Core line 62, column 3 - line 67, column 3: " + [ v.value0.method.constructor.name ]);
                      };
                  };
              };
          };
      };
  };
  var hostFile = function (app) {
      return function (url) {
          return function (f) {
              var handler = function (req) {
                  return function (res) {
                      return Control_Monad_Aff.runAff(function (err) {
                          return function __do() {
                              Control_Monad_Eff_Console.log("Failed hostFile " + Control_Monad_Eff_Exception.message(err))();
                              return $foreign.sendStr(res)(Control_Monad_Eff_Exception.message(err))();
                          };
                      })(function (a) {
                          return $foreign.sendBuffer(res)(a);
                      })(Prelude[">>="](Control_Monad_Aff.bindAff)(parseBody(Data_Generic.genericUnit)(Control_Monad_Aff.monadErrorAff)(convert(req)))(f));
                  };
              };
              return $foreign.get(app)(url)($foreign.noParser)(handler);
          };
      };
  };
  var blobToBuffer = Unsafe_Coerce.unsafeCoerce;
  var hostFileUploadEndpoint = function (dictSerializable) {
      return function (dictGeneric) {
          return function (app) {
              return function (v) {
                  return function (h) {
                      var handler = function (req) {
                          return function (res) {
                              return Control_Monad_Aff.runAff(function (err) {
                                  return function __do() {
                                      Control_Monad_Eff_Console.log("Failed hostFileUploadEndpoint on " + (v.value0.url + Control_Monad_Eff_Exception.message(err)))();
                                      return $foreign.sendStr(res)(Control_Monad_Eff_Exception.message(err))();
                                  };
                              })(function (a) {
                                  return $foreign.sendStr(res)(Data_Foreign_Generic.toJSONGeneric(dictGeneric)(Data_Foreign_Generic.defaultOptions)(a));
                              })((function () {
                                  var i = convertBlob(req);
                                  return Prelude[">>="](Control_Monad_Aff.bindAff)(parseQueryParams(dictSerializable)(Control_Monad_Aff.monadErrorAff)(i))(function (qp) {
                                      return h(qp)(mapBody(blobToBuffer)(i));
                                  });
                              })());
                          };
                      };
                      return $foreign.post(app)(v.value0.url)($foreign.bufferParser)(handler);
                  };
              };
          };
      };
  };
  exports["hostFileUploadEndpoint"] = hostFileUploadEndpoint;
  exports["hostFile"] = hostFile;
  exports["hostEndpoint"] = hostEndpoint;
  exports["hostStatic"] = $foreign.hostStatic;
  exports["listen"] = $foreign.listen;
  exports["makeApp"] = $foreign.makeApp;
})(PS["Server.Core"] = PS["Server.Core"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var App_DB = PS["App.DB"];
  var App_Endpoint = PS["App.Endpoint"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  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 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_Int = PS["Data.Int"];
  var Data_Int_Extended = PS["Data.Int.Extended"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_StrMap = PS["Data.StrMap"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Database_AnyDB = PS["Database.AnyDB"];
  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 Node_Yargs_Applicative = PS["Node.Yargs.Applicative"];
  var Node_Yargs_Setup = PS["Node.Yargs.Setup"];
  var Prelude = PS["Prelude"];
  var Server_Core = PS["Server.Core"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var Data_Serializable = PS["Data.Serializable"];
  var Data_Generic = PS["Data.Generic"];
  var App_Model_Photobooth = PS["App.Model.Photobooth"];
  var App_Model_Event = PS["App.Model.Event"];
  var App_Model_Statistic = PS["App.Model.Statistic"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var App_Model_Session = PS["App.Model.Session"];        
  var withServerConn = Database_AnyDB.withConnection(App_DB.mainConnectionInfo);
  var throwStr = function (dictMonadError) {
      return function ($86) {
          return Control_Monad_Error_Class.throwError(dictMonadError)(Control_Monad_Eff_Exception.error($86));
      };
  };
  var setup = Prelude["<>"](Node_Yargs_Setup.semigroupYargsSetup)(Node_Yargs_Setup.usage("$0 -p port"))(Node_Yargs_Setup.example("$0 -p 8080")("Run photobooth server!"));
  var safeParseIntE = function (dictMonadError) {
      return function (label) {
          return function (s) {
              return Data_Maybe.maybe(throwStr(dictMonadError)(label + ": Invalid int provided"))(Prelude["return"]((dictMonadError["__superclass_Prelude.Monad_0"]())["__superclass_Prelude.Applicative_0"]()))(Data_Int_Extended.safeParseInt(s));
          };
      };
  };
  var readParams1 = function (dictMonadError) {
      return function (label) {
          return function (key) {
              return function (f) {
                  return function (v) {
                      return Data_Maybe.maybe(Control_Monad_Error_Class.throwError(dictMonadError)(Control_Monad_Eff_Exception.error(label + (": No " + (key + " provided")))))(f)(Data_StrMap.lookup(key)(v.params));
                  };
              };
          };
      };
  };
  var findProfileFiles = function (v) {
      return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(Node_Path.concat([ "profiles", v.value0, v.value1 ])))(function (names) {
          return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude["<$>"](Prelude.functorArray)(function (path) {
              return Node_Path.concat([ v.value0, v.value1, path ]);
          })(names));
      });
  };
  var blobToBuffer = Unsafe_Coerce.unsafeCoerce;
  var allProfiles = (function () {
      var prof = Node_Path.normalize("./profiles");
      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(prof))(function (v) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude.flip(Data_Array.filterM(Control_Monad_Aff.monadAff))(v)(function (p) {
              return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.stat(Node_Path.concat([ prof, p ])))(function ($87) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(Node_FS_Stats.isDirectory($87));
              });
          }))(function (v1) {
              return Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(v1)(function (dir) {
                  return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(Node_Path.concat([ prof, dir ])))(function (profs) {
                      return Prelude["return"](Control_Monad_Aff.applicativeAff)(new Data_Tuple.Tuple(dir, profs));
                  });
              });
          });
      });
  })();
  var server = function (p) {
      var port = Data_Int.ceil(p);
      return function __do() {
          var v = Data_Date.now();
          var v1 = Server_Core.makeApp();
          Server_Core.hostEndpoint(Data_Serializable.serializableString)(Data_Generic.genericUnit)(Data_Generic.genericMaybe(App_Model_Photobooth.genericPhotobooth))(v1)(App_Endpoint.getPhotobooth)(function (s) {
              return function (v2) {
                  return withServerConn(function (conn) {
                      return App_DB.queryPhotobooth(conn)(s);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_Photobooth.genericPhotobooth))(v1)(App_Endpoint.getPhotobooths)(function (v2) {
              return function (v3) {
                  return withServerConn(App_DB.allPhotobooths);
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(App_Model_Photobooth.genericPhotobooth)(App_Model_Photobooth.genericPhotobooth)(v1)(App_Endpoint.postPhotobooths)(function (v2) {
              return function (v3) {
                  return withServerConn(function (conn) {
                      return App_DB.newPB(conn)(v3.body);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(App_Model_Photobooth.genericPhotobooth)(App_Model_Photobooth.genericPhotobooth)(v1)(App_Endpoint.putPhotobooths)(function (v2) {
              return function (v3) {
                  return withServerConn(function (conn) {
                      return App_DB.updatePB(conn)(v3.body);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableString)(Data_Generic.genericUnit)(Data_Generic.genericUnit)(v1)(App_Endpoint.deletePhotobooth)(function (s) {
              return function (v2) {
                  return withServerConn(function (conn) {
                      return App_DB.deletePB(conn)(s);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableString)(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_Event.genericEvent))(v1)(App_Endpoint.getEvents)(function (s) {
              return function (v2) {
                  return withServerConn(function (conn) {
                      return App_DB.queryEvents(conn)(s);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(App_Model_Event.genericEvent)(App_Model_Event.genericEvent)(v1)(App_Endpoint.postEvents)(function (v2) {
              return function (v3) {
                  return withServerConn(function (conn) {
                      return App_DB.newEvent(conn)(v3.body);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(App_Model_Event.genericEvent)(App_Model_Event.genericEvent)(v1)(App_Endpoint.putEvents)(function (v2) {
              return function (v3) {
                  return withServerConn(function (conn) {
                      return App_DB.updateEvent(conn)(v3.body);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableTuple(Data_Serializable.serializableString)(Data_Serializable.serializableInt))(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_Event.genericEvent))(v1)(App_Endpoint.getEventsPaged)(function (v2) {
              return function (v3) {
                  return withServerConn(function (conn) {
                      return App_DB.queryEventsPaged(conn)(v2.value1)(v2.value0);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableArray(Data_Serializable.serializableInt))(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_Event.genericEvent))(v1)(App_Endpoint.getEventsByIds)(function (ids) {
              return function (v2) {
                  return withServerConn(function (conn) {
                      return App_DB.queryEventsByIds(conn)(ids);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableTuple(Data_Serializable.serializableString)(Data_Serializable.serializableDate))(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_Event.genericPartialEvent))(v1)(App_Endpoint.getNewEvents)(function (qp) {
              return function (v2) {
                  return withServerConn(function (conn) {
                      return App_DB.queryNewEvents(conn)(qp);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(Data_Generic.genericUnit)(Data_Generic.genericArray(Data_Generic.genericTuple(Data_Generic.genericString)(Data_Generic.genericArray(Data_Generic.genericString))))(v1)(App_Endpoint.getProfiles)(function (v2) {
              return function (v3) {
                  return allProfiles;
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableString)(Data_Generic.genericUnit)(App_Model_Statistic.genericAllStatistics)(v1)(App_Endpoint.getStatistics)(function (s) {
              return function (v2) {
                  return withServerConn(function (conn) {
                      return App_DB.queryAllStatistics(conn)(s);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableTuple(Data_Serializable.serializableString)(Data_Serializable.serializableDate))(Data_Generic.genericUnit)(Data_Generic.genericArray(App_Model_SavedFile.genericSavedFile))(v1)(App_Endpoint.getNewFiles)(function (qp) {
              return function (v2) {
                  return withServerConn(function (conn) {
                      return App_DB.queryNewFiles(conn)(qp);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(App_Model_Statistic.genericAllStatistics)(Data_Generic.genericUnit)(v1)(App_Endpoint.postStatistics)(function (v2) {
              return function (v3) {
                  return withServerConn(function (c) {
                      return App_DB.addStatistics(c)(v3.body);
                  });
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableTuple(Data_Serializable.serializableString)(Data_Serializable.serializableString))(Data_Generic.genericUnit)(Data_Generic.genericArray(Data_Generic.genericString))(v1)(App_Endpoint.getProfileFiles)(function (qp) {
              return function (v2) {
                  return findProfileFiles(qp);
              };
          })();
          Server_Core.hostEndpoint(Data_Serializable.serializableUnit)(Data_Generic.genericTuple(Data_Generic.genericString)(Data_Generic.genericString))(App_Model_Session.genericSession)(v1)(App_Endpoint.login)(function (v2) {
              return function (v3) {
                  return withServerConn(function (c) {
                      return App_DB.tryLogin(c)(v3.body.value0)(v3.body.value1);
                  });
              };
          })();
          Server_Core.hostFileUploadEndpoint(Data_Serializable.serializableTuple(Data_Serializable.serializableInt)(Data_Serializable.serializableString))(App_Model_SavedFile.genericSavedFile)(v1)(App_Endpoint.attachFile)(function (qp) {
              return function (v2) {
                  return withServerConn(function (c) {
                      return App_DB.saveFileToDb(c)(qp)(v2.body);
                  });
              };
          })();
          Server_Core.hostFile(v1)("/api/files/:id")(readParams1(Control_Monad_Aff.monadErrorAff)("GetFile")("id")(function (stri) {
              return Prelude[">>="](Control_Monad_Aff.bindAff)(safeParseIntE(Control_Monad_Aff.monadErrorAff)("GetFile")(stri))(function (id) {
                  return withServerConn(function (conn) {
                      return App_DB.getFileById(conn)(id);
                  });
              });
          }))();
          Server_Core.hostStatic(v1)("static")();
          Server_Core.hostStatic(v1)("profiles")();
          Server_Core.listen(v1)(port)();
          return Control_Monad_Eff_Console.log("Starting server on " + Prelude.show(Prelude.showInt)(port))();
      };
  };
  var main = Node_Yargs_Applicative.runY(setup)(Prelude["<$>"](Node_Yargs_Applicative.functorY)(server)(Node_Yargs_Applicative.yarg(Node_Yargs_Applicative.argNumber)("p")([ "port" ])(new Data_Maybe.Just("Port"))(new Data_Either.Left(8080.0))(false)));
  exports["allProfiles"] = allProfiles;
  exports["findProfileFiles"] = findProfileFiles;
  exports["throwStr"] = throwStr;
  exports["safeParseIntE"] = safeParseIntE;
  exports["readParams1"] = readParams1;
  exports["blobToBuffer"] = blobToBuffer;
  exports["server"] = server;
  exports["main"] = main;
  exports["setup"] = setup;
  exports["withServerConn"] = withServerConn;
})(PS["Main"] = PS["Main"] || {});
PS["Main"].main();