output.js

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

  exports.replicate = function (count) {
    return function (value) {
      var result = [];
      var n = 0;
      for (var i = 0; i < count; i++) {
        result[n++] = value;
      }
      return result;
    };
  };   

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

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

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

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

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

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

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

  exports._deleteAt = function (just) {
    return function (nothing) {
      return function (i) {
        return function (l) {
          if (i < 0 || i >= l.length) return nothing;
          var l1 = l.slice();
          l1.splice(i, 1);
          return just(l1);
        };
      };
    };
  };

  exports._updateAt = function (just) {
    return function (nothing) {
      return function (i) {
        return function (a) {
          return function (l) {
            if (i < 0 || i >= l.length) return nothing;
            var l1 = l.slice();
            l1[i] = a;
            return just(l1);
          };
        };
      };
    };
  };

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

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

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

  //------------------------------------------------------------------------------
  // Partial ---------------------------------------------------------------------
  //------------------------------------------------------------------------------

  exports.unsafeIndexImpl = function (xs) {
    return function (n) {
      return xs[n];
    };
  };
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
    "use strict";

  exports.arrayMap = function (f) {
    return function (arr) {
      var l = arr.length;
      var result = new Array(l);
      for (var i = 0; i < l; i++) {
        result[i] = f(arr[i]);
      }
      return result;
    };
  };
})(PS["Data.Functor"] = PS["Data.Functor"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Semigroupoid = function (compose) {
      this.compose = compose;
  };
  var semigroupoidFn = new Semigroupoid(function (f) {
      return function (g) {
          return function (x) {
              return f(g(x));
          };
      };
  });
  var compose = function (dict) {
      return dict.compose;
  };
  exports["Semigroupoid"] = Semigroupoid;
  exports["compose"] = compose;
  exports["semigroupoidFn"] = semigroupoidFn;
})(PS["Control.Semigroupoid"] = PS["Control.Semigroupoid"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Semigroupoid = PS["Control.Semigroupoid"];        
  var Category = function (__superclass_Control$dotSemigroupoid$dotSemigroupoid_0, id) {
      this["__superclass_Control.Semigroupoid.Semigroupoid_0"] = __superclass_Control$dotSemigroupoid$dotSemigroupoid_0;
      this.id = id;
  };
  var id = function (dict) {
      return dict.id;
  };
  var categoryFn = new Category(function () {
      return Control_Semigroupoid.semigroupoidFn;
  }, function (x) {
      return x;
  });
  exports["Category"] = Category;
  exports["id"] = id;
  exports["categoryFn"] = categoryFn;
})(PS["Control.Category"] = PS["Control.Category"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Category = PS["Control.Category"];
  var $$const = function (a) {
      return function (v) {
          return a;
      };
  };
  exports["const"] = $$const;
})(PS["Data.Function"] = PS["Data.Function"] || {});
(function(exports) {
    "use strict";

  exports.unit = {};
})(PS["Data.Unit"] = PS["Data.Unit"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Show"];     
  var Show = function (show) {
      this.show = show;
  }; 
  var show = function (dict) {
      return dict.show;
  };
  exports["Show"] = Show;
  exports["show"] = show;
})(PS["Data.Show"] = PS["Data.Show"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Unit"];
  var Data_Show = PS["Data.Show"];
  exports["unit"] = $foreign.unit;
})(PS["Data.Unit"] = PS["Data.Unit"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Functor"];
  var Data_Function = PS["Data.Function"];
  var Data_Unit = PS["Data.Unit"];
  var Control_Semigroupoid = PS["Control.Semigroupoid"];        
  var Functor = function (map) {
      this.map = map;
  };
  var map = function (dict) {
      return dict.map;
  };                                                                                             
  var functorArray = new Functor($foreign.arrayMap);
  exports["Functor"] = Functor;
  exports["map"] = map;
  exports["functorArray"] = functorArray;
})(PS["Data.Functor"] = PS["Data.Functor"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Semigroup"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Void = PS["Data.Void"];        
  var Semigroup = function (append) {
      this.append = append;
  };                                                       
  var append = function (dict) {
      return dict.append;
  };
  exports["Semigroup"] = Semigroup;
  exports["append"] = append;
})(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Data_Functor = PS["Data.Functor"];
  var Data_Semigroup = PS["Data.Semigroup"];        
  var Alt = function (__superclass_Data$dotFunctor$dotFunctor_0, alt) {
      this["__superclass_Data.Functor.Functor_0"] = __superclass_Data$dotFunctor$dotFunctor_0;
      this.alt = alt;
  };                                                       
  var alt = function (dict) {
      return dict.alt;
  };
  exports["Alt"] = Alt;
  exports["alt"] = alt;
})(PS["Control.Alt"] = PS["Control.Alt"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Control.Apply"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Function = PS["Data.Function"];
  var Control_Category = PS["Control.Category"];        
  var Apply = function (__superclass_Data$dotFunctor$dotFunctor_0, apply) {
      this["__superclass_Data.Functor.Functor_0"] = __superclass_Data$dotFunctor$dotFunctor_0;
      this.apply = apply;
  };                      
  var apply = function (dict) {
      return dict.apply;
  };
  exports["Apply"] = Apply;
  exports["apply"] = apply;
})(PS["Control.Apply"] = PS["Control.Apply"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Apply = PS["Control.Apply"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Unit = PS["Data.Unit"];        
  var Applicative = function (__superclass_Control$dotApply$dotApply_0, pure) {
      this["__superclass_Control.Apply.Apply_0"] = __superclass_Control$dotApply$dotApply_0;
      this.pure = pure;
  };
  var pure = function (dict) {
      return dict.pure;
  };
  exports["Applicative"] = Applicative;
  exports["pure"] = pure;
})(PS["Control.Applicative"] = PS["Control.Applicative"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Alt = PS["Control.Alt"];
  var Data_Functor = PS["Data.Functor"];        
  var Plus = function (__superclass_Control$dotAlt$dotAlt_0, empty) {
      this["__superclass_Control.Alt.Alt_0"] = __superclass_Control$dotAlt$dotAlt_0;
      this.empty = empty;
  };       
  var empty = function (dict) {
      return dict.empty;
  };
  exports["Plus"] = Plus;
  exports["empty"] = empty;
})(PS["Control.Plus"] = PS["Control.Plus"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Alt = PS["Control.Alt"];
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Functor = PS["Data.Functor"];        
  var Alternative = function (__superclass_Control$dotApplicative$dotApplicative_0, __superclass_Control$dotPlus$dotPlus_1) {
      this["__superclass_Control.Applicative.Applicative_0"] = __superclass_Control$dotApplicative$dotApplicative_0;
      this["__superclass_Control.Plus.Plus_1"] = __superclass_Control$dotPlus$dotPlus_1;
  };
  exports["Alternative"] = Alternative;
})(PS["Control.Alternative"] = PS["Control.Alternative"] || {});
(function(exports) {
    "use strict";

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

  exports.foldlArray = function (f) {
    return function (init) {
      return function (xs) {
        var acc = init;
        var len = xs.length;
        for (var i = 0; i < len; i++) {
          acc = f(acc)(xs[i]);
        }
        return acc;
      };
    };
  };
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Category = PS["Control.Category"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Semigroup = PS["Data.Semigroup"];        
  var Extend = function (__superclass_Data$dotFunctor$dotFunctor_0, extend) {
      this["__superclass_Data.Functor.Functor_0"] = __superclass_Data$dotFunctor$dotFunctor_0;
      this.extend = extend;
  };
  var extend = function (dict) {
      return dict.extend;
  };
  exports["Extend"] = Extend;
  exports["extend"] = extend;
})(PS["Control.Extend"] = PS["Control.Extend"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Control.Bind"];
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Category = PS["Control.Category"];
  var Data_Function = PS["Data.Function"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Unit = PS["Data.Unit"];        
  var Bind = function (__superclass_Control$dotApply$dotApply_0, bind) {
      this["__superclass_Control.Apply.Apply_0"] = __superclass_Control$dotApply$dotApply_0;
      this.bind = bind;
  };                     
  var bind = function (dict) {
      return dict.bind;
  };
  exports["Bind"] = Bind;
  exports["bind"] = bind;
})(PS["Control.Bind"] = PS["Control.Bind"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Bind = PS["Control.Bind"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Unit = PS["Data.Unit"];        
  var Monad = function (__superclass_Control$dotApplicative$dotApplicative_0, __superclass_Control$dotBind$dotBind_1) {
      this["__superclass_Control.Applicative.Applicative_0"] = __superclass_Control$dotApplicative$dotApplicative_0;
      this["__superclass_Control.Bind.Bind_1"] = __superclass_Control$dotBind$dotBind_1;
  };
  exports["Monad"] = Monad;
})(PS["Control.Monad"] = PS["Control.Monad"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Monad = PS["Control.Monad"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Unit = PS["Data.Unit"];        
  var MonadZero = function (__superclass_Control$dotAlternative$dotAlternative_1, __superclass_Control$dotMonad$dotMonad_0) {
      this["__superclass_Control.Alternative.Alternative_1"] = __superclass_Control$dotAlternative$dotAlternative_1;
      this["__superclass_Control.Monad.Monad_0"] = __superclass_Control$dotMonad$dotMonad_0;
  };
  exports["MonadZero"] = MonadZero;
})(PS["Control.MonadZero"] = PS["Control.MonadZero"] || {});
(function(exports) {
    "use strict";

  exports.refEq = function (r1) {
    return function (r2) {
      return r1 === r2;
    };
  };
})(PS["Data.Eq"] = PS["Data.Eq"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Eq"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Void = PS["Data.Void"];        
  var Eq = function (eq) {
      this.eq = eq;
  };
  var Eq1 = function (eq1) {
      this.eq1 = eq1;
  };                                    
  var eqInt = new Eq($foreign.refEq);    
  var eq1 = function (dict) {
      return dict.eq1;
  };
  var eq = function (dict) {
      return dict.eq;
  };
  exports["Eq"] = Eq;
  exports["Eq1"] = Eq1;
  exports["eq"] = eq;
  exports["eq1"] = eq1;
  exports["eqInt"] = eqInt;
})(PS["Data.Eq"] = PS["Data.Eq"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Data_Functor = PS["Data.Functor"];        
  var Invariant = function (imap) {
      this.imap = imap;
  };
  var imapF = function (dictFunctor) {
      return function (f) {
          return function (v) {
              return Data_Functor.map(dictFunctor)(f);
          };
      };
  };                                                             
  var imap = function (dict) {
      return dict.imap;
  };
  exports["Invariant"] = Invariant;
  exports["imap"] = imap;
  exports["imapF"] = imapF;
})(PS["Data.Functor.Invariant"] = PS["Data.Functor.Invariant"] || {});
(function(exports) {
    "use strict";

  exports.unsafeCompareImpl = function (lt) {
    return function (eq) {
      return function (gt) {
        return function (x) {
          return function (y) {
            return x < y ? lt : x === y ? eq : gt;
          };
        };
      };
    };
  };
})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Data_Eq = PS["Data.Eq"];
  var Data_Semigroup = PS["Data.Semigroup"];
  var Data_Show = PS["Data.Show"];        
  var LT = (function () {
      function LT() {

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

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

      };
      EQ.value = new EQ();
      return EQ;
  })();
  exports["LT"] = LT;
  exports["GT"] = GT;
  exports["EQ"] = EQ;
})(PS["Data.Ordering"] = PS["Data.Ordering"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Ord.Unsafe"];
  var Data_Ordering = PS["Data.Ordering"];        
  var unsafeCompare = $foreign.unsafeCompareImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);
  exports["unsafeCompare"] = unsafeCompare;
})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
(function(exports) {
    "use strict";

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

  exports.intMul = function (x) {
    return function (y) {
      /* jshint bitwise: false */
      return x * y | 0;
    };
  };
})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Semiring"];
  var Data_Unit = PS["Data.Unit"];        
  var Semiring = function (add, mul, one, zero) {
      this.add = add;
      this.mul = mul;
      this.one = one;
      this.zero = zero;
  };
  var zero = function (dict) {
      return dict.zero;
  };                                                                            
  var semiringInt = new Semiring($foreign.intAdd, $foreign.intMul, 1, 0);
  var one = function (dict) {
      return dict.one;
  };
  var mul = function (dict) {
      return dict.mul;
  };
  var add = function (dict) {
      return dict.add;
  };
  exports["Semiring"] = Semiring;
  exports["add"] = add;
  exports["mul"] = mul;
  exports["one"] = one;
  exports["zero"] = zero;
  exports["semiringInt"] = semiringInt;
})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Ord"];
  var Data_Eq = PS["Data.Eq"];
  var Data_Function = PS["Data.Function"];
  var Data_Ord_Unsafe = PS["Data.Ord.Unsafe"];
  var Data_Ordering = PS["Data.Ordering"];
  var Data_Ring = PS["Data.Ring"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Void = PS["Data.Void"];
  var Data_Semiring = PS["Data.Semiring"];        
  var Ord = function (__superclass_Data$dotEq$dotEq_0, compare) {
      this["__superclass_Data.Eq.Eq_0"] = __superclass_Data$dotEq$dotEq_0;
      this.compare = compare;
  };
  var Ord1 = function (__superclass_Data$dotEq$dotEq1_0, compare1) {
      this["__superclass_Data.Eq.Eq1_0"] = __superclass_Data$dotEq$dotEq1_0;
      this.compare1 = compare1;
  };                                
  var ordInt = new Ord(function () {
      return Data_Eq.eqInt;
  }, Data_Ord_Unsafe.unsafeCompare);
  var compare1 = function (dict) {
      return dict.compare1;
  };
  var compare = function (dict) {
      return dict.compare;
  };
  var max = function (dictOrd) {
      return function (x) {
          return function (y) {
              var $28 = compare(dictOrd)(x)(y);
              if ($28 instanceof Data_Ordering.LT) {
                  return y;
              };
              if ($28 instanceof Data_Ordering.EQ) {
                  return x;
              };
              if ($28 instanceof Data_Ordering.GT) {
                  return x;
              };
              throw new Error("Failed pattern match at Data.Ord line 123, column 3 - line 126, column 12: " + [ $28.constructor.name ]);
          };
      };
  };
  var min = function (dictOrd) {
      return function (x) {
          return function (y) {
              var $29 = compare(dictOrd)(x)(y);
              if ($29 instanceof Data_Ordering.LT) {
                  return x;
              };
              if ($29 instanceof Data_Ordering.EQ) {
                  return x;
              };
              if ($29 instanceof Data_Ordering.GT) {
                  return y;
              };
              throw new Error("Failed pattern match at Data.Ord line 114, column 3 - line 117, column 12: " + [ $29.constructor.name ]);
          };
      };
  };
  exports["Ord"] = Ord;
  exports["Ord1"] = Ord1;
  exports["compare"] = compare;
  exports["compare1"] = compare1;
  exports["max"] = max;
  exports["min"] = min;
  exports["ordInt"] = ordInt;
})(PS["Data.Ord"] = PS["Data.Ord"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var otherwise = true;
  exports["otherwise"] = otherwise;
})(PS["Data.Boolean"] = PS["Data.Boolean"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Semigroup = PS["Data.Semigroup"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Function = PS["Data.Function"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Eq = PS["Data.Eq"];
  var Data_EuclideanRing = PS["Data.EuclideanRing"];
  var Data_Boolean = PS["Data.Boolean"];        
  var Monoid = function (__superclass_Data$dotSemigroup$dotSemigroup_0, mempty) {
      this["__superclass_Data.Semigroup.Semigroup_0"] = __superclass_Data$dotSemigroup$dotSemigroup_0;
      this.mempty = mempty;
  };       
  var mempty = function (dict) {
      return dict.mempty;
  };
  exports["Monoid"] = Monoid;
  exports["mempty"] = mempty;
})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Bounded"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Ordering = PS["Data.Ordering"];        
  var Bounded = function (__superclass_Data$dotOrd$dotOrd_0, bottom, top) {
      this["__superclass_Data.Ord.Ord_0"] = __superclass_Data$dotOrd$dotOrd_0;
      this.bottom = bottom;
      this.top = top;
  };
  var top = function (dict) {
      return dict.top;
  };              
  var bottom = function (dict) {
      return dict.bottom;
  };
  exports["Bounded"] = Bounded;
  exports["bottom"] = bottom;
  exports["top"] = top;
})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "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_MonadZero = PS["Control.MonadZero"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Eq = PS["Data.Eq"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Functor = PS["Data.Functor"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Monad = PS["Control.Monad"];
  var Data_Semigroup = PS["Data.Semigroup"];
  var Data_Ordering = PS["Data.Ordering"];
  var Data_Bounded = PS["Data.Bounded"];
  var Data_Show = PS["Data.Show"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Function = PS["Data.Function"];
  var Control_Category = PS["Control.Category"];        
  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 showMaybe = function (dictShow) {
      return new Data_Show.Show(function (v) {
          if (v instanceof Just) {
              return "(Just " + (Data_Show.show(dictShow)(v.value0) + ")");
          };
          if (v instanceof Nothing) {
              return "Nothing";
          };
          throw new Error("Failed pattern match at Data.Maybe line 208, column 3 - line 209, column 3: " + [ v.constructor.name ]);
      });
  };
  var semigroupMaybe = function (dictSemigroup) {
      return new Data_Semigroup.Semigroup(function (v) {
          return function (v1) {
              if (v instanceof Nothing) {
                  return v1;
              };
              if (v1 instanceof Nothing) {
                  return v;
              };
              if (v instanceof Just && v1 instanceof Just) {
                  return new Just(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0));
              };
              throw new Error("Failed pattern match at Data.Maybe line 177, column 3 - line 177, column 23: " + [ v.constructor.name, v1.constructor.name ]);
          };
      });
  };
  var monoidMaybe = function (dictSemigroup) {
      return new Data_Monoid.Monoid(function () {
          return semigroupMaybe(dictSemigroup);
      }, Nothing.value);
  };
  var maybe$prime = function (v) {
      return function (v1) {
          return function (v2) {
              if (v2 instanceof Nothing) {
                  return v(Data_Unit.unit);
              };
              if (v2 instanceof Just) {
                  return v1(v2.value0);
              };
              throw new Error("Failed pattern match at Data.Maybe line 233, column 1 - line 233, column 28: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
          };
      };
  };
  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 220, column 1 - line 220, column 22: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
          };
      };
  };
  var isNothing = maybe(true)(Data_Function["const"](false));
  var isJust = maybe(false)(Data_Function["const"](true));
  var functorMaybe = new Data_Functor.Functor(function (v) {
      return function (v1) {
          if (v1 instanceof Just) {
              return new Just(v(v1.value0));
          };
          return Nothing.value;
      };
  });
  var invariantMaybe = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorMaybe));
  var fromMaybe$prime = function (a) {
      return maybe$prime(a)(Control_Category.id(Control_Category.categoryFn));
  };
  var fromMaybe = function (a) {
      return maybe(a)(Control_Category.id(Control_Category.categoryFn));
  };
  var fromJust = function (dictPartial) {
      return function (v) {
          var __unused = function (dictPartial1) {
              return function ($dollar34) {
                  return $dollar34;
              };
          };
          return __unused(dictPartial)((function () {
              if (v instanceof Just) {
                  return v.value0;
              };
              throw new Error("Failed pattern match at Data.Maybe line 271, column 1 - line 271, column 21: " + [ v.constructor.name ]);
          })());
      };
  };
  var extendMaybe = new Control_Extend.Extend(function () {
      return functorMaybe;
  }, function (v) {
      return function (v1) {
          if (v1 instanceof Nothing) {
              return Nothing.value;
          };
          return new Just(v(v1));
      };
  });
  var eqMaybe = function (dictEq) {
      return new Data_Eq.Eq(function (x) {
          return function (y) {
              if (x instanceof Nothing && y instanceof Nothing) {
                  return true;
              };
              if (x instanceof Just && y instanceof Just) {
                  return Data_Eq.eq(dictEq)(x.value0)(y.value0);
              };
              return false;
          };
      });
  };
  var ordMaybe = function (dictOrd) {
      return new Data_Ord.Ord(function () {
          return eqMaybe(dictOrd["__superclass_Data.Eq.Eq_0"]());
      }, function (x) {
          return function (y) {
              if (x instanceof Nothing && y instanceof Nothing) {
                  return Data_Ordering.EQ.value;
              };
              if (x instanceof Nothing) {
                  return Data_Ordering.LT.value;
              };
              if (y instanceof Nothing) {
                  return Data_Ordering.GT.value;
              };
              if (x instanceof Just && y instanceof Just) {
                  return Data_Ord.compare(dictOrd)(x.value0)(y.value0);
              };
              throw new Error("Failed pattern match at Data.Maybe line 196, column 1 - line 196, column 51: " + [ x.constructor.name, y.constructor.name ]);
          };
      });
  };
  var eq1Maybe = new Data_Eq.Eq1(function (dictEq) {
      return Data_Eq.eq(eqMaybe(dictEq));
  });
  var ord1Maybe = new Data_Ord.Ord1(function () {
      return eq1Maybe;
  }, function (dictOrd) {
      return Data_Ord.compare(ordMaybe(dictOrd));
  });
  var boundedMaybe = function (dictBounded) {
      return new Data_Bounded.Bounded(function () {
          return ordMaybe(dictBounded["__superclass_Data.Ord.Ord_0"]());
      }, Nothing.value, new Just(Data_Bounded.top(dictBounded)));
  };
  var applyMaybe = new Control_Apply.Apply(function () {
      return functorMaybe;
  }, function (v) {
      return function (v1) {
          if (v instanceof Just) {
              return Data_Functor.map(functorMaybe)(v.value0)(v1);
          };
          if (v instanceof Nothing) {
              return Nothing.value;
          };
          throw new Error("Failed pattern match at Data.Maybe line 69, column 3 - line 69, column 31: " + [ v.constructor.name, v1.constructor.name ]);
      };
  });
  var bindMaybe = new Control_Bind.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 128, column 3 - line 128, column 24: " + [ v.constructor.name, v1.constructor.name ]);
      };
  });
  var applicativeMaybe = new Control_Applicative.Applicative(function () {
      return applyMaybe;
  }, Just.create);
  var monadMaybe = new Control_Monad.Monad(function () {
      return applicativeMaybe;
  }, function () {
      return bindMaybe;
  });
  var altMaybe = new Control_Alt.Alt(function () {
      return functorMaybe;
  }, function (v) {
      return function (v1) {
          if (v instanceof Nothing) {
              return v1;
          };
          return v;
      };
  });
  var plusMaybe = new Control_Plus.Plus(function () {
      return altMaybe;
  }, Nothing.value);
  var alternativeMaybe = new Control_Alternative.Alternative(function () {
      return applicativeMaybe;
  }, function () {
      return plusMaybe;
  });
  var monadZeroMaybe = new Control_MonadZero.MonadZero(function () {
      return alternativeMaybe;
  }, function () {
      return monadMaybe;
  });
  exports["Nothing"] = Nothing;
  exports["Just"] = Just;
  exports["fromJust"] = fromJust;
  exports["fromMaybe"] = fromMaybe;
  exports["fromMaybe'"] = fromMaybe$prime;
  exports["isJust"] = isJust;
  exports["isNothing"] = isNothing;
  exports["maybe"] = maybe;
  exports["maybe'"] = maybe$prime;
  exports["functorMaybe"] = functorMaybe;
  exports["applyMaybe"] = applyMaybe;
  exports["applicativeMaybe"] = applicativeMaybe;
  exports["altMaybe"] = altMaybe;
  exports["plusMaybe"] = plusMaybe;
  exports["alternativeMaybe"] = alternativeMaybe;
  exports["bindMaybe"] = bindMaybe;
  exports["monadMaybe"] = monadMaybe;
  exports["monadZeroMaybe"] = monadZeroMaybe;
  exports["extendMaybe"] = extendMaybe;
  exports["invariantMaybe"] = invariantMaybe;
  exports["semigroupMaybe"] = semigroupMaybe;
  exports["monoidMaybe"] = monoidMaybe;
  exports["eqMaybe"] = eqMaybe;
  exports["eq1Maybe"] = eq1Maybe;
  exports["ordMaybe"] = ordMaybe;
  exports["ord1Maybe"] = ord1Maybe;
  exports["boundedMaybe"] = boundedMaybe;
  exports["showMaybe"] = showMaybe;
})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.Foldable"];
  var Prelude = PS["Prelude"];
  var Control_Plus = PS["Control.Plus"];
  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 Data_Newtype = PS["Data.Newtype"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Semigroupoid = PS["Control.Semigroupoid"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Applicative = PS["Control.Applicative"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Function = PS["Data.Function"];
  var Control_Category = PS["Control.Category"];
  var Data_Semigroup = PS["Data.Semigroup"];
  var Data_Eq = PS["Data.Eq"];
  var Data_Ordering = PS["Data.Ordering"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Semiring = PS["Data.Semiring"];
  var Data_Functor = PS["Data.Functor"];
  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];        
  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 Data_Semigroup.append(dictMonoid["__superclass_Data.Semigroup.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["foldMap"] = foldMap;
  exports["foldMapDefaultR"] = foldMapDefaultR;
  exports["foldl"] = foldl;
  exports["foldr"] = foldr;
  exports["foldableArray"] = foldableArray;
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
    "use strict";

  // module Partial.Unsafe

  exports.unsafePartial = function (f) {
    return f();
  };
})(PS["Partial.Unsafe"] = PS["Partial.Unsafe"] || {});
(function(exports) {
    "use strict";

  // module Partial

  exports.crashWith = function () {
    return function (msg) {
      throw new Error(msg);
    };
  };
})(PS["Partial"] = PS["Partial"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Partial"];
  exports["crashWith"] = $foreign.crashWith;
})(PS["Partial"] = PS["Partial"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Partial.Unsafe"];
  var Partial = PS["Partial"];        
  var unsafeCrashWith = function (msg) {
      return $foreign.unsafePartial(function (dictPartial) {
          return Partial.crashWith(dictPartial)(msg);
      });
  };
  exports["unsafeCrashWith"] = unsafeCrashWith;
})(PS["Partial.Unsafe"] = PS["Partial.Unsafe"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "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_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
  var Control_Monad_ST = PS["Control.Monad.ST"];
  var Data_Array_ST = PS["Data.Array.ST"];
  var Data_Array_ST_Iterator = PS["Data.Array.ST.Iterator"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_NonEmpty = PS["Data.NonEmpty"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Unfoldable = PS["Data.Unfoldable"];
  var Partial_Unsafe = PS["Partial.Unsafe"];
  var Data_Function = PS["Data.Function"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Semiring = PS["Data.Semiring"];
  var Data_Boolean = PS["Data.Boolean"];
  var Data_Ordering = PS["Data.Ordering"];
  var Data_Ring = PS["Data.Ring"];
  var Data_Eq = PS["Data.Eq"];
  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
  var Control_Apply = PS["Control.Apply"];
  var Data_Functor = PS["Data.Functor"];
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Semigroupoid = PS["Control.Semigroupoid"];
  var Data_Semigroup = PS["Data.Semigroup"];
  var Control_Category = PS["Control.Category"];      
  var updateAt = $foreign._updateAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var unsafeIndex = function (dictPartial) {
      return $foreign.unsafeIndexImpl;
  };
  var tail = $foreign["uncons'"](Data_Function["const"](Data_Maybe.Nothing.value))(function (v) {
      return function (xs) {
          return new Data_Maybe.Just(xs);
      };
  });
  var index = $foreign.indexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  var head = function (xs) {
      return index(xs)(0);
  };
  var deleteAt = $foreign._deleteAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
  exports["deleteAt"] = deleteAt;
  exports["head"] = head;
  exports["index"] = index;
  exports["tail"] = tail;
  exports["unsafeIndex"] = unsafeIndex;
  exports["updateAt"] = updateAt;
  exports["filter"] = $foreign.filter;
  exports["length"] = $foreign.length;
  exports["replicate"] = $foreign.replicate;
  exports["snoc"] = $foreign.snoc;
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
    "use strict";

  exports.toNumber = function (n) {
    return n;
  };
})(PS["Data.Int"] = PS["Data.Int"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "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 Global = PS["Global"];
  var $$Math = PS["Math"];
  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Boolean = PS["Data.Boolean"];
  var Data_Eq = PS["Data.Eq"];
  var Data_Ring = PS["Data.Ring"];
  var Data_Bounded = PS["Data.Bounded"];
  var Control_Semigroupoid = PS["Control.Semigroupoid"];
  exports["toNumber"] = $foreign.toNumber;
})(PS["Data.Int"] = PS["Data.Int"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.empty = {};

  function _collect(f) {
    return function (m) {
      var r = [];
      for (var k in m) {
        if (hasOwnProperty.call(m, k)) {
          r.push(f(k)(m[k]));
        }
      }
      return r;
    };
  }
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var $foreign = PS["Data.StrMap"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Control_Monad_ST = PS["Control.Monad.ST"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
  var Data_List = PS["Data.List"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_StrMap_ST = PS["Data.StrMap.ST"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Unfoldable = PS["Data.Unfoldable"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Function = PS["Data.Function"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Category = PS["Control.Category"];
  var Data_Eq = PS["Data.Eq"];
  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
  var Data_Show = PS["Data.Show"];
  var Data_Semigroup = PS["Data.Semigroup"];
  var Control_Semigroupoid = PS["Control.Semigroupoid"];
  var Data_List_Types = PS["Data.List.Types"];
  var Control_Bind = PS["Control.Bind"];
  exports["empty"] = $foreign.empty;
})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
(function(exports) {
    "use strict";
  var Prelude = PS["Prelude"];
  var Data_Array = PS["Data.Array"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Function = PS["Data.Function"];
  var Control_Apply = PS["Control.Apply"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Applicative = PS["Control.Applicative"];
  var Control_Monad = PS["Control.Monad"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Ring = PS["Data.Ring"];
  var Data_Boolean = PS["Data.Boolean"];
  var Data_EuclideanRing = PS["Data.EuclideanRing"];
  var Data_Semiring = PS["Data.Semiring"];        
  var Random = function (x) {
      return x;
  };
  var runRandom = function (v) {
      return function (seed) {
          return v(seed);
      };
  };

  //showResult :: forall a. Show a => { value :: a, seed :: Seed } -> String

  //showResult r = "(" <> show r.value <> ", " <> show r.seed <> ")"
  var randomFunctor = new Data_Functor.Functor(function (f) {
      return function (v) {
          return Random(function (seed) {
              var result = v(seed);
              var $8 = {};
              for (var $9 in result) {
                  if ({}.hasOwnProperty.call(result, $9)) {
                      $8[$9] = result[$9];
                  };
              };
              $8.value = f(result.value);
              return $8;
          });
      };
  });
  var generate = (function () {
      var abs = function (x) {
          if (x < 0) {
              return -x | 0;
          };
          if (Data_Boolean.otherwise) {
              return x;
          };
          throw new Error("Failed pattern match at Random line 45, column 1 - line 54, column 31: " + [ x.constructor.name ]);
      };
      return Random(function (seed) {
          var $$new = abs(((214013 * seed | 0) + 158188 | 0) % 8388608);
          return {
              value: $$new, 
              seed: $$new
          };
      });
  })();
  var generateInt = function (min) {
      return function (max) {
          return Data_Functor.map(randomFunctor)(function (n) {
              return min + n % (max - min | 0) | 0;
          })(generate);
      };
  };
  var selectOne = function (arr) {
      return Data_Functor.map(randomFunctor)(Data_Array.index(arr))(generateInt(0)(Data_Array.length(arr)));
  };
  var unsafeSelectOne = function (dictPartial) {
      return function (arr) {
          return Data_Functor.map(randomFunctor)(Data_Array.unsafeIndex(dictPartial)(arr))(generateInt(0)(Data_Array.length(arr)));
      };
  };
  var applyRandom = new Control_Apply.Apply(function () {
      return randomFunctor;
  }, function (rf) {
      return function (ra) {
          return Random(function (seed) {
              var f = runRandom(rf)(seed);
              var a = runRandom(ra)(f.seed);
              return {
                  value: f.value(a.value), 
                  seed: a.seed
              };
          });
      };
  });
  var randomApplicative = new Control_Applicative.Applicative(function () {
      return applyRandom;
  }, function (x) {
      return Random(function (seed) {
          return {
              value: x, 
              seed: seed
          };
      });
  });
  var randomBind = new Control_Bind.Bind(function () {
      return applyRandom;
  }, function (a) {
      return function (f) {
          return Random(function (seed) {
              var result = runRandom(a)(seed);
              return runRandom(f(result.value))(result.seed);
          });
      };
  });
  var randomMonad = new Control_Monad.Monad(function () {
      return randomApplicative;
  }, function () {
      return randomBind;
  });
  exports["Random"] = Random;
  exports["generate"] = generate;
  exports["generateInt"] = generateInt;
  exports["runRandom"] = runRandom;
  exports["selectOne"] = selectOne;
  exports["unsafeSelectOne"] = unsafeSelectOne;
  exports["randomFunctor"] = randomFunctor;
  exports["applyRandom"] = applyRandom;
  exports["randomBind"] = randomBind;
  exports["randomApplicative"] = randomApplicative;
  exports["randomMonad"] = randomMonad;
})(PS["Random"] = PS["Random"] || {});
(function(exports) {
    "use strict";
  var Prelude = PS["Prelude"];
  var Data_Array = PS["Data.Array"];
  var Data_Int = PS["Data.Int"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Traversable = PS["Data.Traversable"];
  var Data_StrMap = PS["Data.StrMap"];
  var Random = PS["Random"];
  var Data_Show = PS["Data.Show"];
  var Data_Eq = PS["Data.Eq"];
  var Data_Ring = PS["Data.Ring"];
  var Data_Semiring = PS["Data.Semiring"];
  var Data_Function = PS["Data.Function"];
  var Data_Ord = PS["Data.Ord"];
  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
  var Data_Boolean = PS["Data.Boolean"];
  var Data_Semigroup = PS["Data.Semigroup"];
  var Data_Unit = PS["Data.Unit"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Functor = PS["Data.Functor"];        
  var Axe = (function () {
      function Axe() {

      };
      Axe.value = new Axe();
      return Axe;
  })();
  var Dagger = (function () {
      function Dagger() {

      };
      Dagger.value = new Dagger();
      return Dagger;
  })();
  var Sword = (function () {
      function Sword() {

      };
      Sword.value = new Sword();
      return Sword;
  })();
  var Spear = (function () {
      function Spear() {

      };
      Spear.value = new Spear();
      return Spear;
  })();
  var Halberd = (function () {
      function Halberd() {

      };
      Halberd.value = new Halberd();
      return Halberd;
  })();
  var Common = (function () {
      function Common() {

      };
      Common.value = new Common();
      return Common;
  })();
  var Rusty = (function () {
      function Rusty() {

      };
      Rusty.value = new Rusty();
      return Rusty;
  })();
  var Masterwork = (function () {
      function Masterwork() {

      };
      Masterwork.value = new Masterwork();
      return Masterwork;
  })();
  var Sharp = (function () {
      function Sharp() {

      };
      Sharp.value = new Sharp();
      return Sharp;
  })();
  var DwarvenMine = (function () {
      function DwarvenMine() {

      };
      DwarvenMine.value = new DwarvenMine();
      return DwarvenMine;
  })();
  var GoblinCave = (function () {
      function GoblinCave() {

      };
      GoblinCave.value = new GoblinCave();
      return GoblinCave;
  })();
  var Cave = (function () {
      function Cave() {

      };
      Cave.value = new Cave();
      return Cave;
  })();
  var IceCave = (function () {
      function IceCave() {

      };
      IceCave.value = new IceCave();
      return IceCave;
  })();
  var WizardTower = (function () {
      function WizardTower() {

      };
      WizardTower.value = new WizardTower();
      return WizardTower;
  })();
  var Healing = (function () {
      function Healing() {

      };
      Healing.value = new Healing();
      return Healing;
  })();
  var Warming = (function () {
      function Warming() {

      };
      Warming.value = new Warming();
      return Warming;
  })();
  var Ground = (function () {
      function Ground(value0) {
          this.value0 = value0;
      };
      Ground.create = function (value0) {
          return new Ground(value0);
      };
      return Ground;
  })();
  var Wall = (function () {
      function Wall(value0) {
          this.value0 = value0;
      };
      Wall.create = function (value0) {
          return new Wall(value0);
      };
      return Wall;
  })();
  var Mountain = (function () {
      function Mountain(value0) {
          this.value0 = value0;
      };
      Mountain.create = function (value0) {
          return new Mountain(value0);
      };
      return Mountain;
  })();
  var Forest = (function () {
      function Forest(value0) {
          this.value0 = value0;
      };
      Forest.create = function (value0) {
          return new Forest(value0);
      };
      return Forest;
  })();
  var Water = (function () {
      function Water(value0) {
          this.value0 = value0;
      };
      Water.create = function (value0) {
          return new Water(value0);
      };
      return Water;
  })();
  var Puddle = (function () {
      function Puddle(value0) {
          this.value0 = value0;
      };
      Puddle.create = function (value0) {
          return new Puddle(value0);
      };
      return Puddle;
  })();
  var Door = (function () {
      function Door(value0) {
          this.value0 = value0;
      };
      Door.create = function (value0) {
          return new Door(value0);
      };
      return Door;
  })();
  var River = (function () {
      function River() {

      };
      River.value = new River();
      return River;
  })();
  var StairsUp = (function () {
      function StairsUp() {

      };
      StairsUp.value = new StairsUp();
      return StairsUp;
  })();
  var StairsDown = (function () {
      function StairsDown() {

      };
      StairsDown.value = new StairsDown();
      return StairsDown;
  })();
  var DungeonEntrance = (function () {
      function DungeonEntrance() {

      };
      DungeonEntrance.value = new DungeonEntrance();
      return DungeonEntrance;
  })();
  var Hideout = (function () {
      function Hideout() {

      };
      Hideout.value = new Hideout();
      return Hideout;
  })();
  var Fire = (function () {
      function Fire() {

      };
      Fire.value = new Fire();
      return Fire;
  })();
  var WizardWall = (function () {
      function WizardWall() {

      };
      WizardWall.value = new WizardWall();
      return WizardWall;
  })();
  var ErrorTile = (function () {
      function ErrorTile() {

      };
      ErrorTile.value = new ErrorTile();
      return ErrorTile;
  })();
  var Player = (function () {
      function Player(value0) {
          this.value0 = value0;
      };
      Player.create = function (value0) {
          return new Player(value0);
      };
      return Player;
  })();
  var AlphaWolf = (function () {
      function AlphaWolf() {

      };
      AlphaWolf.value = new AlphaWolf();
      return AlphaWolf;
  })();
  var Wolf = (function () {
      function Wolf() {

      };
      Wolf.value = new Wolf();
      return Wolf;
  })();
  var Bear = (function () {
      function Bear() {

      };
      Bear.value = new Bear();
      return Bear;
  })();
  var Goblin = (function () {
      function Goblin() {

      };
      Goblin.value = new Goblin();
      return Goblin;
  })();
  var Snowman = (function () {
      function Snowman() {

      };
      Snowman.value = new Snowman();
      return Snowman;
  })();
  var IceCorpse = (function () {
      function IceCorpse() {

      };
      IceCorpse.value = new IceCorpse();
      return IceCorpse;
  })();
  var Tim = (function () {
      function Tim() {

      };
      Tim.value = new Tim();
      return Tim;
  })();
  var IceElemental = (function () {
      function IceElemental() {

      };
      IceElemental.value = new IceElemental();
      return IceElemental;
  })();
  var GiantIceElemental = (function () {
      function GiantIceElemental() {

      };
      GiantIceElemental.value = new GiantIceElemental();
      return GiantIceElemental;
  })();
  var DwarfGhost = (function () {
      function DwarfGhost() {

      };
      DwarfGhost.value = new DwarfGhost();
      return DwarfGhost;
  })();
  var Snake = (function () {
      function Snake() {

      };
      Snake.value = new Snake();
      return Snake;
  })();
  var GiantSnake = (function () {
      function GiantSnake() {

      };
      GiantSnake.value = new GiantSnake();
      return GiantSnake;
  })();
  var Bat = (function () {
      function Bat() {

      };
      Bat.value = new Bat();
      return Bat;
  })();
  var Cloak = (function () {
      function Cloak() {

      };
      Cloak.value = new Cloak();
      return Cloak;
  })();
  var Chest = (function () {
      function Chest() {

      };
      Chest.value = new Chest();
      return Chest;
  })();
  var Gloves = (function () {
      function Gloves() {

      };
      Gloves.value = new Gloves();
      return Gloves;
  })();
  var CommonA = (function () {
      function CommonA() {

      };
      CommonA.value = new CommonA();
      return CommonA;
  })();
  var LightA = (function () {
      function LightA() {

      };
      LightA.value = new LightA();
      return LightA;
  })();
  var ThickA = (function () {
      function ThickA() {

      };
      ThickA.value = new ThickA();
      return ThickA;
  })();
  var MasterworkA = (function () {
      function MasterworkA() {

      };
      MasterworkA.value = new MasterworkA();
      return MasterworkA;
  })();
  var Weapon = (function () {
      function Weapon(value0) {
          this.value0 = value0;
      };
      Weapon.create = function (value0) {
          return new Weapon(value0);
      };
      return Weapon;
  })();
  var Armour = (function () {
      function Armour(value0) {
          this.value0 = value0;
      };
      Armour.create = function (value0) {
          return new Armour(value0);
      };
      return Armour;
  })();
  var Potion = (function () {
      function Potion(value0) {
          this.value0 = value0;
      };
      Potion.create = function (value0) {
          return new Potion(value0);
      };
      return Potion;
  })();
  var Wood = (function () {
      function Wood() {

      };
      Wood.value = new Wood();
      return Wood;
  })();
  var Creature = function (x) {
      return x;
  };
  var GameState = function (x) {
      return x;
  };
  var weaponTypeStats = function (v) {
      if (v instanceof Axe) {
          return {
              dmg: 6, 
              hit: -20 | 0, 
              weight: 6
          };
      };
      if (v instanceof Dagger) {
          return {
              dmg: 1, 
              hit: 10, 
              weight: 2
          };
      };
      if (v instanceof Sword) {
          return {
              dmg: 3, 
              hit: 0, 
              weight: 4
          };
      };
      if (v instanceof Spear) {
          return {
              dmg: 2, 
              hit: 10, 
              weight: 3
          };
      };
      if (v instanceof Halberd) {
          return {
              dmg: 4, 
              hit: 0, 
              weight: 5
          };
      };
      throw new Error("Failed pattern match at Rogue line 354, column 1 - line 354, column 60: " + [ v.constructor.name ]);
  };
  var weaponTypeName = function (v) {
      if (v instanceof Axe) {
          return "axe";
      };
      if (v instanceof Dagger) {
          return "dagger";
      };
      if (v instanceof Sword) {
          return "sword";
      };
      if (v instanceof Spear) {
          return "spear";
      };
      if (v instanceof Halberd) {
          return "halberd";
      };
      throw new Error("Failed pattern match at Rogue line 347, column 1 - line 348, column 1: " + [ v.constructor.name ]);
  };
  var weaponPrefixStats = function (v) {
      if (v instanceof Rusty) {
          return {
              dmg: -2 | 0, 
              hit: -5 | 0, 
              weight: -1 | 0
          };
      };
      if (v instanceof Masterwork) {
          return {
              dmg: 4, 
              hit: 10, 
              weight: 0
          };
      };
      if (v instanceof Sharp) {
          return {
              dmg: 2, 
              hit: 5, 
              weight: 0
          };
      };
      return {
          dmg: 0, 
          hit: 0, 
          weight: 0
      };
  };
  var weaponPrefixName = function (v) {
      if (v instanceof Common) {
          return "common";
      };
      if (v instanceof Rusty) {
          return "rusty";
      };
      if (v instanceof Masterwork) {
          return "masterwork";
      };
      if (v instanceof Sharp) {
          return "sharp";
      };
      throw new Error("Failed pattern match at Rogue line 363, column 1 - line 364, column 1: " + [ v.constructor.name ]);
  };
  var weaponHitChance = function (v) {
      if (v instanceof Data_Maybe.Just && v.value0 instanceof Weapon) {
          return (weaponTypeStats(v.value0.value0.weaponType)).hit;
      };
      return 0;
  };
  var weaponDamage = function (v) {
      if (v instanceof Data_Maybe.Just && v.value0 instanceof Weapon) {
          return (weaponPrefixStats(v.value0.value0.prefix)).dmg + (weaponTypeStats(v.value0.value0.weaponType)).dmg | 0;
      };
      return -3 | 0;
  };
  var tileIcon = function (v) {
      if (v instanceof Ground) {
          return ".";
      };
      if (v instanceof Wall) {
          return "#";
      };
      if (v instanceof Mountain) {
          return "^";
      };
      if (v instanceof Forest) {
          return "\x05";
      };
      if (v instanceof Water) {
          return "\xf7";
      };
      if (v instanceof Puddle) {
          if (v.value0.frozen) {
              return "#";
          };
          if (!v.value0.frozen) {
              return ".";
          };
          throw new Error("Failed pattern match at Rogue line 239, column 30 - line 240, column 1: " + [ v.value0.frozen.constructor.name ]);
      };
      if (v instanceof Door) {
          return "+";
      };
      if (v instanceof River) {
          return "~";
      };
      if (v instanceof StairsUp) {
          return "<";
      };
      if (v instanceof StairsDown) {
          return ">";
      };
      if (v instanceof DungeonEntrance) {
          return "o";
      };
      if (v instanceof Hideout) {
          return "O";
      };
      if (v instanceof Fire) {
          return "\x0f";
      };
      if (v instanceof WizardWall) {
          return "#";
      };
      return "?";
  };
  var themeName = function (v) {
      if (v instanceof DwarvenMine) {
          return "abandoned dwarven mines";
      };
      if (v instanceof GoblinCave) {
          return "goblin caves";
      };
      if (v instanceof Cave) {
          return "caves";
      };
      if (v instanceof WizardTower) {
          return "wizard's hideout";
      };
      if (v instanceof IceCave) {
          return "ice caves";
      };
      throw new Error("Failed pattern match at Rogue line 273, column 1 - line 274, column 1: " + [ v.constructor.name ]);
  };
  var showTile = new Data_Show.Show(function (v) {
      if (v instanceof Ground) {
          return "Ground";
      };
      if (v instanceof Wall) {
          return "Wall";
      };
      if (v instanceof Mountain) {
          return "Mountain";
      };
      if (v instanceof Forest) {
          return "Forest";
      };
      if (v instanceof Water) {
          return "Water";
      };
      if (v instanceof Puddle) {
          return "Puddle";
      };
      if (v instanceof Door) {
          return "Door";
      };
      if (v instanceof River) {
          return "River";
      };
      if (v instanceof StairsUp) {
          return "StairsUp";
      };
      if (v instanceof StairsDown) {
          return "StairsDown";
      };
      if (v instanceof DungeonEntrance) {
          return "DungeonEntrance";
      };
      if (v instanceof Hideout) {
          return "Hideout";
      };
      if (v instanceof Fire) {
          return "Fire";
      };
      if (v instanceof WizardWall) {
          return "WizardWall";
      };
      if (v instanceof ErrorTile) {
          return "ErrorTile";
      };
      throw new Error("Failed pattern match at Rogue line 198, column 5 - line 199, column 5: " + [ v.constructor.name ]);
  });
  var showCreature = new Data_Show.Show(function (v) {
      if (v.creatureType instanceof Player) {
          return v.creatureType.value0.name;
      };
      if (v.creatureType instanceof AlphaWolf) {
          return "alpha wolf";
      };
      if (v.creatureType instanceof Wolf) {
          return "wolf";
      };
      if (v.creatureType instanceof Bear) {
          return "bear";
      };
      if (v.creatureType instanceof Goblin) {
          return "goblin";
      };
      if (v.creatureType instanceof Snowman) {
          return "snowman";
      };
      if (v.creatureType instanceof IceCorpse) {
          return "frozen zombie";
      };
      if (v.creatureType instanceof Tim) {
          return "evil wizard";
      };
      if (v.creatureType instanceof IceElemental) {
          return "small ice elemental";
      };
      if (v.creatureType instanceof GiantIceElemental) {
          return "giant ice elemental";
      };
      if (v.creatureType instanceof DwarfGhost) {
          return "dwarf spirit";
      };
      if (v.creatureType instanceof Snake) {
          return "snake";
      };
      if (v.creatureType instanceof GiantSnake) {
          return "giant snake";
      };
      if (v.creatureType instanceof Bat) {
          return "small bat";
      };
      throw new Error("Failed pattern match at Rogue line 78, column 5 - line 78, column 65: " + [ v.constructor.name ]);
  });
  var showArmourType = new Data_Eq.Eq(function (x) {
      return function (y) {
          if (x instanceof Cloak && y instanceof Cloak) {
              return true;
          };
          if (x instanceof Chest && y instanceof Chest) {
              return true;
          };
          if (x instanceof Gloves && y instanceof Gloves) {
              return true;
          };
          return false;
      };
  });

  // creatureBaseDmg :: Creature -> Int

  // creatureBaseDmg (Creature { creatureType: AlphaWolf }) = 2

  // creatureBaseDmg (Creature { creatureType: Bear })      = 3

  // creatureBaseDmg (Creature { creatureType: Snowman })   = 4

  // creatureBaseDmg (Creature { creatureType: Tim })       = 10

  // creatureBaseDmg _                                      = 1
  var setPlayer = function (v) {
      return function (pl) {
          var $140 = {};
          for (var $141 in v) {
              if ({}.hasOwnProperty.call(v, $141)) {
                  $140[$141] = v[$141];
              };
          };
          $140.player = pl;
          return $140;
      };
  };
  var setLevelTile = function (level) {
      return function (t) {
          return function (p) {
              var $143 = {};
              for (var $144 in level) {
                  if ({}.hasOwnProperty.call(level, $144)) {
                      $143[$144] = level[$144];
                  };
              };
              $143.tiles = Data_Maybe.fromMaybe(level.tiles)(Data_Array.updateAt((p.y * level.width | 0) + p.x | 0)(t)(level.tiles));
              return $143;
          };
      };
  };
  var setTile = function (v) {
      return function (t) {
          return function (p) {
              var $149 = {};
              for (var $150 in v) {
                  if ({}.hasOwnProperty.call(v, $150)) {
                      $149[$150] = v[$150];
                  };
              };
              $149.level = setLevelTile(v.level)(t)(p);
              return $149;
          };
      };
  };
  var setExits = function (l) {
      return function (u) {
          return function (d) {
              return {
                  tiles: l.tiles, 
                  width: l.width, 
                  height: l.height, 
                  enemies: l.enemies, 
                  items: l.items, 
                  up: u, 
                  down: d
              };
          };
      };
  };
  var potionName = function (v) {
      if (v instanceof Healing) {
          return "healing potion";
      };
      if (v instanceof Warming) {
          return "liquid fire";
      };
      throw new Error("Failed pattern match at Rogue line 427, column 1 - line 428, column 1: " + [ v.constructor.name ]);
  };
  var potionEffect = function (v) {
      return function (v1) {
          if (v1 instanceof Potion && v1.value0.effect instanceof Healing) {
              var heal = function (v2) {
                  var $159 = {};
                  for (var $160 in v2) {
                      if ({}.hasOwnProperty.call(v2, $160)) {
                          $159[$160] = v2[$160];
                      };
                  };
                  $159.stats = (function () {
                      var $156 = {};
                      for (var $157 in v2.stats) {
                          if ({}.hasOwnProperty.call(v2.stats, $157)) {
                              $156[$157] = v2["stats"][$157];
                          };
                      };
                      $156.hp = Data_Ord.max(Data_Ord.ordInt)(v2.stats.hp + 5 | 0)(v2.stats.hpMax);
                      return $156;
                  })();
                  return $159;
              };
              var $162 = {};
              for (var $163 in v) {
                  if ({}.hasOwnProperty.call(v, $163)) {
                      $162[$163] = v[$163];
                  };
              };
              $162.player = heal(v.player);
              return $162;
          };
          if (v1 instanceof Potion && v1.value0.effect instanceof Warming) {
              var warm = Data_Ord.min(Data_Ord.ordInt)(v.coldStatus - 10 | 0)(0);
              var $167 = {};
              for (var $168 in v) {
                  if ({}.hasOwnProperty.call(v, $168)) {
                      $167[$168] = v[$168];
                  };
              };
              $167.coldStatus = warm;
              return $167;
          };
          return v;
      };
  };
  var pointPlus = function (v) {
      return function (v1) {
          return {
              x: v.x + v1.x | 0, 
              y: v.y + v1.y | 0
          };
      };
  };
  var pointMinus = function (v) {
      return function (v1) {
          return {
              x: v.x - v1.x | 0, 
              y: v.y - v1.y | 0
          };
      };
  };
  var pointEquals = function (v) {
      return function (v1) {
          return v.x === v1.x && v.y === v1.y;
      };
  };
  var min$prime = function (x) {
      return function (y) {
          if (x < y) {
              return x;
          };
          if (Data_Boolean.otherwise) {
              return y;
          };
          throw new Error("Failed pattern match at Rogue line 497, column 1 - line 499, column 20: " + [ x.constructor.name, y.constructor.name ]);
      };
  };
  var max$prime = function (x) {
      return function (y) {
          if (x > y) {
              return x;
          };
          if (Data_Boolean.otherwise) {
              return y;
          };
          throw new Error("Failed pattern match at Rogue line 502, column 1 - line 504, column 20: " + [ x.constructor.name, y.constructor.name ]);
      };
  };
  var itemIcon = function (v) {
      if (v instanceof Weapon) {
          return "/";
      };
      if (v instanceof Armour) {
          return "[";
      };
      if (v instanceof Potion) {
          return "\xad";
      };
      return "=";
  };
  var itemColor = function (v) {
      if (v instanceof Weapon) {
          return "rgba(102, 102, 153, 0.6)";
      };
      if (v instanceof Armour) {
          return "rgba(102, 102, 143, 0.6)";
      };
      if (v instanceof Potion && v.value0.effect instanceof Healing) {
          return "rgba(0, 102, 0, 0.6)";
      };
      if (v instanceof Potion && v.value0.effect instanceof Warming) {
          return "rgba(255, 0, 0, 0.6)";
      };
      return "rgba(102, 51, 0, 0.6)";
  };
  var isWeapon = function (v) {
      if (v instanceof Weapon) {
          return true;
      };
      return false;
  };
  var isTileTransparent = function (v) {
      if (v instanceof Wall) {
          return false;
      };
      if (v instanceof Mountain) {
          return false;
      };
      if (v instanceof Forest) {
          return false;
      };
      if (v instanceof WizardWall) {
          return false;
      };
      return true;
  };
  var isTileSolid = function (v) {
      if (v instanceof Ground) {
          return false;
      };
      if (v instanceof Forest) {
          return false;
      };
      if (v instanceof Water) {
          return !v.value0.frozen;
      };
      if (v instanceof Puddle) {
          return v.value0.frozen;
      };
      if (v instanceof DungeonEntrance) {
          return false;
      };
      if (v instanceof Hideout) {
          return false;
      };
      if (v instanceof StairsUp) {
          return false;
      };
      if (v instanceof StairsDown) {
          return false;
      };
      if (v instanceof Fire) {
          return false;
      };
      return true;
  };
  var isPlayer = function (v) {
      if (v.creatureType instanceof Player) {
          return true;
      };
      return false;
  };
  var isCorrectArmour = function (v) {
      return function (v1) {
          return function (v2) {
              if (v1 instanceof Cloak && v2 === 1) {
                  return new Data_Maybe.Just(v);
              };
              if (v1 instanceof Chest && v2 === 2) {
                  return new Data_Maybe.Just(v);
              };
              if (v1 instanceof Gloves && v2 === 3) {
                  return new Data_Maybe.Just(v);
              };
              return Data_Maybe.Nothing.value;
          };
      };
  };
  var isArmourOfType = function (v) {
      return function (v1) {
          if (v instanceof Armour) {
              return Data_Eq.eq(showArmourType)(v.value0.armourType)(v1);
          };
          return false;
      };
  };
  var getPlayer = function (v) {
      return v.player;
  };
  var getLevelTile = function (level) {
      return function (p) {
          return Data_Maybe.fromMaybe(ErrorTile.value)(Data_Array.index(level.tiles)((p.y * level.width | 0) + p.x | 0));
      };
  };
  var getTile = function (v) {
      return function (p) {
          return getLevelTile(v.level)(p);
      };
  };
  var frozenColor = function (v) {
      if (v.frozen) {
          return "0.1)";
      };
      if (!v.frozen) {
          return "0.6)";
      };
      throw new Error("Failed pattern match at Rogue line 251, column 1 - line 252, column 1: " + [ v.constructor.name ]);
  };
  var tileColor = function (v) {
      if (v instanceof Ground) {
          return "rgba(139, 69, 19, " + frozenColor(v.value0);
      };
      if (v instanceof Wall) {
          return "rgba(120, 120, 120, " + frozenColor(v.value0);
      };
      if (v instanceof Mountain) {
          return "rgba(70, 70, 70, " + frozenColor(v.value0);
      };
      if (v instanceof Forest) {
          return "rgba(20, 240, 30, " + frozenColor(v.value0);
      };
      if (v instanceof Water) {
          return "rgba(10, 10, 125, " + frozenColor(v.value0);
      };
      if (v instanceof Puddle) {
          return "rgba(20, 20, 250, " + frozenColor(v.value0);
      };
      if (v instanceof Door) {
          return "rgba(200, 180, 50, " + frozenColor(v.value0);
      };
      if (v instanceof River) {
          return "rgba(10, 10, 125, 0.6)";
      };
      if (v instanceof Hideout) {
          return "rgba(100, 50, 125, 0.6)";
      };
      if (v instanceof Fire) {
          return "rgba(250, 70, 30, 0.9)";
      };
      if (v instanceof WizardWall) {
          return "rgba(155, 35, 151, 0.5)";
      };
      return "rgba(120, 120, 120, 0.6)";
  };

  // Just equips a new item, if the item corresponds with correct 'slot'
  var equip = function (v) {
      return function (v1) {
          return function (v2) {
              if (v1 instanceof Armour && v2 === 1) {
                  var $245 = {};
                  for (var $246 in v) {
                      if ({}.hasOwnProperty.call(v, $246)) {
                          $245[$246] = v[$246];
                      };
                  };
                  $245.equipment = (function () {
                      var $242 = {};
                      for (var $243 in v.equipment) {
                          if ({}.hasOwnProperty.call(v.equipment, $243)) {
                              $242[$243] = v["equipment"][$243];
                          };
                      };
                      $242.cloak = isCorrectArmour(new Armour(v1.value0))(v1.value0.armourType)(1);
                      return $242;
                  })();
                  return $245;
              };
              if (v1 instanceof Armour && v2 === 2) {
                  var $252 = {};
                  for (var $253 in v) {
                      if ({}.hasOwnProperty.call(v, $253)) {
                          $252[$253] = v[$253];
                      };
                  };
                  $252.equipment = (function () {
                      var $249 = {};
                      for (var $250 in v.equipment) {
                          if ({}.hasOwnProperty.call(v.equipment, $250)) {
                              $249[$250] = v["equipment"][$250];
                          };
                      };
                      $249.chest = isCorrectArmour(new Armour(v1.value0))(v1.value0.armourType)(2);
                      return $249;
                  })();
                  return $252;
              };
              if (v1 instanceof Armour && v2 === 3) {
                  var $259 = {};
                  for (var $260 in v) {
                      if ({}.hasOwnProperty.call(v, $260)) {
                          $259[$260] = v[$260];
                      };
                  };
                  $259.equipment = (function () {
                      var $256 = {};
                      for (var $257 in v.equipment) {
                          if ({}.hasOwnProperty.call(v.equipment, $257)) {
                              $256[$257] = v["equipment"][$257];
                          };
                      };
                      $256.hands = isCorrectArmour(new Armour(v1.value0))(v1.value0.armourType)(3);
                      return $256;
                  })();
                  return $259;
              };
              if (v2 === 4) {
                  var $266 = {};
                  for (var $267 in v) {
                      if ({}.hasOwnProperty.call(v, $267)) {
                          $266[$267] = v[$267];
                      };
                  };
                  $266.equipment = (function () {
                      var $263 = {};
                      for (var $264 in v.equipment) {
                          if ({}.hasOwnProperty.call(v.equipment, $264)) {
                              $263[$264] = v["equipment"][$264];
                          };
                      };
                      $263.weapon = new Data_Maybe.Just(v1);
                      return $263;
                  })();
                  return $266;
              };
              return v;
          };
      };
  };
  var eqTheme = new Data_Eq.Eq(function (x) {
      return function (y) {
          if (x instanceof DwarvenMine && y instanceof DwarvenMine) {
              return true;
          };
          if (x instanceof GoblinCave && y instanceof GoblinCave) {
              return true;
          };
          if (x instanceof Cave && y instanceof Cave) {
              return true;
          };
          if (x instanceof IceCave && y instanceof IceCave) {
              return true;
          };
          if (x instanceof WizardTower && y instanceof WizardTower) {
              return true;
          };
          return false;
      };
  });
  var dmg = function (v) {
      return function (v1) {
          if (v1 instanceof Data_Maybe.Just && v1.value0 instanceof Weapon) {
              var maxDam = v.stats.str + weaponDamage(new Data_Maybe.Just(v1.value0)) | 0;
              return Random.generateInt(0)(maxDam);
          };
          return Random.generateInt(0)(v.stats.str);
      };
  };
  var deleteItem = function (v) {
      return function (i) {
          var $277 = {};
          for (var $278 in v) {
              if ({}.hasOwnProperty.call(v, $278)) {
                  $277[$278] = v[$278];
              };
          };
          $277.inv = Data_Maybe.fromMaybe(v.inv)(Data_Array.deleteAt(i)(v.inv));
          return $277;
      };
  };
  var defaultStats = function (v) {
      return {
          hpMax: 50, 
          hp: 50, 
          str: 6, 
          dex: 10, 
          "int": 10
      };
  };
  var defaultArmourStats = {
      ap: 0, 
      cr: 0, 
      weight: 0
  };
  var creatureTypeStats = function (v) {
      if (v instanceof AlphaWolf) {
          return {
              hpMax: 12, 
              hp: 12, 
              str: 12, 
              dex: 12, 
              "int": 9
          };
      };
      if (v instanceof Wolf) {
          return {
              hpMax: 8, 
              hp: 8, 
              str: 7, 
              dex: 10, 
              "int": 9
          };
      };
      if (v instanceof Bear) {
          return {
              hpMax: 18, 
              hp: 18, 
              str: 12, 
              dex: 6, 
              "int": 9
          };
      };
      if (v instanceof Goblin) {
          return {
              hpMax: 6, 
              hp: 6, 
              str: 6, 
              dex: 8, 
              "int": 8
          };
      };
      if (v instanceof Snowman) {
          return {
              hpMax: 10, 
              hp: 10, 
              str: 14, 
              dex: 6, 
              "int": 9
          };
      };
      if (v instanceof IceCorpse) {
          return {
              hpMax: 6, 
              hp: 6, 
              str: 8, 
              dex: 5, 
              "int": 9
          };
      };
      if (v instanceof Tim) {
          return {
              hpMax: 20, 
              hp: 20, 
              str: 16, 
              dex: 10, 
              "int": 50
          };
      };
      if (v instanceof IceElemental) {
          return {
              hpMax: 10, 
              hp: 10, 
              str: 8, 
              dex: 10, 
              "int": 10
          };
      };
      if (v instanceof GiantIceElemental) {
          return {
              hpMax: 15, 
              hp: 15, 
              str: 14, 
              dex: 10, 
              "int": 10
          };
      };
      if (v instanceof Snake) {
          return {
              hpMax: 6, 
              hp: 6, 
              str: 6, 
              dex: 13, 
              "int": 10
          };
      };
      if (v instanceof GiantSnake) {
          return {
              hpMax: 12, 
              hp: 12, 
              str: 10, 
              dex: 9, 
              "int": 10
          };
      };
      if (v instanceof DwarfGhost) {
          return {
              hpMax: 8, 
              hp: 8, 
              str: 8, 
              dex: 8, 
              "int": 10
          };
      };
      if (v instanceof Bat) {
          return {
              hpMax: 4, 
              hp: 4, 
              str: 4, 
              dex: 13, 
              "int": 10
          };
      };
      if (v instanceof Player) {
          return {
              hpMax: 12, 
              hp: 12, 
              str: 12, 
              dex: 10, 
              "int": 10
          };
      };
      throw new Error("Failed pattern match at Rogue line 133, column 1 - line 133, column 87: " + [ v.constructor.name ]);
  };
  var creatureSpeed = function (v) {
      return Data_Int.toNumber(300 - (v.stats.dex * 10 | 0) | 0);
  };
  var creatureIcon = function (v) {
      if (v.creatureType instanceof Player) {
          return "@";
      };
      if (v.creatureType instanceof AlphaWolf) {
          return "W";
      };
      if (v.creatureType instanceof Wolf) {
          return "w";
      };
      if (v.creatureType instanceof Bear) {
          return "B";
      };
      if (v.creatureType instanceof Goblin) {
          return "g";
      };
      if (v.creatureType instanceof Snowman) {
          return "\xea";
      };
      if (v.creatureType instanceof IceCorpse) {
          return "Z";
      };
      if (v.creatureType instanceof Tim) {
          return "\x8f";
      };
      if (v.creatureType instanceof IceElemental) {
          return "\xa4";
      };
      if (v.creatureType instanceof GiantIceElemental) {
          return "\xa5";
      };
      if (v.creatureType instanceof DwarfGhost) {
          return "\x02";
      };
      if (v.creatureType instanceof Snake) {
          return "s";
      };
      if (v.creatureType instanceof GiantSnake) {
          return "S";
      };
      if (v.creatureType instanceof Bat) {
          return "b";
      };
      throw new Error("Failed pattern match at Rogue line 100, column 1 - line 101, column 1: " + [ v.constructor.name ]);
  };
  var creatureHitChance = function (v) {
      return function (v1) {
          if (v1.creatureType instanceof Player) {
              return (40 + (v1.stats.dex * 2 | 0) | 0) + weaponHitChance(v.equipment.weapon) | 0;
          };
          return 40 + (v1.stats.dex * 2 | 0) | 0;
      };
  };
  var creatureColor = function (v) {
      if (v.creatureType instanceof Player) {
          return "rgba(0, 200, 0, 0.6)";
      };
      if (v.creatureType instanceof AlphaWolf) {
          return "rgba(200, 200, 200, 0.6)";
      };
      if (v.creatureType instanceof Wolf) {
          return "rgba(100, 100, 100, 0.6)";
      };
      if (v.creatureType instanceof Bear) {
          return "rgba(156, 98, 66, 0.6)";
      };
      if (v.creatureType instanceof Goblin) {
          return "rgba(30, 150, 0, 0.6)";
      };
      if (v.creatureType instanceof Snowman) {
          return "rgba(200, 200, 200, 0.6)";
      };
      if (v.creatureType instanceof IceCorpse) {
          return "rgba(126, 121, 196, 0.6)";
      };
      if (v.creatureType instanceof Tim) {
          return "rgba(245, 65, 241, 0.6)";
      };
      if (v.creatureType instanceof IceElemental) {
          return "rgba(250, 250, 250, 0.2)";
      };
      if (v.creatureType instanceof GiantIceElemental) {
          return "rgba(250, 250, 250, 0.2)";
      };
      if (v.creatureType instanceof DwarfGhost) {
          return "rgba(100, 100, 100, 0.5)";
      };
      if (v.creatureType instanceof Snake) {
          return "rgba(0, 120, 0, 0.6)";
      };
      if (v.creatureType instanceof GiantSnake) {
          return "rgba(0, 120, 0, 0.6)";
      };
      if (v.creatureType instanceof Bat) {
          return "rgba(120, 120, 120, 0.6)";
      };
      throw new Error("Failed pattern match at Rogue line 117, column 1 - line 118, column 1: " + [ v.constructor.name ]);
  };
  var createWizard = function (v) {
      return {
          creatureType: Tim.value, 
          stats: {
              hpMax: 20, 
              hp: 20, 
              str: 10, 
              dex: 10, 
              "int": 10
          }, 
          inv: [  ], 
          pos: {
              x: 0, 
              y: 0
          }, 
          time: 0.0
      };
  };
  var createLevel = function (x) {
      return function (y) {
          return function (t) {
              var zero = {
                  x: 0, 
                  y: 0
              };
              return {
                  tiles: Data_Array.replicate(x * y | 0)(t), 
                  width: x, 
                  height: y, 
                  enemies: Data_StrMap.empty, 
                  items: [  ], 
                  up: zero, 
                  down: zero
              };
          };
      };
  };
  var initialGameState = function (v) {
      return {
          level: createLevel(75)(25)(new Ground({
              frozen: false
          })), 
          player: {
              creatureType: new Player({
                  name: "Frozty"
              }), 
              pos: {
                  x: 0, 
                  y: 11
              }, 
              stats: defaultStats(Data_Unit.unit), 
              inv: [ Wood.value, Wood.value, new Armour({
                  armourType: Cloak.value, 
                  prefix: CommonA.value
              }), new Weapon({
                  weaponType: Dagger.value, 
                  prefix: Rusty.value
              }) ], 
              time: 0.0
          }, 
          coldStatus: 0, 
          coldStep: 0, 
          maxEnc: 70, 
          equipment: {
              cloak: Data_Maybe.Nothing.value, 
              chest: Data_Maybe.Nothing.value, 
              hands: Data_Maybe.Nothing.value, 
              weapon: Data_Maybe.Nothing.value
          }
      };
  };
  var armourTypeStats = function (v) {
      if (v instanceof Cloak) {
          return {
              ap: 1, 
              cr: 5, 
              weight: 8
          };
      };
      if (v instanceof Gloves) {
          return {
              ap: 0, 
              cr: 2, 
              weight: 2
          };
      };
      if (v instanceof Chest) {
          return {
              ap: 2, 
              cr: 4, 
              weight: 6
          };
      };
      throw new Error("Failed pattern match at Rogue line 396, column 1 - line 396, column 53: " + [ v.constructor.name ]);
  };
  var armourTypeName = function (v) {
      if (v instanceof Cloak) {
          return "cloak";
      };
      if (v instanceof Gloves) {
          return "gloves";
      };
      if (v instanceof Chest) {
          return "coat";
      };
      throw new Error("Failed pattern match at Rogue line 317, column 1 - line 318, column 1: " + [ v.constructor.name ]);
  };
  var armourPrefixStats = function (v) {
      if (v instanceof LightA) {
          return {
              ap: 0, 
              cr: 0, 
              weight: -3 | 0
          };
      };
      if (v instanceof ThickA) {
          return {
              ap: 1, 
              cr: 3, 
              weight: 4
          };
      };
      if (v instanceof MasterworkA) {
          return {
              ap: 3, 
              cr: 1, 
              weight: 1
          };
      };
      return {
          ap: 0, 
          cr: 0, 
          weight: 0
      };
  };
  var itemWeight = function (v) {
      if (v instanceof Weapon) {
          return max$prime(1)((weaponTypeStats(v.value0.weaponType)).weight + (weaponPrefixStats(v.value0.prefix)).weight | 0);
      };
      if (v instanceof Armour) {
          return max$prime(1)((armourTypeStats(v.value0.armourType)).weight + (armourPrefixStats(v.value0.prefix)).weight | 0);
      };
      if (v instanceof Potion) {
          return 1;
      };
      if (v instanceof Wood) {
          return 5;
      };
      throw new Error("Failed pattern match at Rogue line 443, column 1 - line 443, column 113: " + [ v.constructor.name ]);
  };
  var totalEnc = function (v) {
      var weapon = Data_Maybe.maybe(0)(itemWeight)(v.equipment.weapon);
      var inv = Data_Foldable.foldl(Data_Foldable.foldableArray)(Data_Semiring.add(Data_Semiring.semiringInt))(0)(Data_Functor.map(Data_Functor.functorArray)(itemWeight)(v.player.inv));
      var hands = Data_Maybe.maybe(0)(itemWeight)(v.equipment.hands);
      var cloak = Data_Maybe.maybe(0)(itemWeight)(v.equipment.cloak);
      var chest = Data_Maybe.maybe(0)(itemWeight)(v.equipment.chest);
      return (((cloak + chest | 0) + hands | 0) + weapon | 0) + inv | 0;
  };
  var armourPrefixName = function (v) {
      if (v instanceof CommonA) {
          return "common";
      };
      if (v instanceof LightA) {
          return "light";
      };
      if (v instanceof ThickA) {
          return "thick";
      };
      if (v instanceof MasterworkA) {
          return "masterwork";
      };
      throw new Error("Failed pattern match at Rogue line 403, column 1 - line 404, column 1: " + [ v.constructor.name ]);
  };
  var itemName = function (v) {
      if (v instanceof Weapon) {
          return weaponPrefixName(v.value0.prefix) + (" " + weaponTypeName(v.value0.weaponType));
      };
      if (v instanceof Armour) {
          return armourPrefixName(v.value0.prefix) + (" " + armourTypeName(v.value0.armourType));
      };
      if (v instanceof Potion) {
          return potionName(v.value0.effect);
      };
      if (v instanceof Wood) {
          return "wood";
      };
      throw new Error("Failed pattern match at Rogue line 322, column 1 - line 322, column 86: " + [ v.constructor.name ]);
  };
  var addStats = function (a) {
      return function (b) {
          return {
              hpMax: a.hpMax + b.hpMax | 0, 
              hp: a.hp + b.hp | 0, 
              str: a.str + b.str | 0, 
              dex: a.dex + b.dex | 0, 
              "int": a["int"] + b["int"] | 0
          };
      };
  };
  var addItem = function (v) {
      return function (v1) {
          if (v1 instanceof Data_Maybe.Just) {
              var $335 = {};
              for (var $336 in v) {
                  if ({}.hasOwnProperty.call(v, $336)) {
                      $335[$336] = v[$336];
                  };
              };
              $335.inv = Data_Array.snoc(v.inv)(v1.value0);
              return $335;
          };
          return v;
      };
  };
  var unEquip = function (v) {
      return function (v1) {
          if (v1 === 1) {
              var $344 = {};
              for (var $345 in v) {
                  if ({}.hasOwnProperty.call(v, $345)) {
                      $344[$345] = v[$345];
                  };
              };
              $344.equipment = (function () {
                  var $341 = {};
                  for (var $342 in v.equipment) {
                      if ({}.hasOwnProperty.call(v.equipment, $342)) {
                          $341[$342] = v["equipment"][$342];
                      };
                  };
                  $341.cloak = Data_Maybe.Nothing.value;
                  return $341;
              })();
              $344.player = addItem(v.player)(v.equipment.cloak);
              return $344;
          };
          if (v1 === 2) {
              var $350 = {};
              for (var $351 in v) {
                  if ({}.hasOwnProperty.call(v, $351)) {
                      $350[$351] = v[$351];
                  };
              };
              $350.equipment = (function () {
                  var $347 = {};
                  for (var $348 in v.equipment) {
                      if ({}.hasOwnProperty.call(v.equipment, $348)) {
                          $347[$348] = v["equipment"][$348];
                      };
                  };
                  $347.chest = Data_Maybe.Nothing.value;
                  return $347;
              })();
              $350.player = addItem(v.player)(v.equipment.chest);
              return $350;
          };
          if (v1 === 3) {
              var $356 = {};
              for (var $357 in v) {
                  if ({}.hasOwnProperty.call(v, $357)) {
                      $356[$357] = v[$357];
                  };
              };
              $356.equipment = (function () {
                  var $353 = {};
                  for (var $354 in v.equipment) {
                      if ({}.hasOwnProperty.call(v.equipment, $354)) {
                          $353[$354] = v["equipment"][$354];
                      };
                  };
                  $353.hands = Data_Maybe.Nothing.value;
                  return $353;
              })();
              $356.player = addItem(v.player)(v.equipment.hands);
              return $356;
          };
          if (v1 === 4) {
              var $362 = {};
              for (var $363 in v) {
                  if ({}.hasOwnProperty.call(v, $363)) {
                      $362[$363] = v[$363];
                  };
              };
              $362.equipment = (function () {
                  var $359 = {};
                  for (var $360 in v.equipment) {
                      if ({}.hasOwnProperty.call(v.equipment, $360)) {
                          $359[$360] = v["equipment"][$360];
                      };
                  };
                  $359.weapon = Data_Maybe.Nothing.value;
                  return $359;
              })();
              $362.player = addItem(v.player)(v.equipment.weapon);
              return $362;
          };
          return v;
      };
  };
  var addArmourStats = function (a) {
      return function (b) {
          return {
              ap: a.ap + b.ap | 0, 
              cr: a.cr + b.cr | 0, 
              weight: a.weight + b.weight | 0
          };
      };
  };
  var armourStats = function (v) {
      if (v instanceof Armour) {
          return addArmourStats(armourTypeStats(v.value0.armourType))(armourPrefixStats(v.value0.prefix));
      };
      return defaultArmourStats;
  };
  var playerArmour = function (v) {
      return ((armourStats(Data_Maybe.fromMaybe(Wood.value)(v.equipment.cloak))).ap + (armourStats(Data_Maybe.fromMaybe(Wood.value)(v.equipment.chest))).ap | 0) + (armourStats(Data_Maybe.fromMaybe(Wood.value)(v.equipment.hands))).ap | 0;
  };
  var attack = function (seed) {
      return function (v) {
          return function (v1) {
              return function (v2) {
                  if (v1.creatureType instanceof Player) {
                      var d = (Random.runRandom(dmg(v1)(v.equipment.weapon))(seed)).value;
                      var $375 = {};
                      for (var $376 in v2) {
                          if ({}.hasOwnProperty.call(v2, $376)) {
                              $375[$376] = v2[$376];
                          };
                      };
                      $375.stats = (function () {
                          var $372 = {};
                          for (var $373 in v2.stats) {
                              if ({}.hasOwnProperty.call(v2.stats, $373)) {
                                  $372[$373] = v2["stats"][$373];
                              };
                          };
                          $372.hp = v2.stats.hp - d | 0;
                          return $372;
                      })();
                      return $375;
                  };
                  if (v2.creatureType instanceof Player) {
                      var d = max$prime(0)((Random.runRandom(dmg(v1)(Data_Maybe.Nothing.value))(seed)).value - playerArmour(v) | 0);
                      var $383 = {};
                      for (var $384 in v2) {
                          if ({}.hasOwnProperty.call(v2, $384)) {
                              $383[$384] = v2[$384];
                          };
                      };
                      $383.stats = (function () {
                          var $380 = {};
                          for (var $381 in v2.stats) {
                              if ({}.hasOwnProperty.call(v2.stats, $381)) {
                                  $380[$381] = v2["stats"][$381];
                              };
                          };
                          $380.hp = v2.stats.hp - d | 0;
                          return $380;
                      })();
                      return $383;
                  };
                  var d = (Random.runRandom(dmg(v1)(Data_Maybe.Nothing.value))(seed)).value;
                  var $391 = {};
                  for (var $392 in v2) {
                      if ({}.hasOwnProperty.call(v2, $392)) {
                          $391[$392] = v2[$392];
                      };
                  };
                  $391.stats = (function () {
                      var $388 = {};
                      for (var $389 in v2.stats) {
                          if ({}.hasOwnProperty.call(v2.stats, $389)) {
                              $388[$389] = v2["stats"][$389];
                          };
                      };
                      $388.hp = v2.stats.hp - d | 0;
                      return $388;
                  })();
                  return $391;
              };
          };
      };
  };
  var playerColdRes = function (v) {
      return ((armourStats(Data_Maybe.fromMaybe(Wood.value)(v.equipment.cloak))).cr + (armourStats(Data_Maybe.fromMaybe(Wood.value)(v.equipment.chest))).cr | 0) + (armourStats(Data_Maybe.fromMaybe(Wood.value)(v.equipment.hands))).cr | 0;
  };
  exports["CommonA"] = CommonA;
  exports["LightA"] = LightA;
  exports["ThickA"] = ThickA;
  exports["MasterworkA"] = MasterworkA;
  exports["Cloak"] = Cloak;
  exports["Chest"] = Chest;
  exports["Gloves"] = Gloves;
  exports["Creature"] = Creature;
  exports["Player"] = Player;
  exports["AlphaWolf"] = AlphaWolf;
  exports["Wolf"] = Wolf;
  exports["Bear"] = Bear;
  exports["Goblin"] = Goblin;
  exports["Snowman"] = Snowman;
  exports["IceCorpse"] = IceCorpse;
  exports["Tim"] = Tim;
  exports["IceElemental"] = IceElemental;
  exports["GiantIceElemental"] = GiantIceElemental;
  exports["DwarfGhost"] = DwarfGhost;
  exports["Snake"] = Snake;
  exports["GiantSnake"] = GiantSnake;
  exports["Bat"] = Bat;
  exports["GameState"] = GameState;
  exports["Weapon"] = Weapon;
  exports["Armour"] = Armour;
  exports["Potion"] = Potion;
  exports["Wood"] = Wood;
  exports["Healing"] = Healing;
  exports["Warming"] = Warming;
  exports["DwarvenMine"] = DwarvenMine;
  exports["GoblinCave"] = GoblinCave;
  exports["Cave"] = Cave;
  exports["IceCave"] = IceCave;
  exports["WizardTower"] = WizardTower;
  exports["Ground"] = Ground;
  exports["Wall"] = Wall;
  exports["Mountain"] = Mountain;
  exports["Forest"] = Forest;
  exports["Water"] = Water;
  exports["Puddle"] = Puddle;
  exports["Door"] = Door;
  exports["River"] = River;
  exports["StairsUp"] = StairsUp;
  exports["StairsDown"] = StairsDown;
  exports["DungeonEntrance"] = DungeonEntrance;
  exports["Hideout"] = Hideout;
  exports["Fire"] = Fire;
  exports["WizardWall"] = WizardWall;
  exports["ErrorTile"] = ErrorTile;
  exports["Common"] = Common;
  exports["Rusty"] = Rusty;
  exports["Masterwork"] = Masterwork;
  exports["Sharp"] = Sharp;
  exports["Axe"] = Axe;
  exports["Dagger"] = Dagger;
  exports["Sword"] = Sword;
  exports["Spear"] = Spear;
  exports["Halberd"] = Halberd;
  exports["addArmourStats"] = addArmourStats;
  exports["addItem"] = addItem;
  exports["addStats"] = addStats;
  exports["armourPrefixName"] = armourPrefixName;
  exports["armourPrefixStats"] = armourPrefixStats;
  exports["armourStats"] = armourStats;
  exports["armourTypeName"] = armourTypeName;
  exports["armourTypeStats"] = armourTypeStats;
  exports["attack"] = attack;
  exports["createLevel"] = createLevel;
  exports["createWizard"] = createWizard;
  exports["creatureColor"] = creatureColor;
  exports["creatureHitChance"] = creatureHitChance;
  exports["creatureIcon"] = creatureIcon;
  exports["creatureSpeed"] = creatureSpeed;
  exports["creatureTypeStats"] = creatureTypeStats;
  exports["defaultArmourStats"] = defaultArmourStats;
  exports["defaultStats"] = defaultStats;
  exports["deleteItem"] = deleteItem;
  exports["dmg"] = dmg;
  exports["equip"] = equip;
  exports["frozenColor"] = frozenColor;
  exports["getLevelTile"] = getLevelTile;
  exports["getPlayer"] = getPlayer;
  exports["getTile"] = getTile;
  exports["initialGameState"] = initialGameState;
  exports["isArmourOfType"] = isArmourOfType;
  exports["isCorrectArmour"] = isCorrectArmour;
  exports["isPlayer"] = isPlayer;
  exports["isTileSolid"] = isTileSolid;
  exports["isTileTransparent"] = isTileTransparent;
  exports["isWeapon"] = isWeapon;
  exports["itemColor"] = itemColor;
  exports["itemIcon"] = itemIcon;
  exports["itemName"] = itemName;
  exports["itemWeight"] = itemWeight;
  exports["max'"] = max$prime;
  exports["min'"] = min$prime;
  exports["playerArmour"] = playerArmour;
  exports["playerColdRes"] = playerColdRes;
  exports["pointEquals"] = pointEquals;
  exports["pointMinus"] = pointMinus;
  exports["pointPlus"] = pointPlus;
  exports["potionEffect"] = potionEffect;
  exports["potionName"] = potionName;
  exports["setExits"] = setExits;
  exports["setLevelTile"] = setLevelTile;
  exports["setPlayer"] = setPlayer;
  exports["setTile"] = setTile;
  exports["themeName"] = themeName;
  exports["tileColor"] = tileColor;
  exports["tileIcon"] = tileIcon;
  exports["totalEnc"] = totalEnc;
  exports["unEquip"] = unEquip;
  exports["weaponDamage"] = weaponDamage;
  exports["weaponHitChance"] = weaponHitChance;
  exports["weaponPrefixName"] = weaponPrefixName;
  exports["weaponPrefixStats"] = weaponPrefixStats;
  exports["weaponTypeName"] = weaponTypeName;
  exports["weaponTypeStats"] = weaponTypeStats;
  exports["showCreature"] = showCreature;
  exports["showTile"] = showTile;
  exports["eqTheme"] = eqTheme;
  exports["showArmourType"] = showArmourType;
})(PS["Rogue"] = PS["Rogue"] || {});
(function(exports) {
  // Generated by psc version 0.10.7
  "use strict";
  var Prelude = PS["Prelude"];
  var Rogue = PS["Rogue"];
  var Data_Array = PS["Data.Array"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Traversable = PS["Data.Traversable"];
  var Partial_Unsafe = PS["Partial.Unsafe"];
  var Random = PS["Random"];
  var Data_Function = PS["Data.Function"];
  var Data_Ord = PS["Data.Ord"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Semiring = PS["Data.Semiring"];
  var Data_Ring = PS["Data.Ring"];
  var Data_Functor = PS["Data.Functor"];
  var Data_Eq = PS["Data.Eq"];
  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
  var Control_Bind = PS["Control.Bind"];
  var Control_Applicative = PS["Control.Applicative"];        
  var randomTheme = Random.unsafeSelectOne()([ Rogue.DwarvenMine.value, Rogue.GoblinCave.value, Rogue.Cave.value, Rogue.IceCave.value ]);
  var filterNegativeWeights = Data_Array.filter(function (x) {
      return x.weight > 0;
  });
  var randomWeighted = function (initialItems) {
      var weightSum = Data_Foldable.foldl(Data_Foldable.foldableArray)(function (acc) {
          return function (a) {
              return acc + a.weight | 0;
          };
      })(0)(initialItems);
      var go = function (__copy_items) {
          return function (__copy_weight) {
              var items = __copy_items;
              var weight = __copy_weight;
              tco: while (true) {
                  var $12 = Data_Array.head(items);
                  if ($12 instanceof Data_Maybe.Nothing) {
                      return Partial_Unsafe.unsafeCrashWith("empty array in randomWeighted");
                  };
                  if ($12 instanceof Data_Maybe.Just) {
                      var $13 = weight > $12.value0.weight;
                      if ($13) {
                          var tail$prime = Data_Maybe.fromMaybe([  ])(Data_Array.tail(items));
                          var __tco_weight = weight - $12.value0.weight | 0;
                          items = tail$prime;
                          weight = __tco_weight;
                          continue tco;
                      };
                      if (!$13) {
                          return $12.value0.item;
                      };
                      throw new Error("Failed pattern match at ContentGenerator line 23, column 21 - line 26, column 40: " + [ $13.constructor.name ]);
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 20, column 13 - line 26, column 40: " + [ $12.constructor.name ]);
              };
          };
      };
      return Data_Functor.map(Random.randomFunctor)(go(filterNegativeWeights(initialItems)))(Random.generateInt(0)(weightSum));
  };
  var randomEnemy = function (theme) {
      return function (depth) {
          var randomCreatureType = [ {
              item: Rogue.AlphaWolf.value, 
              weight: (function () {
                  var $15 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.Cave.value);
                  if ($15) {
                      return 100;
                  };
                  if (!$15) {
                      return 5;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 112, column 66 - line 112, column 99: " + [ $15.constructor.name ]);
              })()
          }, {
              item: Rogue.Wolf.value, 
              weight: (function () {
                  var $16 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.Cave.value);
                  if ($16) {
                      return 200;
                  };
                  if (!$16) {
                      return 30;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 113, column 66 - line 113, column 100: " + [ $16.constructor.name ]);
              })()
          }, {
              item: Rogue.Bear.value, 
              weight: (function () {
                  var $17 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.Cave.value);
                  if ($17) {
                      return 150;
                  };
                  if (!$17) {
                      return 30;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 114, column 66 - line 114, column 100: " + [ $17.constructor.name ]);
              })()
          }, {
              item: Rogue.Goblin.value, 
              weight: (function () {
                  var $18 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.GoblinCave.value);
                  if ($18) {
                      return 400;
                  };
                  if (!$18) {
                      return 10;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 115, column 66 - line 115, column 106: " + [ $18.constructor.name ]);
              })()
          }, {
              item: Rogue.Snowman.value, 
              weight: (function () {
                  var $19 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.IceCave.value) || Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.WizardTower.value);
                  if ($19) {
                      return 200;
                  };
                  if (!$19) {
                      return 5;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 116, column 66 - line 116, column 126: " + [ $19.constructor.name ]);
              })()
          }, {
              item: Rogue.IceCorpse.value, 
              weight: (function () {
                  var $20 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.IceCave.value) || Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.WizardTower.value);
                  if ($20) {
                      return 200;
                  };
                  if (!$20) {
                      return 5;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 117, column 66 - line 117, column 126: " + [ $20.constructor.name ]);
              })()
          }, {
              item: Rogue.IceElemental.value, 
              weight: (function () {
                  var $21 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.IceCave.value) || Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.WizardTower.value);
                  if ($21) {
                      return 200;
                  };
                  if (!$21) {
                      return 5;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 118, column 66 - line 118, column 126: " + [ $21.constructor.name ]);
              })()
          }, {
              item: Rogue.GiantIceElemental.value, 
              weight: (function () {
                  var $22 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.WizardTower.value);
                  if ($22) {
                      return 200;
                  };
                  if (!$22) {
                      return 0;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 119, column 66 - line 119, column 106: " + [ $22.constructor.name ]);
              })()
          }, {
              item: Rogue.Snake.value, 
              weight: (function () {
                  var $23 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.Cave.value);
                  if ($23) {
                      return 300;
                  };
                  if (!$23) {
                      return 0;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 120, column 66 - line 120, column 99: " + [ $23.constructor.name ]);
              })()
          }, {
              item: Rogue.GiantSnake.value, 
              weight: (function () {
                  var $24 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.Cave.value);
                  if ($24) {
                      return 100;
                  };
                  if (!$24) {
                      return 0;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 121, column 66 - line 121, column 99: " + [ $24.constructor.name ]);
              })()
          }, {
              item: Rogue.DwarfGhost.value, 
              weight: (function () {
                  var $25 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.DwarvenMine.value);
                  if ($25) {
                      return 600;
                  };
                  if (!$25) {
                      return 0;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 122, column 66 - line 122, column 106: " + [ $25.constructor.name ]);
              })()
          }, {
              item: Rogue.Bat.value, 
              weight: (function () {
                  var $26 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.Cave.value);
                  if ($26) {
                      return 200;
                  };
                  if (!$26) {
                      return 30;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 123, column 66 - line 123, column 100: " + [ $26.constructor.name ]);
              })()
          } ];
          var randomCreatureStats = [ {
              item: {
                  hpMax: 3, 
                  hp: 3, 
                  str: 2, 
                  dex: 2, 
                  "int": 0
              }, 
              weight: 10
          }, {
              item: {
                  hpMax: 2, 
                  hp: 2, 
                  str: 1, 
                  dex: 1, 
                  "int": 0
              }, 
              weight: 20
          }, {
              item: {
                  hpMax: 1, 
                  hp: 1, 
                  str: 1, 
                  dex: 1, 
                  "int": 0
              }, 
              weight: 60
          }, {
              item: {
                  hpMax: 0, 
                  hp: 0, 
                  str: 0, 
                  dex: 0, 
                  "int": 0
              }, 
              weight: 50
          } ];
          var randomCreature = Control_Bind.bind(Random.randomBind)(randomWeighted(randomCreatureStats))(function (v) {
              return Control_Bind.bind(Random.randomBind)(randomWeighted(randomCreatureType))(function (v1) {
                  return Control_Applicative.pure(Random.randomApplicative)({
                      creatureType: v1, 
                      pos: {
                          x: 0, 
                          y: 0
                      }, 
                      stats: Rogue.addStats(v)(Rogue.creatureTypeStats(v1)), 
                      inv: [  ], 
                      time: 0.0
                  });
              });
          });
          return randomCreature;
      };
  };
  var randomItem = function (theme) {
      return function (depth) {
          var weaponTypeWeights = [ {
              item: Rogue.Axe.value, 
              weight: (function () {
                  var $29 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.DwarvenMine.value);
                  if ($29) {
                      return 200;
                  };
                  if (!$29) {
                      return 10;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 53, column 55 - line 53, column 96: " + [ $29.constructor.name ]);
              })()
          }, {
              item: Rogue.Dagger.value, 
              weight: 40
          }, {
              item: Rogue.Sword.value, 
              weight: 20
          }, {
              item: Rogue.Spear.value, 
              weight: 20
          }, {
              item: Rogue.Halberd.value, 
              weight: (function () {
                  var $30 = Data_Eq.eq(Rogue.eqTheme)(theme)(Rogue.DwarvenMine.value);
                  if ($30) {
                      return 200;
                  };
                  if (!$30) {
                      return 5;
                  };
                  throw new Error("Failed pattern match at ContentGenerator line 57, column 55 - line 57, column 95: " + [ $30.constructor.name ]);
              })()
          } ];
          var weaponPrefixWeights = [ {
              item: Rogue.Common.value, 
              weight: 30 - depth | 0
          }, {
              item: Rogue.Rusty.value, 
              weight: 30 - (depth * 10 | 0) | 0
          }, {
              item: Rogue.Masterwork.value, 
              weight: 0 + (depth * 2 | 0) | 0
          }, {
              item: Rogue.Sharp.value, 
              weight: 10 + (depth * 5 | 0) | 0
          } ];
          var randomWeapon = Control_Bind.bind(Random.randomBind)(randomWeighted(weaponTypeWeights))(function (v) {
              return Control_Bind.bind(Random.randomBind)(randomWeighted(weaponPrefixWeights))(function (v1) {
                  return Control_Applicative.pure(Random.randomApplicative)(new Rogue.Weapon({
                      weaponType: v, 
                      prefix: v1
                  }));
              });
          });
          var potionEffectWeights = [ {
              item: Rogue.Healing.value, 
              weight: 50
          }, {
              item: Rogue.Warming.value, 
              weight: 50
          } ];
          var randomPotion = Control_Bind.bind(Random.randomBind)(randomWeighted(potionEffectWeights))(function (v) {
              return Control_Applicative.pure(Random.randomApplicative)(new Rogue.Potion({
                  effect: v
              }));
          });
          var armourTypeWeights = [ {
              item: Rogue.Cloak.value, 
              weight: 10
          }, {
              item: Rogue.Chest.value, 
              weight: 10
          }, {
              item: Rogue.Gloves.value, 
              weight: 10
          } ];
          var armourPrefixWeights = [ {
              item: Rogue.CommonA.value, 
              weight: 30 - depth | 0
          }, {
              item: Rogue.LightA.value, 
              weight: 20 + depth | 0
          }, {
              item: Rogue.ThickA.value, 
              weight: 10 + (depth * 2 | 0) | 0
          }, {
              item: Rogue.MasterworkA.value, 
              weight: 5 + depth | 0
          } ];
          var randomArmour = Control_Bind.bind(Random.randomBind)(randomWeighted(armourTypeWeights))(function (v) {
              return Control_Bind.bind(Random.randomBind)(randomWeighted(armourPrefixWeights))(function (v1) {
                  return Control_Applicative.pure(Random.randomApplicative)(new Rogue.Armour({
                      armourType: v, 
                      prefix: v1
                  }));
              });
          });
          return Control_Bind.bind(Random.randomBind)(randomWeapon)(function (v) {
              return Control_Bind.bind(Random.randomBind)(randomArmour)(function (v1) {
                  return Control_Bind.bind(Random.randomBind)(randomPotion)(function (v2) {
                      return Control_Bind.bind(Random.randomBind)(Control_Applicative.pure(Random.randomApplicative)(Rogue.Wood.value))(function (v3) {
                          return randomWeighted([ {
                              item: v, 
                              weight: 20
                          }, {
                              item: v1, 
                              weight: 20
                          }, {
                              item: v2, 
                              weight: 10
                          }, {
                              item: v3, 
                              weight: 5
                          } ]);
                      });
                  });
              });
          });
      };
  };
  exports["filterNegativeWeights"] = filterNegativeWeights;
  exports["randomEnemy"] = randomEnemy;
  exports["randomItem"] = randomItem;
  exports["randomTheme"] = randomTheme;
  exports["randomWeighted"] = randomWeighted;
})(PS["ContentGenerator"] = PS["ContentGenerator"] || {});