work.js

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

  //module App.Config

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

  // module Control.Monad.Eff

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

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

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

  // module Prelude

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

  exports.arrayMap = function (f) {
    return function (arr) {
      var l = arr.length;
      var result = new Array(l);
      for (var i = 0; i < l; i++) {
        result[i] = f(arr[i]);
      }
      return result;
    };
  };

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

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

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

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

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

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

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

  exports.showNumberImpl = function (n) {
    /* jshint bitwise: false */
    return n === (n | 0) ? n + ".0" : n.toString();
  };

  exports.showCharImpl = function (c) {
    var code = c.charCodeAt(0);
    if (code < 0x20 || code === 0x7F) {
      switch (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'";
      }
      return "'\\" + code.toString(10) + "'";
    }
    return c === "'" || c === "\\" ? "'\\" + c + "'" : "'" + c + "'";
  };

  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 Semiring = function (add, mul, one, zero) {
      this.add = add;
      this.mul = mul;
      this.one = one;
      this.zero = zero;
  };
  var Eq = function (eq) {
      this.eq = eq;
  };
  var Ord = function (__superclass_Prelude$dotEq_0, compare) {
      this["__superclass_Prelude.Eq_0"] = __superclass_Prelude$dotEq_0;
      this.compare = compare;
  };
  var Bounded = function (bottom, top) {
      this.bottom = bottom;
      this.top = top;
  };
  var BooleanAlgebra = function (__superclass_Prelude$dotBounded_0, conj, disj, not) {
      this["__superclass_Prelude.Bounded_0"] = __superclass_Prelude$dotBounded_0;
      this.conj = conj;
      this.disj = disj;
      this.not = not;
  };
  var Show = function (show) {
      this.show = show;
  };
  var zero = function (dict) {
      return dict.zero;
  };
  var unsafeCompare = $foreign.unsafeCompareImpl(LT.value)(EQ.value)(GT.value);
  var unit = {};
  var top = function (dict) {
      return dict.top;
  }; 
  var showString = new Show($foreign.showStringImpl);
  var showNumber = new Show($foreign.showNumberImpl);
  var showInt = new Show($foreign.showIntImpl);
  var showChar = new Show($foreign.showCharImpl);
  var showBoolean = new Show(function (v) {
      if (v) {
          return "true";
      };
      if (!v) {
          return "false";
      };
      throw new Error("Failed pattern match at Prelude line 842, column 3 - line 843, column 3: " + [ v.constructor.name ]);
  });
  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 one = function (dict) {
      return dict.one;
  };
  var not = function (dict) {
      return dict.not;
  };
  var mul = function (dict) {
      return dict.mul;
  };
  var map = function (dict) {
      return dict.map;
  };
  var $less$dollar$greater = function (dictFunctor) {
      return map(dictFunctor);
  };
  var id = function (dict) {
      return dict.id;
  };
  var functorArray = new Functor($foreign.arrayMap);
  var flip = function (f) {
      return function (b) {
          return function (a) {
              return f(a)(b);
          };
      };
  }; 
  var eqString = new Eq($foreign.refEq);
  var ordString = new Ord(function () {
      return eqString;
  }, unsafeCompare);
  var eq = function (dict) {
      return dict.eq;
  };
  var $eq$eq = function (dictEq) {
      return eq(dictEq);
  };
  var disj = function (dict) {
      return dict.disj;
  };
  var $$const = function (a) {
      return function (v) {
          return a;
      };
  };
  var $$void = function (dictFunctor) {
      return function (fa) {
          return $less$dollar$greater(dictFunctor)($$const(unit))(fa);
      };
  };
  var conj = function (dict) {
      return dict.conj;
  };
  var compose = function (dict) {
      return dict.compose;
  };
  var compare = function (dict) {
      return dict.compare;
  };
  var categoryFn = new Category(function () {
      return semigroupoidFn;
  }, function (x) {
      return x;
  });
  var boundedBoolean = new Bounded(false, true);
  var bottom = function (dict) {
      return dict.bottom;
  };
  var booleanAlgebraBoolean = new BooleanAlgebra(function () {
      return boundedBoolean;
  }, $foreign.boolAnd, $foreign.boolOr, $foreign.boolNot);
  var $div$eq = function (dictEq) {
      return function (x) {
          return function (y) {
              return not(booleanAlgebraBoolean)($eq$eq(dictEq)(x)(y));
          };
      };
  };
  var bind = function (dict) {
      return dict.bind;
  };
  var $greater$greater$eq = function (dictBind) {
      return bind(dictBind);
  }; 
  var apply = function (dict) {
      return dict.apply;
  };
  var $less$times$greater = function (dictApply) {
      return apply(dictApply);
  };
  var liftA1 = function (dictApplicative) {
      return function (f) {
          return function (a) {
              return $less$times$greater(dictApplicative["__superclass_Prelude.Apply_0"]())(pure(dictApplicative)(f))(a);
          };
      };
  }; 
  var append = function (dict) {
      return dict.append;
  };
  var $less$greater = function (dictSemigroup) {
      return append(dictSemigroup);
  };
  var ap = function (dictMonad) {
      return function (f) {
          return function (a) {
              return bind(dictMonad["__superclass_Prelude.Bind_1"]())(f)(function (v) {
                  return bind(dictMonad["__superclass_Prelude.Bind_1"]())(a)(function (v1) {
                      return $$return(dictMonad["__superclass_Prelude.Applicative_0"]())(v(v1));
                  });
              });
          };
      };
  }; 
  var add = function (dict) {
      return dict.add;
  };
  exports["LT"] = LT;
  exports["GT"] = GT;
  exports["EQ"] = EQ;
  exports["Show"] = Show;
  exports["BooleanAlgebra"] = BooleanAlgebra;
  exports["Bounded"] = Bounded;
  exports["Ord"] = Ord;
  exports["Eq"] = Eq;
  exports["Semiring"] = Semiring;
  exports["Monad"] = Monad;
  exports["Bind"] = Bind;
  exports["Applicative"] = Applicative;
  exports["Apply"] = Apply;
  exports["Functor"] = Functor;
  exports["Category"] = Category;
  exports["Semigroupoid"] = Semigroupoid;
  exports["show"] = show;
  exports["not"] = not;
  exports["disj"] = disj;
  exports["conj"] = conj;
  exports["bottom"] = bottom;
  exports["top"] = top;
  exports["unsafeCompare"] = unsafeCompare;
  exports["compare"] = compare;
  exports["/="] = $div$eq;
  exports["=="] = $eq$eq;
  exports["eq"] = eq;
  exports["one"] = one;
  exports["mul"] = mul;
  exports["zero"] = zero;
  exports["add"] = add;
  exports["<>"] = $less$greater;
  exports["append"] = append;
  exports["ap"] = ap;
  exports["return"] = $$return;
  exports[">>="] = $greater$greater$eq;
  exports["bind"] = bind;
  exports["liftA1"] = liftA1;
  exports["pure"] = pure;
  exports["<*>"] = $less$times$greater;
  exports["apply"] = apply;
  exports["void"] = $$void;
  exports["<$>"] = $less$dollar$greater;
  exports["map"] = map;
  exports["id"] = id;
  exports["compose"] = compose;
  exports["const"] = $$const;
  exports["flip"] = flip;
  exports["unit"] = unit;
  exports["semigroupoidFn"] = semigroupoidFn;
  exports["categoryFn"] = categoryFn;
  exports["functorArray"] = functorArray;
  exports["eqString"] = eqString;
  exports["ordString"] = ordString;
  exports["boundedBoolean"] = boundedBoolean;
  exports["booleanAlgebraBoolean"] = booleanAlgebraBoolean;
  exports["showBoolean"] = showBoolean;
  exports["showInt"] = showInt;
  exports["showNumber"] = showNumber;
  exports["showChar"] = showChar;
  exports["showString"] = showString;
  exports["showArray"] = showArray;
})(PS["Prelude"] = PS["Prelude"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Eff"];
  var Prelude = PS["Prelude"];        
  var monadEff = new Prelude.Monad(function () {
      return applicativeEff;
  }, function () {
      return bindEff;
  });
  var bindEff = new Prelude.Bind(function () {
      return applyEff;
  }, $foreign.bindE);
  var applyEff = new Prelude.Apply(function () {
      return functorEff;
  }, Prelude.ap(monadEff));
  var applicativeEff = new Prelude.Applicative(function () {
      return applyEff;
  }, $foreign.returnE);
  var functorEff = new Prelude.Functor(Prelude.liftA1(applicativeEff));
  exports["functorEff"] = functorEff;
  exports["applyEff"] = applyEff;
  exports["applicativeEff"] = applicativeEff;
  exports["bindEff"] = bindEff;
  exports["monadEff"] = monadEff;
  exports["runPure"] = $foreign.runPure;
})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  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;
  };
})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Foldable

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

  exports.foldlArray = function (f) {
    return function (init) {
      return function (xs) {
        var acc = init;
        var len = xs.length;
        for (var i = 0; i < len; i++) {
          acc = f(acc)(xs[i]);
        }
        return acc;
      };
    };
  };
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var $times$greater = function (dictApply) {
      return function (a) {
          return function (b) {
              return Prelude["<*>"](dictApply)(Prelude["<$>"](dictApply["__superclass_Prelude.Functor_0"]())(Prelude["const"](Prelude.id(Prelude.categoryFn)))(a))(b);
          };
      };
  };
  exports["*>"] = $times$greater;
})(PS["Control.Apply"] = PS["Control.Apply"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var mempty = function (dict) {
      return dict.mempty;
  };
  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 ]);
      };
  });
  exports["Nothing"] = Nothing;
  exports["Just"] = Just;
  exports["fromMaybe"] = fromMaybe;
  exports["maybe"] = maybe;
  exports["functorMaybe"] = functorMaybe;
  exports["applyMaybe"] = applyMaybe;
  exports["bindMaybe"] = bindMaybe;
})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
(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 foldl = function (dict) {
      return dict.foldl;
  }; 
  var foldMapDefaultR = function (dictFoldable) {
      return function (dictMonoid) {
          return function (f) {
              return function (xs) {
                  return foldr(dictFoldable)(function (x) {
                      return function (acc) {
                          return Prelude["<>"](dictMonoid["__superclass_Prelude.Semigroup_0"]())(f(x))(acc);
                      };
                  })(Data_Monoid.mempty(dictMonoid))(xs);
              };
          };
      };
  };
  var foldableArray = new Foldable(function (dictMonoid) {
      return foldMapDefaultR(foldableArray)(dictMonoid);
  }, $foreign.foldlArray, $foreign.foldrArray);
  var foldMap = function (dict) {
      return dict.foldMap;
  };
  exports["Foldable"] = Foldable;
  exports["foldMapDefaultR"] = foldMapDefaultR;
  exports["foldMap"] = foldMap;
  exports["foldl"] = foldl;
  exports["foldr"] = foldr;
  exports["foldableArray"] = foldableArray;
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Traversable

  // jshint maxparams: 3

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

    var emptyList = {};

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

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

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

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

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

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

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

  // module Data.Int

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

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

  // module Data.Maybe.Unsafe

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

  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"];
  exports["joinWith"] = $foreign.joinWith;
})(PS["Data.String"] = PS["Data.String"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Foreign"];
  var Prelude = PS["Prelude"];
  var Data_Either = PS["Data.Either"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Function = PS["Data.Function"];
  var Data_Int_1 = PS["Data.Int"];
  var Data_Int_1 = PS["Data.Int"];
  var Data_String = PS["Data.String"];        
  var TypeMismatch = (function () {
      function TypeMismatch(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      TypeMismatch.create = function (value0) {
          return function (value1) {
              return new TypeMismatch(value0, value1);
          };
      };
      return TypeMismatch;
  })();
  var ErrorAtIndex = (function () {
      function ErrorAtIndex(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ErrorAtIndex.create = function (value0) {
          return function (value1) {
              return new ErrorAtIndex(value0, value1);
          };
      };
      return ErrorAtIndex;
  })();
  var ErrorAtProperty = (function () {
      function ErrorAtProperty(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ErrorAtProperty.create = function (value0) {
          return function (value1) {
              return new ErrorAtProperty(value0, value1);
          };
      };
      return ErrorAtProperty;
  })();
  var JSONError = (function () {
      function JSONError(value0) {
          this.value0 = value0;
      };
      JSONError.create = function (value0) {
          return new JSONError(value0);
      };
      return JSONError;
  })();
  var unsafeReadTagged = function (tag) {
      return function (value) {
          if ($foreign.tagOf(value) === tag) {
              return Prelude.pure(Data_Either.applicativeEither)($foreign.unsafeFromForeign(value));
          };
          return new Data_Either.Left(new TypeMismatch(tag, $foreign.tagOf(value)));
      };
  };
  var showForeignError = new Prelude.Show(function (v) {
      if (v instanceof TypeMismatch) {
          return "Type mismatch: expected " + (v.value0 + (", found " + v.value1));
      };
      if (v instanceof ErrorAtIndex) {
          return "Error at array index " + (Prelude.show(Prelude.showInt)(v.value0) + (": " + Prelude.show(showForeignError)(v.value1)));
      };
      if (v instanceof ErrorAtProperty) {
          return "Error at property " + (Prelude.show(Prelude.showString)(v.value0) + (": " + Prelude.show(showForeignError)(v.value1)));
      };
      if (v instanceof JSONError) {
          return "JSON error: " + v.value0;
      };
      throw new Error("Failed pattern match at Data.Foreign line 54, column 3 - line 55, column 3: " + [ v.constructor.name ]);
  });
  var readString = unsafeReadTagged("String");
  var readNumber = unsafeReadTagged("Number");
  var readInt = function (value) {
      var error = Data_Either.Left.create(new TypeMismatch("Int", $foreign.tagOf(value)));
      var fromNumber = function ($30) {
          return Data_Maybe.maybe(error)(Prelude.pure(Data_Either.applicativeEither))(Data_Int_1.fromNumber($30));
      };
      return Data_Either.either(Prelude["const"](error))(fromNumber)(readNumber(value));
  };
  exports["TypeMismatch"] = TypeMismatch;
  exports["ErrorAtIndex"] = ErrorAtIndex;
  exports["ErrorAtProperty"] = ErrorAtProperty;
  exports["JSONError"] = JSONError;
  exports["readInt"] = readInt;
  exports["readNumber"] = readNumber;
  exports["readString"] = readString;
  exports["unsafeReadTagged"] = unsafeReadTagged;
  exports["showForeignError"] = showForeignError;
  exports["isUndefined"] = $foreign.isUndefined;
  exports["isNull"] = $foreign.isNull;
  exports["typeOf"] = $foreign.typeOf;
})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
(function(exports) {
  /* global exports */
  "use strict";

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

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

  //------------------------------------------------------------------------------
  // 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]);
        };
      };
    };
  };

  //------------------------------------------------------------------------------
  // 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);
      };
    };
  };
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Biapplicative = PS["Control.Biapplicative"];
  var Control_Biapply = PS["Control.Biapply"];
  var Control_Comonad = PS["Control.Comonad"];
  var Control_Extend = PS["Control.Extend"];
  var Control_Lazy = PS["Control.Lazy"];
  var Data_Bifoldable = PS["Data.Bifoldable"];
  var Data_Bifunctor = PS["Data.Bifunctor"];
  var Data_Bitraversable = PS["Data.Bitraversable"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];        
  var Tuple = (function () {
      function Tuple(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      Tuple.create = function (value0) {
          return function (value1) {
              return new Tuple(value0, value1);
          };
      };
      return Tuple;
  })();
  var snd = function (v) {
      return v.value1;
  };                                                                                                    
  var fst = function (v) {
      return v.value0;
  };
  exports["Tuple"] = Tuple;
  exports["snd"] = snd;
  exports["fst"] = fst;
})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Array"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Lazy = PS["Control.Lazy"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var 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 $$null = function (xs) {
      return $foreign.length(xs) === 0;
  };
  var index = $foreign.indexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var $bang$bang = index;
  var last = function (xs) {
      return $bang$bang(xs)($foreign.length(xs) - 1);
  };
  exports["sortBy"] = sortBy;
  exports["sort"] = sort;
  exports["index"] = index;
  exports["!!"] = $bang$bang;
  exports["last"] = last;
  exports["null"] = $$null;
  exports["length"] = $foreign.length;
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Foreign.Index

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

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

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

  // module Data.Generic


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

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

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

      };
      SigInt.value = new SigInt();
      return SigInt;
  })();
  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 genericShowPrec = function (d) {
      return function (v) {
          if (v instanceof SProd) {
              var showParen = function (v1) {
                  return function (x) {
                      if (!v1) {
                          return x;
                      };
                      if (v1) {
                          return "(" + (x + ")");
                      };
                      throw new Error("Failed pattern match at Data.Generic line 185, column 9 - line 186, column 9: " + [ v1.constructor.name, x.constructor.name ]);
                  };
              };
              var $72 = Data_Array["null"](v.value1);
              if ($72) {
                  return v.value0;
              };
              if (!$72) {
                  return showParen(d > 10)(v.value0 + (" " + Data_String.joinWith(" ")(Prelude.map(Prelude.functorArray)(function (x) {
                      return genericShowPrec(11)(x(Prelude.unit));
                  })(v.value1))));
              };
              throw new Error("Failed pattern match at Data.Generic line 182, column 5 - line 185, column 3: " + [ $72.constructor.name ]);
          };
          if (v instanceof SRecord) {
              return "{" + (Data_String.joinWith(", ")(Prelude.map(Prelude.functorArray)(function (x) {
                  return x.recLabel + (": " + genericShowPrec(0)(x.recValue(Prelude.unit)));
              })(v.value0)) + "}");
          };
          if (v instanceof SBoolean) {
              return Prelude.show(Prelude.showBoolean)(v.value0);
          };
          if (v instanceof SInt) {
              return Prelude.show(Prelude.showInt)(v.value0);
          };
          if (v instanceof SNumber) {
              return Prelude.show(Prelude.showNumber)(v.value0);
          };
          if (v instanceof SString) {
              return Prelude.show(Prelude.showString)(v.value0);
          };
          if (v instanceof SChar) {
              return Prelude.show(Prelude.showChar)(v.value0);
          };
          if (v instanceof SArray) {
              return "[" + (Data_String.joinWith(", ")(Prelude.map(Prelude.functorArray)(function (x) {
                  return genericShowPrec(0)(x(Prelude.unit));
              })(v.value0)) + "]");
          };
          throw new Error("Failed pattern match at Data.Generic line 181, column 1 - line 188, column 1: " + [ d.constructor.name, v.constructor.name ]);
      };
  }; 
  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 gShow = function (dictGeneric) {
      return function ($187) {
          return genericShowPrec(0)(toSpine(dictGeneric)($187));
      };
  };
  var fromSpine = function (dict) {
      return dict.fromSpine;
  };
  var eqGeneric = new Prelude.Eq(function (v) {
      return function (v1) {
          if (v instanceof SProd && v1 instanceof SProd) {
              return v.value0 === v1.value0 && (Data_Array.length(v.value1) === Data_Array.length(v1.value1) && $foreign.zipAll(function (x) {
                  return function (y) {
                      return Prelude["=="](eqGeneric)(x(Prelude.unit))(y(Prelude.unit));
                  };
              })(v.value1)(v1.value1));
          };
          if (v instanceof SRecord && v1 instanceof SRecord) {
              var go = function (x) {
                  return function (y) {
                      return x.recLabel === y.recLabel && Prelude["=="](eqGeneric)(x.recValue(Prelude.unit))(y.recValue(Prelude.unit));
                  };
              };
              return Data_Array.length(v.value0) === Data_Array.length(v1.value0) && $foreign.zipAll(go)(v.value0)(v1.value0);
          };
          if (v instanceof SInt && v1 instanceof SInt) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SNumber && v1 instanceof SNumber) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SBoolean && v1 instanceof SBoolean) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SChar && v1 instanceof SChar) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SString && v1 instanceof SString) {
              return v.value0 === v1.value0;
          };
          if (v instanceof SArray && v1 instanceof SArray) {
              return Data_Array.length(v.value0) === Data_Array.length(v1.value0) && $foreign.zipAll(function (x) {
                  return function (y) {
                      return Prelude["=="](eqGeneric)(x(Prelude.unit))(y(Prelude.unit));
                  };
              })(v.value0)(v1.value0);
          };
          return false;
      };
  });
  var gEq = function (dictGeneric) {
      return function (x) {
          return function (y) {
              return Prelude["=="](eqGeneric)(toSpine(dictGeneric)(x))(toSpine(dictGeneric)(y));
          };
      };
  };
  var anyProxy = (Type_Proxy["Proxy"]).value;
  exports["SigProd"] = SigProd;
  exports["SigRecord"] = SigRecord;
  exports["SigInt"] = SigInt;
  exports["SProd"] = SProd;
  exports["SRecord"] = SRecord;
  exports["SNumber"] = SNumber;
  exports["SBoolean"] = SBoolean;
  exports["SInt"] = SInt;
  exports["SString"] = SString;
  exports["SChar"] = SChar;
  exports["SArray"] = SArray;
  exports["Generic"] = Generic;
  exports["gEq"] = gEq;
  exports["gShow"] = gShow;
  exports["fromSpine"] = fromSpine;
  exports["toSignature"] = toSignature;
  exports["toSpine"] = toSpine;
  exports["genericInt"] = genericInt;
  exports["eqGeneric"] = eqGeneric;
})(PS["Data.Generic"] = PS["Data.Generic"] || {});
(function(exports) {
    "use strict";
  var path =require("path");         

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

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

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

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

  // module Control.Monad.Eff.Console

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

  // module Control.Monad.Eff.Exception

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

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

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

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

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

  exports.empty = {};

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

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

  exports._collect = _collect;

  exports.keys = Object.keys || _collect(function (k) {
    return function () { return k; };
  });
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  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;
})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.StrMap"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_List = PS["Data.List"];
  var Control_Monad_ST = PS["Control.Monad.ST"];
  var Data_StrMap_ST = PS["Data.StrMap.ST"];
  var thawST = $foreign._copyEff;
  var pureST = function (f) {
      return Control_Monad_Eff.runPure($foreign.runST(f));
  };
  var mutate = function (f) {
      return function (m) {
          return pureST(function __do() {
              var v = thawST(m)();
              f(v)();
              return v;
          });
      };
  }; 
  var insert = function (k) {
      return function (v) {
          return mutate(function (s) {
              return Data_StrMap_ST.poke(s)(k)(v);
          });
      };
  };
  exports["thawST"] = thawST;
  exports["insert"] = insert;
  exports["keys"] = $foreign.keys;
  exports["empty"] = $foreign.empty;
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
    "use strict";

  // module Unsafe.Coerce

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

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

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

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

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

  // jshint maxparams: 3
  exports.strictJsDate = function (just, nothing, s) {
    var epoch = Date.parse(s);
    if (isNaN(epoch)) return nothing;
    var date = new Date(epoch);
    var s2 = date.toISOString();
    var idx = s2.indexOf(s);
    return idx < 0 ? nothing : just(date);
  };
})(PS["Data.Date"] = PS["Data.Date"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Char = PS["Data.Char"];
  var Data_Either = PS["Data.Either"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Unfoldable = PS["Data.Unfoldable"];
  var Enum = function (__superclass_Prelude$dotBounded_0, cardinality, fromEnum, pred, succ, toEnum) {
      this["__superclass_Prelude.Bounded_0"] = __superclass_Prelude$dotBounded_0;
      this.cardinality = cardinality;
      this.fromEnum = fromEnum;
      this.pred = pred;
      this.succ = succ;
      this.toEnum = toEnum;
  };
  var toEnum = function (dict) {
      return dict.toEnum;
  };
  var succ = function (dict) {
      return dict.succ;
  };
  var pred = function (dict) {
      return dict.pred;
  };                               
  var fromEnum = function (dict) {
      return dict.fromEnum;
  };
  var defaultSucc = function (toEnum$prime) {
      return function (fromEnum$prime) {
          return function (a) {
              return toEnum$prime(fromEnum$prime(a) + 1 | 0);
          };
      };
  };
  var defaultPred = function (toEnum$prime) {
      return function (fromEnum$prime) {
          return function (a) {
              return toEnum$prime(fromEnum$prime(a) - 1);
          };
      };
  };                                                                                                                
  var cardinality = function (dict) {
      return dict.cardinality;
  };
  exports["Enum"] = Enum;
  exports["defaultPred"] = defaultPred;
  exports["defaultSucc"] = defaultSucc;
  exports["toEnum"] = toEnum;
  exports["succ"] = succ;
  exports["pred"] = pred;
  exports["fromEnum"] = fromEnum;
  exports["cardinality"] = cardinality;
})(PS["Data.Enum"] = PS["Data.Enum"] || {});
(function(exports) {
  /* globals exports */
  "use strict";     

  exports.isNaN = isNaN;
})(PS["Global"] = PS["Global"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Global"];
  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 January = (function () {
      function January() {

      };
      January.value = new January();
      return January;
  })();
  var February = (function () {
      function February() {

      };
      February.value = new February();
      return February;
  })();
  var March = (function () {
      function March() {

      };
      March.value = new March();
      return March;
  })();
  var April = (function () {
      function April() {

      };
      April.value = new April();
      return April;
  })();
  var May = (function () {
      function May() {

      };
      May.value = new May();
      return May;
  })();
  var June = (function () {
      function June() {

      };
      June.value = new June();
      return June;
  })();
  var July = (function () {
      function July() {

      };
      July.value = new July();
      return July;
  })();
  var August = (function () {
      function August() {

      };
      August.value = new August();
      return August;
  })();
  var September = (function () {
      function September() {

      };
      September.value = new September();
      return September;
  })();
  var October = (function () {
      function October() {

      };
      October.value = new October();
      return October;
  })();
  var November = (function () {
      function November() {

      };
      November.value = new November();
      return November;
  })();
  var December = (function () {
      function December() {

      };
      December.value = new December();
      return December;
  })();
  var DateTime = function (x) {
      return x;
  }; 
  var now = $foreign.nowImpl(DateTime);
  var monthToEnum = function (v) {
      if (v === 0) {
          return new Data_Maybe.Just(January.value);
      };
      if (v === 1) {
          return new Data_Maybe.Just(February.value);
      };
      if (v === 2) {
          return new Data_Maybe.Just(March.value);
      };
      if (v === 3) {
          return new Data_Maybe.Just(April.value);
      };
      if (v === 4) {
          return new Data_Maybe.Just(May.value);
      };
      if (v === 5) {
          return new Data_Maybe.Just(June.value);
      };
      if (v === 6) {
          return new Data_Maybe.Just(July.value);
      };
      if (v === 7) {
          return new Data_Maybe.Just(August.value);
      };
      if (v === 8) {
          return new Data_Maybe.Just(September.value);
      };
      if (v === 9) {
          return new Data_Maybe.Just(October.value);
      };
      if (v === 10) {
          return new Data_Maybe.Just(November.value);
      };
      if (v === 11) {
          return new Data_Maybe.Just(December.value);
      };
      return Data_Maybe.Nothing.value;
  };
  var monthFromEnum = function (v) {
      if (v instanceof January) {
          return 0;
      };
      if (v instanceof February) {
          return 1;
      };
      if (v instanceof March) {
          return 2;
      };
      if (v instanceof April) {
          return 3;
      };
      if (v instanceof May) {
          return 4;
      };
      if (v instanceof June) {
          return 5;
      };
      if (v instanceof July) {
          return 6;
      };
      if (v instanceof August) {
          return 7;
      };
      if (v instanceof September) {
          return 8;
      };
      if (v instanceof October) {
          return 9;
      };
      if (v instanceof November) {
          return 10;
      };
      if (v instanceof December) {
          return 11;
      };
      throw new Error("Failed pattern match at Data.Date line 207, column 1 - line 208, column 1: " + [ v.constructor.name ]);
  };
  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 boundedMonth = new Prelude.Bounded(January.value, December.value);
  var enumMonth = new Data_Enum.Enum(function () {
      return boundedMonth;
  }, 12, monthFromEnum, Data_Enum.defaultPred(monthToEnum)(monthFromEnum), Data_Enum.defaultSucc(monthToEnum)(monthFromEnum), monthToEnum);
  exports["January"] = January;
  exports["February"] = February;
  exports["March"] = March;
  exports["April"] = April;
  exports["May"] = May;
  exports["June"] = June;
  exports["July"] = July;
  exports["August"] = August;
  exports["September"] = September;
  exports["October"] = October;
  exports["November"] = November;
  exports["December"] = December;
  exports["now"] = now;
  exports["fromStringStrict"] = fromStringStrict;
  exports["fromJSDate"] = fromJSDate;
  exports["boundedMonth"] = boundedMonth;
  exports["enumMonth"] = enumMonth;
})(PS["Data.Date"] = PS["Data.Date"] || {});
(function(exports) {
    "use strict";
  var $foreign = PS["App.Model.Date"];
  var Data_Date = PS["Data.Date"];
  var Data_Maybe = PS["Data.Maybe"];
  exports["toISOString"] = $foreign.toISOString;
})(PS["App.Model.Date"] = PS["App.Model.Date"] || {});
(function(exports) {
    "use strict";

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

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

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

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

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

  exports._setTimeout = function (nonCanceler, millis, aff) {
    var set = setTimeout, clear = clearTimeout;
    if (millis <= 0 && typeof setImmediate === "function") {
      set = setImmediate;
      clear = clearImmediate;
    }
    return function(success, error) {
      var canceler;

      var timeout = set(function() {
        canceler = aff(success, error);
      }, millis);

      return function(e) {
        return function(s, f) {
          if (canceler !== undefined) {
            return canceler(e)(s, f);
          } else {
            clear(timeout);

            try {
              s(true);
            } catch (err) {
              f(err);
            }

            return nonCanceler;
          }
        };
      };
    };
  }

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

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

      return nonCanceler;
    };
  }

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

      return nonCanceler;
    };
  }

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

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

      var isCanceled    = false;
      var requestCancel = false;

      var onCanceler = function(){};

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

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

          onCanceler(canceler2);

          return canceler2;
        }
      }, error);

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

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

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

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

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

      return nonCanceler;
    };
  }
})(PS["Control.Monad.Aff"] = PS["Control.Monad.Aff"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];        
  var MonadEff = function (__superclass_Prelude$dotMonad_0, liftEff) {
      this["__superclass_Prelude.Monad_0"] = __superclass_Prelude$dotMonad_0;
      this.liftEff = liftEff;
  };                                 
  var liftEff = function (dict) {
      return dict.liftEff;
  };
  exports["MonadEff"] = MonadEff;
  exports["liftEff"] = liftEff;
})(PS["Control.Monad.Eff.Class"] = PS["Control.Monad.Eff.Class"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];        
  var MonadError = function (__superclass_Prelude$dotMonad_0, catchError, throwError) {
      this["__superclass_Prelude.Monad_0"] = __superclass_Prelude$dotMonad_0;
      this.catchError = catchError;
      this.throwError = throwError;
  };
  var throwError = function (dict) {
      return dict.throwError;
  };                          
  var catchError = function (dict) {
      return dict.catchError;
  };
  exports["MonadError"] = MonadError;
  exports["catchError"] = catchError;
  exports["throwError"] = throwError;
})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Control.Monad.Aff"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Either = PS["Data.Either"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Function = PS["Data.Function"];
  var Data_Monoid = PS["Data.Monoid"];
  var runAff = function (ex) {
      return function (f) {
          return function (aff) {
              return $foreign._runAff(ex, f, aff);
          };
      };
  };
  var makeAff$prime = function (h) {
      return $foreign._makeAff(h);
  };
  var functorAff = new Prelude.Functor(function (f) {
      return function (fa) {
          return $foreign._fmap(f, fa);
      };
  });
  var attempt = function (aff) {
      return $foreign._attempt(Data_Either.Left.create, Data_Either.Right.create, aff);
  };
  var apathize = function (a) {
      return Prelude["<$>"](functorAff)(Prelude["const"](Prelude.unit))(attempt(a));
  };
  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 later$prime = function (n) {
      return function (aff) {
          return $foreign._setTimeout(nonCanceler, n, aff);
      };
  };
  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["later'"] = later$prime;
  exports["finally"] = $$finally;
  exports["attempt"] = attempt;
  exports["apathize"] = apathize;
  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) {
  /* global exports */
  /* global Buffer */
  /* global require */
  "use strict";

  exports.toStringImpl = function (enc) {
    return function (buff) {
      return function() {
        return buff.toString(enc);
      };
    };
  };
})(PS["Node.Buffer"] = PS["Node.Buffer"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.Encoding"];
  var Prelude = PS["Prelude"];        
  var ASCII = (function () {
      function ASCII() {

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

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

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

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

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

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

      };
      Hex.value = new Hex();
      return Hex;
  })();
  var showEncoding = new Prelude.Show(function (v) {
      if (v instanceof ASCII) {
          return "ascii";
      };
      if (v instanceof UTF8) {
          return "utf8";
      };
      if (v instanceof UTF16LE) {
          return "utf16le";
      };
      if (v instanceof UCS2) {
          return "ucs2";
      };
      if (v instanceof Base64) {
          return "base64";
      };
      if (v instanceof Binary) {
          return "binary";
      };
      if (v instanceof Hex) {
          return "hex";
      };
      throw new Error("Failed pattern match at Node.Encoding line 18, column 3 - line 19, column 3: " + [ v.constructor.name ]);
  });
  exports["ASCII"] = ASCII;
  exports["UTF8"] = UTF8;
  exports["UTF16LE"] = UTF16LE;
  exports["UCS2"] = UCS2;
  exports["Base64"] = Base64;
  exports["Binary"] = Binary;
  exports["Hex"] = Hex;
  exports["showEncoding"] = showEncoding;
})(PS["Node.Encoding"] = PS["Node.Encoding"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.Buffer"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Maybe = PS["Data.Maybe"];
  var Node_Encoding = PS["Node.Encoding"];
  var toString = function ($3) {
      return $foreign.toStringImpl(Prelude.show(Node_Encoding.showEncoding)($3));
  };
  exports["toString"] = toString;
})(PS["Node.Buffer"] = PS["Node.Buffer"] || {});
(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));
  });
  exports["IsSqlValue"] = IsSqlValue;
  exports["toSql"] = toSql;
  exports["isSqlValueString"] = isSqlValueString;
  exports["isSqlValueInt"] = isSqlValueInt;
})(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 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 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["execute_"] = execute_;
  exports["execute"] = execute;
  exports["connect"] = connect;
  exports["mkConnectionString"] = mkConnectionString;
})(PS["Database.AnyDB"] = PS["Database.AnyDB"] || {});
(function(exports) {
    "use strict";

  //module App.Model.StrMap

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

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

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

      };
      Date.value = new Date();
      return Date;
  })();
  var ColumnDef = (function () {
      function ColumnDef(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      ColumnDef.create = function (value0) {
          return function (value1) {
              return new ColumnDef(value0, value1);
          };
      };
      return ColumnDef;
  })();
  var parens = function (s) {
      return " (" + (s + ")");
  };
  var insert = function (v) {
      return function (fs) {
          return function (repl) {
              return function (str) {
                  var sortedValues = Prelude.map(Prelude.functorArray)(Data_Tuple.snd)(Data_Array.sortBy(function (f1) {
                      return function (f2) {
                          return Prelude.compare(Prelude.ordString)(Data_Tuple.fst(f1))(Data_Tuple.fst(f2));
                      };
                  })(App_Model_StrMap.toArray(fs)));
                  var sortedKeys = Data_Array.sort(Prelude.ordString)(Data_StrMap.keys(fs));
                  return Database_AnyDB.Query("INSERT " + ((function () {
                      if (repl) {
                          return " or replace ";
                      };
                      if (!repl) {
                          return "";
                      };
                      throw new Error("Failed pattern match at SQL line 61, column 28 - line 61, column 63: " + [ repl.constructor.name ]);
                  })() + ("INTO " + (v.name + (parens(Data_String.joinWith(", ")(sortedKeys)) + (" VALUES" + (parens(Data_String.joinWith(", ")(Prelude.map(Prelude.functorArray)(function (str2) {
                      return "'" + (str2 + "'");
                  })(sortedValues))) + (";" + str))))))));
              };
          };
      };
  };
  exports["Char"] = Char;
  exports["Integer"] = Integer;
  exports["Date"] = $$Date;
  exports["ColumnDef"] = ColumnDef;
  exports["parens"] = parens;
  exports["insert"] = insert;
})(PS["SQL"] = PS["SQL"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Lens = PS["Data.Lens"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Date = PS["Data.Date"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Either = PS["Data.Either"];
  var Data_Array = PS["Data.Array"];
  var App_Model_StrMap = PS["App.Model.StrMap"];
  var App_Model_SavedFile = PS["App.Model.SavedFile"];
  var Data_Foreign_Index = PS["Data.Foreign.Index"];
  var Data_Lens_Lens = PS["Data.Lens.Lens"];        
  var PartialEvent = (function () {
      function PartialEvent(value0) {
          this.value0 = value0;
      };
      PartialEvent.create = function (value0) {
          return new PartialEvent(value0);
      };
      return PartialEvent;
  })();
  var partialEventIsForeign = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Prelude["<$>"](Data_Either.functorEither)(Data_Maybe.Just.create)(Data_Foreign_Class.readProp(Data_Foreign_Class.intIsForeign)(Data_Foreign_Index.indexString)("id")(obj)))(function (v) {
          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("computername")(obj))(function (v1) {
              return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("name")(obj))(function (v2) {
                  return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("datefrom")(obj))(function (v3) {
                      return Prelude.bind(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create(new Data_Foreign.TypeMismatch("ISO 8601 Date", v3)))(Data_Either.Right.create)(Data_Date.fromStringStrict(v3)))(function (v4) {
                          return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("dateuntil")(obj))(function (v5) {
                              return Prelude.bind(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create(new Data_Foreign.TypeMismatch("ISO 8601 Date", v5)))(Data_Either.Right.create)(Data_Date.fromStringStrict(v5)))(function (v6) {
                                  return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(Data_Foreign_Class.stringIsForeign)(Data_Foreign_Index.indexString)("profile")(obj))(function (v7) {
                                      return Prelude["return"](Data_Either.applicativeEither)(new PartialEvent({
                                          id: v, 
                                          computername: v1, 
                                          name: v2, 
                                          datefrom: v4, 
                                          dateuntil: v6, 
                                          profile: v7
                                      }));
                                  });
                              });
                          });
                      });
                  });
              });
          });
      });
  });
  exports["PartialEvent"] = PartialEvent;
  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 = 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 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 monthToInt = function (v) {
      if (v instanceof Data_Date.January) {
          return 1;
      };
      if (v instanceof Data_Date.February) {
          return 2;
      };
      if (v instanceof Data_Date.March) {
          return 3;
      };
      if (v instanceof Data_Date.April) {
          return 4;
      };
      if (v instanceof Data_Date.May) {
          return 5;
      };
      if (v instanceof Data_Date.June) {
          return 6;
      };
      if (v instanceof Data_Date.July) {
          return 7;
      };
      if (v instanceof Data_Date.August) {
          return 8;
      };
      if (v instanceof Data_Date.September) {
          return 9;
      };
      if (v instanceof Data_Date.October) {
          return 10;
      };
      if (v instanceof Data_Date.November) {
          return 11;
      };
      if (v instanceof Data_Date.December) {
          return 12;
      };
      throw new Error("Failed pattern match at App.Model.Statistic line 101, column 1 - line 102, column 1: " + [ v.constructor.name ]);
  };                                                                                 
  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, [  ])) ])
  };
  exports["MonthlyStatistic"] = MonthlyStatistic;
  exports["EventStatistic"] = EventStatistic;
  exports["monthToInt"] = monthToInt;
  exports["monthlyStatisticsTable"] = monthlyStatisticsTable;
  exports["eventStatisticsTable"] = eventStatisticsTable;
  exports["monthlyStatisticIsForeign"] = monthlyStatisticIsForeign;
})(PS["App.Model.Statistic"] = PS["App.Model.Statistic"] || {});
(function(exports) {
    "use strict";
  var Prelude = PS["Prelude"];
  var SQL = PS["SQL"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Database_AnyDB_SqlValue = PS["Database.AnyDB.SqlValue"];
  var Data_Generic = PS["Data.Generic"];
  var Data_Foreign_Class = PS["Data.Foreign.Class"];
  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 DefaultActive = (function () {
      function DefaultActive() {

      };
      DefaultActive.value = new DefaultActive();
      return DefaultActive;
  })();
  var EventActive = (function () {
      function EventActive(value0) {
          this.value0 = value0;
      };
      EventActive.create = function (value0) {
          return new EventActive(value0);
      };
      return EventActive;
  })();
  var WorkerState = (function () {
      function WorkerState(value0) {
          this.value0 = value0;
      };
      WorkerState.create = function (value0) {
          return new WorkerState(value0);
      };
      return WorkerState;
  })();
  var isSqlValueActive = new Database_AnyDB_SqlValue.IsSqlValue(function (v) {
      if (v instanceof DefaultActive) {
          return Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(-1);
      };
      if (v instanceof EventActive) {
          return Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(v.value0);
      };
      throw new Error("Failed pattern match at App.Model.WorkerState line 33, column 3 - line 34, column 3: " + [ v.constructor.name ]);
  });
  var genericActive = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.WorkerState.DefaultActive" && v.value1.length === 0)) {
          return new Data_Maybe.Just(DefaultActive.value);
      };
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.WorkerState.EventActive" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(EventActive.create))(Data_Generic.fromSpine(Data_Generic.genericInt)(v.value1[0](Prelude.unit)));
      };
      return Data_Maybe.Nothing.value;
  }, function ($dollarq) {
      return new Data_Generic.SigProd("App.Model.WorkerState.Active", [ {
          sigConstructor: "App.Model.WorkerState.DefaultActive", 
          sigValues: [  ]
      }, {
          sigConstructor: "App.Model.WorkerState.EventActive", 
          sigValues: [ function ($dollarq1) {
              return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);
          } ]
      } ]);
  }, function (v) {
      if (v instanceof DefaultActive) {
          return new Data_Generic.SProd("App.Model.WorkerState.DefaultActive", [  ]);
      };
      if (v instanceof EventActive) {
          return new Data_Generic.SProd("App.Model.WorkerState.EventActive", [ function ($dollarq) {
              return Data_Generic.toSpine(Data_Generic.genericInt)(v.value0);
          } ]);
      };
      throw new Error("Failed pattern match at App.Model.WorkerState line 18, column 1 - line 19, column 1: " + [ v.constructor.name ]);
  });
  var genericWorkerState = new Data_Generic.Generic(function (v) {
      if (v instanceof Data_Generic.SProd && (v.value0 === "App.Model.WorkerState.WorkerState" && v.value1.length === 1)) {
          return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(WorkerState.create))((function (r) {
              if (r instanceof Data_Generic.SRecord && r.value0.length === 1) {
                  return Prelude.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(function (active1) {
                      return {
                          active: active1
                      };
                  }))(Data_Generic.fromSpine(genericActive)((r.value0[0]).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.WorkerState.WorkerState", [ {
          sigConstructor: "App.Model.WorkerState.WorkerState", 
          sigValues: [ function ($dollarq1) {
              return new Data_Generic.SigRecord([ {
                  recLabel: "active", 
                  recValue: function ($dollarq2) {
                      return Data_Generic.toSignature(genericActive)(Data_Generic.anyProxy);
                  }
              } ]);
          } ]
      } ]);
  }, function (v) {
      return new Data_Generic.SProd("App.Model.WorkerState.WorkerState", [ function ($dollarq) {
          return new Data_Generic.SRecord([ {
              recLabel: "active", 
              recValue: function ($dollarq1) {
                  return Data_Generic.toSpine(genericActive)(v.value0.active);
              }
          } ]);
      } ]);
  });
  var showWorkerState = new Prelude.Show(Data_Generic.gShow(genericWorkerState));
  var showActive = new Prelude.Show(Data_Generic.gShow(genericActive));
  var foreignActive = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.read(Data_Foreign_Class.intIsForeign)(obj))(function (v) {
          var $31 = v === -1;
          if ($31) {
              return Prelude["return"](Data_Either.applicativeEither)(DefaultActive.value);
          };
          if (!$31) {
              return Prelude["return"](Data_Either.applicativeEither)(new EventActive(v));
          };
          throw new Error("Failed pattern match at App.Model.WorkerState line 29, column 5 - line 32, column 1: " + [ $31.constructor.name ]);
      });
  });
  var foreignWorkerState = new Data_Foreign_Class.IsForeign(function (obj) {
      return Prelude.bind(Data_Either.bindEither)(Data_Foreign_Class.readProp(foreignActive)(Data_Foreign_Index.indexString)("activeeventid")(obj))(function (v) {
          return Prelude["return"](Data_Either.applicativeEither)(new WorkerState({
              active: v
          }));
      });
  });                                                                      
  var eqActive = new Prelude.Eq(Data_Generic.gEq(genericActive));
  exports["WorkerState"] = WorkerState;
  exports["DefaultActive"] = DefaultActive;
  exports["EventActive"] = EventActive;
  exports["genericActive"] = genericActive;
  exports["genericWorkerState"] = genericWorkerState;
  exports["eqActive"] = eqActive;
  exports["showActive"] = showActive;
  exports["showWorkerState"] = showWorkerState;
  exports["foreignActive"] = foreignActive;
  exports["isSqlValueActive"] = isSqlValueActive;
  exports["foreignWorkerState"] = foreignWorkerState;
})(PS["App.Model.WorkerState"] = PS["App.Model.WorkerState"] || {});
(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 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 updateWorkerState = function (c) {
      return function (v) {
          return Database_AnyDB.execute("update WORKERSTATE set activeeventid = ?")([ Database_AnyDB_SqlValue.toSql(App_Model_WorkerState.isSqlValueActive)(v.value0.active) ])(c);
      };
  };
  var queryActiveEvent = function (c) {
      return function (d) {
          var q = Database_AnyDB.Query("select * from EVENTS where " + ("datefrom <= ? " + "and dateuntil > ? "));
          return Database_AnyDB.queryOne(App_Model_Event.partialEventIsForeign)(q)([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(App_Model_Date.toISOString(d)), Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueString)(App_Model_Date.toISOString(d)) ])(c);
      };
  };
  var networkingConnectionInfo = new Database_AnyDB.Sqlite3({
      filename: "networkingdb", 
      memory: false
  });
  var getMonthlyStatistic = function (cname) {
      return function (c) {
          return function (m) {
              var handle = function (v) {
                  if (v instanceof Data_Maybe.Nothing) {
                      return new App_Model_Statistic.MonthlyStatistic({
                          computername: cname, 
                          month: m, 
                          pictures: 0, 
                          prints: 0
                      });
                  };
                  if (v instanceof Data_Maybe.Just) {
                      return v.value0;
                  };
                  throw new Error("Failed pattern match at App.DB line 354, column 3 - line 362, column 1: " + [ v.constructor.name ]);
              };
              return Prelude[">>="](Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne(App_Model_Statistic.monthlyStatisticIsForeign)("select * from monthlystatistics where month = ?")([ Database_AnyDB_SqlValue.toSql(Database_AnyDB_SqlValue.isSqlValueInt)(m) ])(c))(function ($136) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(handle($136));
              });
          };
      };
  };
  exports["getMonthlyStatistic"] = getMonthlyStatistic;
  exports["queryActiveEvent"] = queryActiveEvent;
  exports["updateWorkerState"] = updateWorkerState;
  exports["upsertMonthlyStatistic"] = upsertMonthlyStatistic;
  exports["upsertEventStatistic"] = upsertEventStatistic;
  exports["networkingConnectionInfo"] = networkingConnectionInfo;
})(PS["App.DB"] = PS["App.DB"] || {});
(function(exports) {
    "use strict";
  exports.execImpl = function execImpl(command) {
    return function(opts) {
      return function(callback) {
        return function() {
          return require("child_process").exec(command, opts, function(err, stdout, stderr) {
            callback(err)(stdout)(stderr)();
          });
        };
      };
    };
  };
  exports.execFileImpl = function execImpl(command) {
    return function(args) {
      return function(opts) {
        return function(callback) {
          return function() {
            return require("child_process").execFile(command, args, opts, function(err, stdout, stderr) {
              callback(err)(stdout)(stderr)();
            });
          };
        };
      };
    };
  };

  exports["undefined"] = undefined;
})(PS["Node.ChildProcess"] = PS["Node.ChildProcess"] || {});
(function(exports) {
  /* global exports */
  "use strict";          

  exports.nullable = function(a, r, f) {
      return a == null ? r : f(a);
  };
})(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 toMaybe = function (n) {
      return $foreign.nullable(n, Data_Maybe.Nothing.value, Data_Maybe.Just.create);
  };
  exports["toMaybe"] = toMaybe;
})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.ChildProcess"];
  var Prelude = PS["Prelude"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Eff_Exception_Unsafe = PS["Control.Monad.Eff.Exception.Unsafe"];
  var Data_StrMap = PS["Data.StrMap"];
  var Data_Function = PS["Data.Function"];
  var Data_Nullable = PS["Data.Nullable"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Foreign = PS["Data.Foreign"];
  var Data_Posix = PS["Data.Posix"];
  var Data_Posix_Signal_1 = PS["Data.Posix.Signal"];
  var Data_Posix_Signal_1 = PS["Data.Posix.Signal"];
  var Unsafe_Coerce = PS["Unsafe.Coerce"];
  var Node_Buffer = PS["Node.Buffer"];
  var Node_FS = PS["Node.FS"];
  var Node_Stream = PS["Node.Stream"];
  var convertExecOptions = function (opts) {
      return Unsafe_Coerce.unsafeCoerce({
          cwd: Data_Maybe.fromMaybe($foreign["undefined"])(opts.cwd), 
          env: Data_Maybe.fromMaybe($foreign["undefined"])(opts.env), 
          timeout: Data_Maybe.fromMaybe($foreign["undefined"])(opts.timeout), 
          maxBuffer: Data_Maybe.fromMaybe($foreign["undefined"])(opts.maxBuffer), 
          killSignal: Data_Maybe.fromMaybe($foreign["undefined"])(opts.killSignal), 
          uid: Data_Maybe.fromMaybe($foreign["undefined"])(opts.uid), 
          gid: Data_Maybe.fromMaybe($foreign["undefined"])(opts.gid)
      });
  };
  var exec = function (cmd) {
      return function (opts) {
          return function (callback) {
              return $foreign.execImpl(cmd)(convertExecOptions(opts))(function (err) {
                  return function (stdout$prime) {
                      return function (stderr$prime) {
                          return callback({
                              error: Data_Nullable.toMaybe(err), 
                              stdout: stdout$prime, 
                              stderr: stderr$prime
                          });
                      };
                  };
              });
          };
      };
  };
  var execFile = function (cmd) {
      return function (args) {
          return function (opts) {
              return function (callback) {
                  return $foreign.execFileImpl(cmd)(args)(convertExecOptions(opts))(function (err) {
                      return function (stdout$prime) {
                          return function (stderr$prime) {
                              return callback({
                                  error: Data_Nullable.toMaybe(err), 
                                  stdout: stdout$prime, 
                                  stderr: stderr$prime
                              });
                          };
                      };
                  });
              };
          };
      };
  };
  exports["execFile"] = execFile;
  exports["exec"] = exec;
})(PS["Node.ChildProcess"] = PS["Node.ChildProcess"] || {});
(function(exports) {
    "use strict";
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_StrMap = PS["Data.StrMap"];
  var Data_String = PS["Data.String"];
  var Node_Buffer = PS["Node.Buffer"];
  var Node_ChildProcess = PS["Node.ChildProcess"];
  var Node_Encoding = PS["Node.Encoding"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];        
  var simpleExecStr = function (cmd) {
      return function (cwd) {
          return function (env) {
              return Control_Monad_Aff.makeAff(function (errcb) {
                  return function (okcb) {
                      var ops = {
                          cwd: cwd, 
                          env: env, 
                          timeout: new Data_Maybe.Just(5000.0), 
                          maxBuffer: Data_Maybe.Nothing.value, 
                          killSignal: Data_Maybe.Nothing.value, 
                          uid: Data_Maybe.Nothing.value, 
                          gid: Data_Maybe.Nothing.value
                      };
                      var handler = function (v) {
                          return function __do() {
                              var v1 = Node_Buffer.toString(Node_Encoding.UTF8.value)(v.stderr)();
                              var v2 = Node_Buffer.toString(Node_Encoding.UTF8.value)(v.stdout)();
                              return Data_Maybe.maybe(okcb(Data_String.joinWith(" ")([ "Success:", cmd, "Stdout:", v2, "StdErr: ", v1 ])))(function (e) {
                                  return errcb(Control_Monad_Eff_Exception.error(Data_String.joinWith(" ")([ "Error:", cmd, "Stdout:", v2, "StdErr: ", v1, "Error:", Prelude.show(Control_Monad_Eff_Exception.showError)(e) ])));
                              })(v.error)();
                          };
                      };
                      return Node_ChildProcess.exec(cmd)(ops)(handler);
                  };
              });
          };
      };
  };
  var simpleExec = function (cmd) {
      return function (cwd) {
          return function (args) {
              return function (env) {
                  return Control_Monad_Aff.makeAff(function (errcb) {
                      return function (okcb) {
                          var ops = {
                              cwd: cwd, 
                              env: env, 
                              timeout: Data_Maybe.Nothing.value, 
                              maxBuffer: Data_Maybe.Nothing.value, 
                              killSignal: Data_Maybe.Nothing.value, 
                              uid: Data_Maybe.Nothing.value, 
                              gid: Data_Maybe.Nothing.value
                          };
                          var handler = function (v) {
                              return function __do() {
                                  var v1 = Node_Buffer.toString(Node_Encoding.UTF8.value)(v.stderr)();
                                  var v2 = Node_Buffer.toString(Node_Encoding.UTF8.value)(v.stdout)();
                                  return Data_Maybe.maybe(okcb(Data_String.joinWith(" ")([ "Success:", cmd, Prelude.show(Prelude.showArray(Prelude.showString))(args), "Stdout:", v2, "StdErr: ", v1 ])))(function (e) {
                                      return errcb(Control_Monad_Eff_Exception.error(Data_String.joinWith(" ")([ "Error:", cmd, Prelude.show(Prelude.showArray(Prelude.showString))(args), "Stdout:", v2, "StdErr: ", v1, "Error:", Prelude.show(Control_Monad_Eff_Exception.showError)(e) ])));
                                  })(v.error)();
                              };
                          };
                          return Node_ChildProcess.execFile(cmd)(args)(ops)(handler);
                      };
                  });
              };
          };
      };
  };
  exports["simpleExecStr"] = simpleExecStr;
  exports["simpleExec"] = simpleExec;
})(PS["App.Exec"] = PS["App.Exec"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Global = PS["Global"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var Data_Char = PS["Data.Char"];
  var Data_String = PS["Data.String"];
  var Data_Int = PS["Data.Int"];
  var semiringPerm = new Prelude.Semiring(function (v) {
      return function (v1) {
          return {
              r: v.r || v1.r, 
              w: v.w || v1.w, 
              x: v.x || v1.x
          };
      };
  }, function (v) {
      return function (v1) {
          return {
              r: v.r && v1.r, 
              w: v.w && v1.w, 
              x: v.x && v1.x
          };
      };
  }, {
      r: true, 
      w: true, 
      x: true
  }, {
      r: false, 
      w: false, 
      x: false
  });
  var permToInt = function (v) {
      return ((function () {
          if (v.r) {
              return 4;
          };
          if (!v.r) {
              return 0;
          };
          throw new Error("Failed pattern match at Node.FS.Perms line 158, column 8 - line 158, column 26: " + [ v.r.constructor.name ]);
      })() + (function () {
          if (v.w) {
              return 2;
          };
          if (!v.w) {
              return 0;
          };
          throw new Error("Failed pattern match at Node.FS.Perms line 159, column 8 - line 159, column 26: " + [ v.w.constructor.name ]);
      })() | 0) + (function () {
          if (v.x) {
              return 1;
          };
          if (!v.x) {
              return 0;
          };
          throw new Error("Failed pattern match at Node.FS.Perms line 160, column 8 - line 160, column 26: " + [ v.x.constructor.name ]);
      })() | 0;
  };
  var permToString = function ($95) {
      return Prelude.show(Prelude.showInt)(permToInt($95));
  };
  var permsToString = function (v) {
      return "0" + (permToString(v.u) + (permToString(v.g) + permToString(v.o)));
  };                                    
  var mkPerms = function (u) {
      return function (g) {
          return function (o) {
              return {
                  u: u, 
                  g: g, 
                  o: o
              };
          };
      };
  }; 
  var all = Prelude.one(semiringPerm);
  exports["permsToString"] = permsToString;
  exports["mkPerms"] = mkPerms;
  exports["all"] = all;
  exports["semiringPerm"] = semiringPerm;
})(PS["Node.FS.Perms"] = PS["Node.FS.Perms"] || {});
(function(exports) {
  /* global require */
  /* global exports */
  "use strict";                                  

  exports.statsMethod = function (m, s) {
    return s[m]();
  }
})(PS["Node.FS.Stats"] = PS["Node.FS.Stats"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.FS.Stats"];
  var Prelude = PS["Prelude"];
  var Data_Date = PS["Data.Date"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];        
  var Stats = (function () {
      function Stats(value0) {
          this.value0 = value0;
      };
      Stats.create = function (value0) {
          return new Stats(value0);
      };
      return Stats;
  })();
  var isDirectory = function (v) {
      return $foreign.statsMethod("isDirectory", v.value0);
  };
  exports["Stats"] = Stats;
  exports["isDirectory"] = isDirectory;
})(PS["Node.FS.Stats"] = PS["Node.FS.Stats"] || {});
(function(exports) {
  /* 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) {
  /* 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"];
  exports["unsafeInterleaveEff"] = $foreign.unsafeInterleaveEff;
})(PS["Control.Monad.Eff.Unsafe"] = PS["Control.Monad.Eff.Unsafe"] || {});
(function(exports) {
    "use strict";
  // module Node.FS.Internal

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

  // module Data.Date.Locale

  // jshint maxparams: 2
  exports.dateMethod = function (method, date) {
    return function () {
      return date[method]();
    };
  };
})(PS["Data.Date.Locale"] = PS["Data.Date.Locale"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.Date.Locale"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Date = PS["Data.Date"];
  var Data_Enum = PS["Data.Enum"];
  var Data_Function = PS["Data.Function"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var Data_Time = PS["Data.Time"];
  var Prelude = PS["Prelude"];
  var month = function (d) {
      return Prelude["<$>"](Control_Monad_Eff.functorEff)(function ($0) {
          return Data_Maybe_Unsafe.fromJust(Data_Enum.toEnum(Data_Date.enumMonth)($0));
      })($foreign.dateMethod("getMonth", d));
  };
  exports["month"] = month;
})(PS["Data.Date.Locale"] = PS["Data.Date.Locale"] || {});
(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) {
  /* global exports */
  "use strict";

  exports["regex'"] = function (s1) {
    return function (s2) {
      return new RegExp(s1, s2);
    };
  };

  exports._match = function (just) {
    return function (nothing) {
      return function (r) {
        return function (s) {
          var m = s.match(r);
          if (m == null) {
            return nothing;
          } else {
            var list = [];
            for (var i = 0; i < m.length; i++) {
              list.push(m[i] == null ? nothing : just(m[i]));
            }
            return just(list);
          }
        };
      };
    };
  };
})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Data.String.Regex"];
  var Prelude = PS["Prelude"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_String = PS["Data.String"];                                            
  var renderFlags = function (f) {
      return (function () {
          if (f.global) {
              return "g";
          };
          if (!f.global) {
              return "";
          };
          throw new Error("Failed pattern match at Data.String.Regex line 65, column 4 - line 65, column 32: " + [ f.global.constructor.name ]);
      })() + ((function () {
          if (f.ignoreCase) {
              return "i";
          };
          if (!f.ignoreCase) {
              return "";
          };
          throw new Error("Failed pattern match at Data.String.Regex line 66, column 4 - line 66, column 36: " + [ f.ignoreCase.constructor.name ]);
      })() + ((function () {
          if (f.multiline) {
              return "m";
          };
          if (!f.multiline) {
              return "";
          };
          throw new Error("Failed pattern match at Data.String.Regex line 67, column 4 - line 67, column 35: " + [ f.multiline.constructor.name ]);
      })() + ((function () {
          if (f.sticky) {
              return "y";
          };
          if (!f.sticky) {
              return "";
          };
          throw new Error("Failed pattern match at Data.String.Regex line 68, column 4 - line 68, column 32: " + [ f.sticky.constructor.name ]);
      })() + (function () {
          if (f.unicode) {
              return "u";
          };
          if (!f.unicode) {
              return "";
          };
          throw new Error("Failed pattern match at Data.String.Regex line 69, column 4 - line 69, column 33: " + [ f.unicode.constructor.name ]);
      })())));
  };
  var regex = function (s) {
      return function (f) {
          return $foreign["regex'"](s)(renderFlags(f));
      };
  };
  var noFlags = {
      global: false, 
      ignoreCase: false, 
      multiline: false, 
      sticky: false, 
      unicode: false
  };
  var match = $foreign._match(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  exports["noFlags"] = noFlags;
  exports["match"] = match;
  exports["renderFlags"] = renderFlags;
  exports["regex"] = regex;
})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
(function(exports) {
    "use strict";

  // module Node.OS

  exports.hostname = function(){
    var os = require("os");
    return os.hostname();
  };
})(PS["Node.OS"] = PS["Node.OS"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var $foreign = PS["Node.OS"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  exports["hostname"] = $foreign.hostname;
})(PS["Node.OS"] = PS["Node.OS"] || {});
(function(exports) {
  // Generated by psc version 0.8.5.0
  "use strict";
  var App_Config = PS["App.Config"];
  var App_DB = PS["App.DB"];
  var App_Exec = PS["App.Exec"];
  var App_FS = PS["App.FS"];
  var App_Model_Date = PS["App.Model.Date"];
  var App_Model_Event = PS["App.Model.Event"];
  var App_Model_Statistic = PS["App.Model.Statistic"];
  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 = PS["Control.Monad.Eff"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var Data_Array = PS["Data.Array"];
  var Data_Date = PS["Data.Date"];
  var Data_Date_Locale = PS["Data.Date.Locale"];
  var Data_Either = PS["Data.Either"];
  var Data_Function = PS["Data.Function"];
  var Data_Int_Extended = PS["Data.Int.Extended"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_String_Regex = PS["Data.String.Regex"];
  var Data_Traversable = PS["Data.Traversable"];
  var Database_AnyDB = PS["Database.AnyDB"];
  var Node_Buffer = PS["Node.Buffer"];
  var Node_ChildProcess = PS["Node.ChildProcess"];
  var Node_Encoding = PS["Node.Encoding"];
  var Node_FS = PS["Node.FS"];
  var Node_FS_Aff = PS["Node.FS.Aff"];
  var Node_FS_Stats = PS["Node.FS.Stats"];
  var Node_OS = PS["Node.OS"];
  var Node_Path = PS["Node.Path"];
  var Node_Process = PS["Node.Process"];
  var Prelude = PS["Prelude"];
  var Data_Foreign = PS["Data.Foreign"];        
  var workerConnI = App_DB.networkingConnectionInfo;
  var targetDir = "background_images";
  var startPrograms = function (v) {
      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff.apathize(App_Exec.simpleExecStr("logman start Prints")(Data_Maybe.Nothing.value)(Data_Maybe.Nothing.value)))(function () {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff.apathize(App_Exec.simpleExec("taskkill")(Data_Maybe.Nothing.value)([ "/F", "/IM", v.value0.photoProgramExe ])(Data_Maybe.Nothing.value)))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff["later'"](200)(Prelude.pure(Control_Monad_Aff.applicativeAff)(Prelude.unit)))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(App_Exec.simpleExecStr("start " + v.value0.photoProgramFullPath)(Data_Maybe.Nothing.value)(Data_Maybe.Nothing.value))(function () {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff["later'"](200)(Prelude.pure(Control_Monad_Aff.applicativeAff)(Prelude.unit)))(function () {
                          return Prelude.pure(Control_Monad_Aff.applicativeAff)(Prelude.unit);
                      });
                  });
              });
          });
      });
  };
  var queryWorkerState = "select * from WORKERSTATE";
  var printsdir = "prints";
  var mainPhotosPrintsDir = Node_Path.concat([ "photos", "prints" ]);
  var mainPhotosDir = "photos";
  var logfile = "workerlog.txt";
  var logToFile = function (s) {
      return Prelude[">>="](Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Data_Date.now))(function (n) {
          return Node_FS_Aff.appendTextFile(Node_Encoding.UTF8.value)(logfile)(App_Model_Date.toISOString(n) + (" " + (s + "\n")));
      });
  };
  var lastNumber = Data_String_Regex.regex("\"(\\d+)\"$")(Data_String_Regex.noFlags);
  var readPrintCount = function (fp) {
      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(fp))(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("No printer log files found in " + fp)))(Prelude["return"](Control_Monad_Aff.applicativeAff))(Data_Array.last(v)))(function (v1) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readTextFile(Node_Encoding.UTF8.value)(Node_Path.concat([ fp, v1 ])))(function (v2) {
                  var $38 = Data_String_Regex.match(lastNumber)(v2);
                  if ($38 instanceof Data_Maybe.Nothing) {
                      return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No number found in print log at " + v1));
                  };
                  if ($38 instanceof Data_Maybe.Just) {
                      var $39 = Data_Array["!!"]($38.value0)(1);
                      if ($39 instanceof Data_Maybe.Nothing) {
                          return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No number match found in print log at " + v1));
                      };
                      if ($39 instanceof Data_Maybe.Just && $39.value0 instanceof Data_Maybe.Nothing) {
                          return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No num match found in print log at " + v1));
                      };
                      if ($39 instanceof Data_Maybe.Just && $39.value0 instanceof Data_Maybe.Just) {
                          return Data_Maybe.maybe(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("Couldn't parse " + ($39.value0.value0 + (" in " + v1)))))(Prelude["return"](Control_Monad_Aff.applicativeAff))(Data_Int_Extended.safeParseInt($39.value0.value0));
                      };
                      throw new Error("Failed pattern match at App.Worker line 198, column 10 - line 207, column 1: " + [ $39.constructor.name ]);
                  };
                  throw new Error("Failed pattern match at App.Worker line 195, column 3 - line 207, column 1: " + [ $38.constructor.name ]);
              });
          });
      });
  };
  var killPrograms = function (v) {
      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff.apathize(App_Exec.simpleExec("taskkill")(Data_Maybe.Nothing.value)([ "/F", "/IM", v.value0.photoProgramExe ])(Data_Maybe.Nothing.value)))(function () {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff["later'"](200)(Prelude.pure(Control_Monad_Aff.applicativeAff)(Prelude.unit)))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff.apathize(App_Exec.simpleExecStr("logman stop Prints")(Data_Maybe.Nothing.value)(Data_Maybe.Nothing.value)))(function () {
                  return Prelude.pure(Control_Monad_Aff.applicativeAff)(Prelude.unit);
              });
          });
      });
  };
  var historyFolder = "photoshistory";
  var mkHistoryDirForActive = function (v) {
      if (v instanceof App_Model_WorkerState.DefaultActive) {
          return Node_Path.concat([ historyFolder, "default" ]);
      };
      if (v instanceof App_Model_WorkerState.EventActive) {
          return Node_Path.concat([ historyFolder, "event_" + Prelude.show(Prelude.showInt)(v.value0) ]);
      };
      throw new Error("Failed pattern match at App.Worker line 237, column 1 - line 238, column 1: " + [ v.constructor.name ]);
  };
  var startup = function (conn) {
      return function (cf) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Running initial startup"))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(targetDir))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(App_FS.defaultDir))(function (v) {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(v)(function (f) {
                          return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.readFile(Node_Path.concat([ App_FS.defaultDir, f ])))(App_FS.overWriteFile(Node_Path.concat([ targetDir, Node_Path.basename(f) ])));
                      }))(function () {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(startPrograms(cf))(function () {
                              var newPhotosFolder = mkHistoryDirForActive(App_Model_WorkerState.DefaultActive.value);
                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(newPhotosFolder))(function () {
                                  return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(Node_Path.concat([ newPhotosFolder, "prints" ])))(function () {
                                      return Prelude.bind(Control_Monad_Aff.bindAff)(App_DB.updateWorkerState(conn)(new App_Model_WorkerState.WorkerState({
                                          active: App_Model_WorkerState.DefaultActive.value
                                      })))(function () {
                                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                                      });
                                  });
                              });
                          });
                      });
                  });
              });
          });
      };
  };
  var switchEvents = function (dateNow) {
      return function (conn) {
          return function (cname) {
              return function (old) {
                  return function ($$new) {
                      return function (cf) {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Swapping from " + (Prelude.show(App_Model_WorkerState.showActive)(old) + (" to " + Prelude.show(App_Model_WorkerState.showActive)($$new)))))(function () {
                              var oldPhotosFolder = mkHistoryDirForActive(old);
                              var newPhotosFolder = mkHistoryDirForActive($$new);
                              return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Killing programs"))(function () {
                                  return Prelude.bind(Control_Monad_Aff.bindAff)(killPrograms(cf))(function () {
                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(oldPhotosFolder))(function (v) {
                                          var amountOfPhotosTakenInOld = Data_Array.length(v) - 1;
                                          return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.rmdirRecur(mainPhotosDir))(function () {
                                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(mainPhotosDir))(function () {
                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(Node_Path.concat([ mainPhotosDir, "prints" ])))(function () {
                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(printsdir))(function (v1) {
                                                          var lastprintsdir = Data_Array["!!"](v1)(Data_Array.length(v1) - 1);
                                                          var secondtolastprintsfolders = Data_Array["!!"](v1)(Data_Array.length(v1) - 2);
                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Maybe.maybe(Prelude["return"](Control_Monad_Aff.applicativeAff)(0))(function (d) {
                                                              return readPrintCount(Node_Path.concat([ printsdir, d ]));
                                                          })(secondtolastprintsfolders))(function (v2) {
                                                              return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                                                                  if (lastprintsdir instanceof Data_Maybe.Nothing) {
                                                                      return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No print logs found"));
                                                                  };
                                                                  if (lastprintsdir instanceof Data_Maybe.Just) {
                                                                      return Prelude[">>="](Control_Monad_Aff.bindAff)(readPrintCount(Node_Path.concat([ printsdir, lastprintsdir.value0 ])))(function (c) {
                                                                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(c - v2);
                                                                      });
                                                                  };
                                                                  throw new Error("Failed pattern match at App.Worker line 130, column 17 - line 135, column 3: " + [ lastprintsdir.constructor.name ]);
                                                              })())(function (v3) {
                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Prelude["<$>"](Control_Monad_Eff.functorEff)(App_Model_Statistic.monthToInt)(Data_Date_Locale.month(dateNow))))(function (v4) {
                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                                                                          if (old instanceof App_Model_WorkerState.DefaultActive) {
                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_DB.getMonthlyStatistic(cname)(conn)(v4))(function (v5) {
                                                                                  var q = App_DB.upsertMonthlyStatistic(new App_Model_Statistic.MonthlyStatistic((function () {
                                                                                      var $59 = {};
                                                                                      for (var $60 in v5.value0) {
                                                                                          if (v5.value0.hasOwnProperty($60)) {
                                                                                              $59[$60] = v5.value0[$60];
                                                                                          };
                                                                                      };
                                                                                      $59.pictures = v5.value0.pictures + amountOfPhotosTakenInOld | 0;
                                                                                      $59.prints = v5.value0.prints + v3 | 0;
                                                                                      return $59;
                                                                                  })()));
                                                                                  return Database_AnyDB.execute_(q)(conn);
                                                                              });
                                                                          };
                                                                          if (old instanceof App_Model_WorkerState.EventActive) {
                                                                              var s = new App_Model_Statistic.EventStatistic({
                                                                                  computername: cname, 
                                                                                  eventId: old.value0, 
                                                                                  pictures: amountOfPhotosTakenInOld, 
                                                                                  prints: v3
                                                                              });
                                                                              var q = App_DB.upsertEventStatistic(s);
                                                                              return Database_AnyDB.execute_(q)(conn);
                                                                          };
                                                                          throw new Error("Failed pattern match at App.Worker line 136, column 3 - line 150, column 3: " + [ old.constructor.name ]);
                                                                      })())(function () {
                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Maybe.maybe(Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit))(App_FS.rmdirRecur)(secondtolastprintsfolders))(function () {
                                                                              var sourcedir = (function () {
                                                                                  if ($$new instanceof App_Model_WorkerState.DefaultActive) {
                                                                                      return App_FS.defaultDir;
                                                                                  };
                                                                                  if ($$new instanceof App_Model_WorkerState.EventActive) {
                                                                                      return App_FS.mkEventDir($$new.value0);
                                                                                  };
                                                                                  throw new Error("Failed pattern match at App.Worker line 153, column 19 - line 156, column 3: " + [ $$new.constructor.name ]);
                                                                              })();
                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(sourcedir))(function (v5) {
                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(targetDir))(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff)(function (f) {
                                                                                      return Node_FS_Aff.unlink(Node_Path.concat([ targetDir, Node_Path.basename(f) ]));
                                                                                  })))(function () {
                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(v5)(function (f) {
                                                                                          return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.readFile(Node_Path.concat([ sourcedir, f ])))(App_FS.overWriteFile(Node_Path.concat([ targetDir, Node_Path.basename(f) ])));
                                                                                      }))(function () {
                                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Starting Programs"))(function () {
                                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(startPrograms(cf))(function () {
                                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(newPhotosFolder))(function () {
                                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(Node_Path.concat([ newPhotosFolder, "prints" ])))(function () {
                                                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(App_DB.updateWorkerState(conn)(new App_Model_WorkerState.WorkerState({
                                                                                                              active: $$new
                                                                                                          })))(function () {
                                                                                                              return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                                                                                                          });
                                                                                                      });
                                                                                                  });
                                                                                              });
                                                                                          });
                                                                                      });
                                                                                  });
                                                                              });
                                                                          });
                                                                      });
                                                                  });
                                                              });
                                                          });
                                                      });
                                                  });
                                              });
                                          });
                                      });
                                  });
                              });
                          });
                      };
                  };
              };
          };
      };
  };
  var copyFile = function (start) {
      return function (end) {
          return Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.readFile(start))(Node_FS_Aff.writeFile(end));
      };
  };
  var safeCopyFile = function (start) {
      return function (end) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.exists(end))(function (v) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.stat(start))(function (v1) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(v1.value0.isFile());
              }))(function (v1) {
                  var $71 = !v && v1;
                  if ($71) {
                      return copyFile(start)(end);
                  };
                  if (!$71) {
                      return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                  };
                  throw new Error("Failed pattern match at App.Worker line 230, column 3 - line 233, column 1: " + [ $71.constructor.name ]);
              });
          });
      };
  };
  var main = Control_Monad_Aff.runAff(function (e) {
      var m = Prelude.show(Control_Monad_Eff_Exception.showError)(e) + (Control_Monad_Eff_Exception.message(e) + Data_Maybe.maybe("")(Prelude.id(Prelude.categoryFn))(Control_Monad_Eff_Exception.stack(e)));
      return Control_Apply["*>"](Control_Monad_Eff.applyEff)(Control_Monad_Eff_Console.log(m))(Control_Monad_Aff.runAff(function (v) {
          return Prelude.pure(Control_Monad_Eff.applicativeEff)(Prelude.unit);
      })(function (v) {
          return Prelude.pure(Control_Monad_Eff.applicativeEff)(Prelude.unit);
      })(logToFile(m)));
  })(Prelude["const"](Control_Monad_Eff_Console.log("Worker done!")))(Database_AnyDB.withConnection(workerConnI)(function (conn) {
      return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Started Worker Script"))(function () {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude[">>="](Control_Monad_Aff.bindAff)(Node_FS_Aff.stat(logfile))(function (v) {
              var $75 = v.value0.size > 5.0e7;
              if ($75) {
                  return Node_FS_Aff.unlink(logfile);
              };
              if (!$75) {
                  return Prelude.pure(Control_Monad_Aff.applicativeAff)(Prelude.unit);
              };
              throw new Error("Failed pattern match at App.Worker line 69, column 39 - line 70, column 3: " + [ $75.constructor.name ]);
          }))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Node_OS.hostname))(function (v) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(App_Config.readConfigFile))(function (v1) {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Either.either(function ($104) {
                          return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error(Prelude.show(Data_Foreign.showForeignError)($104)));
                      })(Prelude.pure(Control_Monad_Aff.applicativeAff))(v1))(function (v2) {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(historyFolder))(function () {
                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(mainPhotosDir))(function () {
                                  return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(mainPhotosPrintsDir))(function () {
                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Database_AnyDB.queryOne_(App_Model_WorkerState.foreignWorkerState)(queryWorkerState)(conn))(function (v3) {
                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Data_Maybe.maybe(Prelude[">>="](Control_Monad_Aff.bindAff)(startup(conn)(v2))(function (v4) {
                                              return Prelude.pure(Control_Monad_Aff.applicativeAff)(new App_Model_WorkerState.WorkerState({
                                                  active: App_Model_WorkerState.DefaultActive.value
                                              }));
                                          }))(Prelude["return"](Control_Monad_Aff.applicativeAff))(v3))(function (v4) {
                                              return Prelude.bind(Control_Monad_Aff.bindAff)(logToFile("Worker state: " + Prelude.show(App_Model_WorkerState.showWorkerState)(v4)))(function () {
                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(mainPhotosDir))(function (v5) {
                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Node_FS_Aff.readdir(mainPhotosPrintsDir))(function (v6) {
                                                          var dirToCopyTo = mkHistoryDirForActive(v4.value0.active);
                                                          var printsDirToCopyTo = Node_Path.concat([ dirToCopyTo, "prints" ]);
                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(dirToCopyTo))(function () {
                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_FS.safeMkdir(printsDirToCopyTo))(function () {
                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(v5)(function (f) {
                                                                      return safeCopyFile(Node_Path.concat([ mainPhotosDir, f ]))(Node_Path.concat([ dirToCopyTo, Node_Path.basename(f) ]));
                                                                  }))(function () {
                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Aff.applicativeAff))(v6)(function (f) {
                                                                          return safeCopyFile(Node_Path.concat([ mainPhotosPrintsDir, f ]))(Node_Path.concat([ printsDirToCopyTo, Node_Path.basename(f) ]));
                                                                      }))(function () {
                                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Data_Date.now))(function (v7) {
                                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(App_DB.queryActiveEvent(conn)(v7))(function (v8) {
                                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                                                                                      if (v8 instanceof Data_Maybe.Nothing) {
                                                                                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(App_Model_WorkerState.DefaultActive.value);
                                                                                      };
                                                                                      if (v8 instanceof Data_Maybe.Just && v8.value0.value0.id instanceof Data_Maybe.Nothing) {
                                                                                          return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("No ID in active event"));
                                                                                      };
                                                                                      if (v8 instanceof Data_Maybe.Just && v8.value0.value0.id instanceof Data_Maybe.Just) {
                                                                                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(new App_Model_WorkerState.EventActive(v8.value0.value0.id.value0));
                                                                                      };
                                                                                      throw new Error("Failed pattern match at App.Worker line 94, column 16 - line 98, column 3: " + [ v8.constructor.name ]);
                                                                                  })())(function (v9) {
                                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                                                                                          var $101 = Prelude["/="](App_Model_WorkerState.eqActive)(v9)(v4.value0.active);
                                                                                          if ($101) {
                                                                                              return switchEvents(v7)(conn)(v)(v4.value0.active)(v9)(v2);
                                                                                          };
                                                                                          if (!$101) {
                                                                                              return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                                                                                          };
                                                                                          throw new Error("Failed pattern match at App.Worker line 99, column 34 - line 102, column 3: " + [ $101.constructor.name ]);
                                                                                      })())(function () {
                                                                                          return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
                                                                                      });
                                                                                  });
                                                                              });
                                                                          });
                                                                      });
                                                                  });
                                                              });
                                                          });
                                                      });
                                                  });
                                              });
                                          });
                                      });
                                  });
                              });
                          });
                      });
                  });
              });
          });
      });
  }));
  exports["mkHistoryDirForActive"] = mkHistoryDirForActive;
  exports["copyFile"] = copyFile;
  exports["safeCopyFile"] = safeCopyFile;
  exports["queryWorkerState"] = queryWorkerState;
  exports["startPrograms"] = startPrograms;
  exports["killPrograms"] = killPrograms;
  exports["readPrintCount"] = readPrintCount;
  exports["lastNumber"] = lastNumber;
  exports["startup"] = startup;
  exports["switchEvents"] = switchEvents;
  exports["main"] = main;
  exports["logToFile"] = logToFile;
  exports["logfile"] = logfile;
  exports["workerConnI"] = workerConnI;
  exports["printsdir"] = printsdir;
  exports["targetDir"] = targetDir;
  exports["historyFolder"] = historyFolder;
  exports["mainPhotosPrintsDir"] = mainPhotosPrintsDir;
  exports["mainPhotosDir"] = mainPhotosDir;
})(PS["App.Worker"] = PS["App.Worker"] || {});
PS["App.Worker"].main();