out.js

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

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

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

      return nonCanceler;
    };
  }

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

      return nonCanceler;
    };
  }

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

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

      var isCanceled    = false;
      var requestCancel = false;

      var onCanceler = function(){};

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

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

          onCanceler(canceler2);

          return canceler2;
        }
      }, error);

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

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

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

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

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

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

  exports.runFn4 = function (fn) {
    return function (a) {
      return function (b) {
        return function (c) {
          return function (d) {
            return fn(a, b, c, d);
          };
        };
      };
    };
  };

  exports.runFn5 = function (fn) {
    return function (a) {
      return function (b) {
        return function (c) {
          return function (d) {
            return function (e) {
              return fn(a, b, c, d, e);
            };
          };
        };
      };
    };
  };

  exports.runFn6 = function (fn) {
    return function (a) {
      return function (b) {
        return function (c) {
          return function (d) {
            return function (e) {
              return function (f) {
                return fn(a, b, c, d, e, f);
              };
            };
          };
        };
      };
    };
  };
 
})(PS["Data.Function"] = PS["Data.Function"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Prelude

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

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

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

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

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

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

  exports.showStringImpl = function (s) {
    return JSON.stringify(s);
  };

  exports.showArrayImpl = function (f) {
    return function (xs) {
      var ss = [];
      for (var i = 0, l = xs.length; i < l; i++) {
        ss[i] = f(xs[i]);
      }
      return "[" + ss.join(",") + "]";
    };
  };
 
})(PS["Prelude"] = PS["Prelude"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["Prelude"];
  var Semigroupoid = function (compose) {
      this.compose = compose;
  };
  var Functor = function (map) {
      this.map = map;
  };
  var Apply = function (__superclass_Prelude$dotFunctor_0, apply) {
      this["__superclass_Prelude.Functor_0"] = __superclass_Prelude$dotFunctor_0;
      this.apply = apply;
  };
  var Applicative = function (__superclass_Prelude$dotApply_0, pure) {
      this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
      this.pure = pure;
  };
  var Bind = function (__superclass_Prelude$dotApply_0, bind) {
      this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
      this.bind = bind;
  };
  var Monad = function (__superclass_Prelude$dotApplicative_0, __superclass_Prelude$dotBind_1) {
      this["__superclass_Prelude.Applicative_0"] = __superclass_Prelude$dotApplicative_0;
      this["__superclass_Prelude.Bind_1"] = __superclass_Prelude$dotBind_1;
  };
  var Semigroup = function (append) {
      this.append = append;
  };
  var Show = function (show) {
      this.show = show;
  };                                                                           
  var unit = {};
  var showString = new Show($foreign.showStringImpl);
  var showInt = new Show($foreign.showIntImpl);
  var show = function (dict) {
      return dict.show;
  };
  var showArray = function (__dict_Show_1) {
      return new Show($foreign.showArrayImpl(show(__dict_Show_1)));
  };                                                                     
  var semigroupoidFn = new Semigroupoid(function (f) {
      return function (g) {
          return function (x) {
              return f(g(x));
          };
      };
  });
  var semigroupString = new Semigroup($foreign.concatString);
  var pure = function (dict) {
      return dict.pure;
  };
  var $$return = function (__dict_Applicative_2) {
      return pure(__dict_Applicative_2);
  };
  var map = function (dict) {
      return dict.map;
  };
  var $less$dollar$greater = function (__dict_Functor_5) {
      return map(__dict_Functor_5);
  };
  var functorArray = new Functor($foreign.arrayMap);
  var $$const = function (a) {
      return function (_133) {
          return a;
      };
  };
  var compose = function (dict) {
      return dict.compose;
  };                                                   
  var $less$less$less = function (__dict_Semigroupoid_14) {
      return compose(__dict_Semigroupoid_14);
  };
  var bind = function (dict) {
      return dict.bind;
  };
  var $greater$greater$eq = function (__dict_Bind_24) {
      return bind(__dict_Bind_24);
  }; 
  var apply = function (dict) {
      return dict.apply;
  };
  var $less$times$greater = function (__dict_Apply_25) {
      return apply(__dict_Apply_25);
  };
  var liftA1 = function (__dict_Applicative_26) {
      return function (f) {
          return function (a) {
              return $less$times$greater(__dict_Applicative_26["__superclass_Prelude.Apply_0"]())(pure(__dict_Applicative_26)(f))(a);
          };
      };
  }; 
  var append = function (dict) {
      return dict.append;
  };
  var $less$greater = function (__dict_Semigroup_28) {
      return append(__dict_Semigroup_28);
  };
  var ap = function (__dict_Monad_30) {
      return function (f) {
          return function (a) {
              return bind(__dict_Monad_30["__superclass_Prelude.Bind_1"]())(f)(function (_20) {
                  return bind(__dict_Monad_30["__superclass_Prelude.Bind_1"]())(a)(function (_19) {
                      return $$return(__dict_Monad_30["__superclass_Prelude.Applicative_0"]())(_20(_19));
                  });
              });
          };
      };
  };
  exports["Show"] = Show;
  exports["Semigroup"] = Semigroup;
  exports["Monad"] = Monad;
  exports["Bind"] = Bind;
  exports["Applicative"] = Applicative;
  exports["Apply"] = Apply;
  exports["Functor"] = Functor;
  exports["Semigroupoid"] = Semigroupoid;
  exports["show"] = show;
  exports["<>"] = $less$greater;
  exports["append"] = append;
  exports["ap"] = ap;
  exports["return"] = $$return;
  exports[">>="] = $greater$greater$eq;
  exports["bind"] = bind;
  exports["liftA1"] = liftA1;
  exports["pure"] = pure;
  exports["apply"] = apply;
  exports["<$>"] = $less$dollar$greater;
  exports["map"] = map;
  exports["<<<"] = $less$less$less;
  exports["compose"] = compose;
  exports["const"] = $$const;
  exports["unit"] = unit;
  exports["semigroupoidFn"] = semigroupoidFn;
  exports["functorArray"] = functorArray;
  exports["semigroupString"] = semigroupString;
  exports["showInt"] = showInt;
  exports["showString"] = showString;
  exports["showArray"] = showArray;;
 
})(PS["Prelude"] = PS["Prelude"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["Data.Function"];
  var Prelude = PS["Prelude"];
  exports["runFn6"] = $foreign.runFn6;
  exports["runFn5"] = $foreign.runFn5;
  exports["runFn4"] = $foreign.runFn4;;
 
})(PS["Data.Function"] = PS["Data.Function"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var Prelude = PS["Prelude"];     
  var Monoid = function (__superclass_Prelude$dotSemigroup_0, mempty) {
      this["__superclass_Prelude.Semigroup_0"] = __superclass_Prelude$dotSemigroup_0;
      this.mempty = mempty;
  };               
  var monoidString = new Monoid(function () {
      return Prelude.semigroupString;
  }, "");  
  var mempty = function (dict) {
      return dict.mempty;
  };
  exports["Monoid"] = Monoid;
  exports["mempty"] = mempty;
  exports["monoidString"] = monoidString;;
 
})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  // module Data.Foldable

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

  exports.foldlArray = function (f) {
    return function (init) {
      return function (xs) {
        var acc = init;
        var len = xs.length;
        for (var i = 0; i < len; i++) {
          acc = f(acc)(xs[i]);
        }
        return acc;
      };
    };
  };
 
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_Extend = PS["Control.Extend"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Monoid = PS["Data.Monoid"];     
  var Nothing = (function () {
      function Nothing() {

      };
      Nothing.value = new Nothing();
      return Nothing;
  })();
  var Just = (function () {
      function Just(value0) {
          this.value0 = value0;
      };
      Just.create = function (value0) {
          return new Just(value0);
      };
      return Just;
  })();
  exports["Nothing"] = Nothing;
  exports["Just"] = Just;;
 
})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["Data.Foldable"];
  var Prelude = PS["Prelude"];
  var Data_Monoid = PS["Data.Monoid"];
  var Control_Apply = PS["Control.Apply"];
  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Maybe_Last = PS["Data.Maybe.Last"];
  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];     
  var Foldable = function (foldMap, foldl, foldr) {
      this.foldMap = foldMap;
      this.foldl = foldl;
      this.foldr = foldr;
  };
  var foldr = function (dict) {
      return dict.foldr;
  };
  var foldl = function (dict) {
      return dict.foldl;
  };
  var intercalate = function (__dict_Foldable_6) {
      return function (__dict_Monoid_7) {
          return function (sep) {
              return function (xs) {
                  var go = function (_346) {
                      return function (x) {
                          if (_346.init) {
                              return {
                                  init: false, 
                                  acc: x
                              };
                          };
                          return {
                              init: false, 
                              acc: Prelude["<>"](__dict_Monoid_7["__superclass_Prelude.Semigroup_0"]())(_346.acc)(Prelude["<>"](__dict_Monoid_7["__superclass_Prelude.Semigroup_0"]())(sep)(x))
                          };
                      };
                  };
                  return (foldl(__dict_Foldable_6)(go)({
                      init: true, 
                      acc: Data_Monoid.mempty(__dict_Monoid_7)
                  })(xs)).acc;
              };
          };
      };
  }; 
  var foldableArray = new Foldable(function (__dict_Monoid_19) {
      return function (f) {
          return function (xs) {
              return foldr(foldableArray)(function (x) {
                  return function (acc) {
                      return Prelude["<>"](__dict_Monoid_19["__superclass_Prelude.Semigroup_0"]())(f(x))(acc);
                  };
              })(Data_Monoid.mempty(__dict_Monoid_19))(xs);
          };
      };
  }, $foreign.foldlArray, $foreign.foldrArray);
  var foldMap = function (dict) {
      return dict.foldMap;
  };
  exports["Foldable"] = Foldable;
  exports["intercalate"] = intercalate;
  exports["foldMap"] = foldMap;
  exports["foldl"] = foldl;
  exports["foldr"] = foldr;
  exports["foldableArray"] = foldableArray;;
 
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Monoid = PS["Data.Monoid"];
  var Control_Alt = PS["Control.Alt"];
  var Control_Extend = PS["Control.Extend"];
  var Data_Bifoldable = PS["Data.Bifoldable"];
  var Data_Bifunctor = PS["Data.Bifunctor"];
  var Data_Bitraversable = PS["Data.Bitraversable"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Traversable = PS["Data.Traversable"];     
  var Left = (function () {
      function Left(value0) {
          this.value0 = value0;
      };
      Left.create = function (value0) {
          return new Left(value0);
      };
      return Left;
  })();
  var Right = (function () {
      function Right(value0) {
          this.value0 = value0;
      };
      Right.create = function (value0) {
          return new Right(value0);
      };
      return Right;
  })();
  var either = function (f) {
      return function (g) {
          return function (_372) {
              if (_372 instanceof Left) {
                  return f(_372.value0);
              };
              if (_372 instanceof Right) {
                  return g(_372.value0);
              };
              throw new Error("Failed pattern match at Data.Either line 28, column 1 - line 29, column 1: " + [ f.constructor.name, g.constructor.name, _372.constructor.name ]);
          };
      };
  };
  exports["Left"] = Left;
  exports["Right"] = Right;
  exports["either"] = either;;
 
})(PS["Data.Either"] = PS["Data.Either"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Control_Monad_Error_Trans = PS["Control.Monad.Error.Trans"];
  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
  var Control_Monad_Trans = PS["Control.Monad.Trans"];
  var Control_Monad_Maybe_Trans = PS["Control.Monad.Maybe.Trans"];
  var Control_Monad_Reader_Trans = PS["Control.Monad.Reader.Trans"];
  var Control_Monad_Writer_Trans = PS["Control.Monad.Writer.Trans"];
  var Control_Monad_State_Trans = PS["Control.Monad.State.Trans"];
  var Control_Monad_Error = PS["Control.Monad.Error"];
  var Data_Either = PS["Data.Either"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];     
  var MonadError = function (catchError, throwError) {
      this.catchError = catchError;
      this.throwError = throwError;
  };
  var throwError = function (dict) {
      return dict.throwError;
  };                          
  var catchError = function (dict) {
      return dict.catchError;
  };
  exports["MonadError"] = MonadError;
  exports["catchError"] = catchError;
  exports["throwError"] = throwError;;
 
})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
(function(exports) {
  /* global exports */
  "use strict";

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

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

  // module Control.Monad.Eff

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

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

  // module Control.Monad.Eff.Console

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

  // module Control.Monad.Eff.Console.Unsafe

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

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

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

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

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

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

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

  exports.concat = function (xss) {
    var result = [];
    for (var i = 0, l = xss.length; i < l; i++) {
      var xs = xss[i];
      for (var j = 0, m = xs.length; j < m; j++) {
        result.push(xs[j]);
      }
    }
    return result;
  };

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

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

  exports.drop = function (n) {
    return function (l) {
      return n < 1 ? l : l.slice(n);
    };
  };
 
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var Prelude = PS["Prelude"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Control_Lazy = PS["Control.Lazy"];
  var Data_Maybe_First = PS["Data.Maybe.First"];
  var Data_Foldable = PS["Data.Foldable"];
  var Control_Biapplicative = PS["Control.Biapplicative"];
  var Control_Biapply = PS["Control.Biapply"];
  var Control_Comonad = PS["Control.Comonad"];
  var Control_Extend = PS["Control.Extend"];
  var Data_Bifoldable = PS["Data.Bifoldable"];
  var Data_Bifunctor = PS["Data.Bifunctor"];
  var Data_Bitraversable = PS["Data.Bitraversable"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Traversable = PS["Data.Traversable"];     
  var Tuple = (function () {
      function Tuple(value0, value1) {
          this.value0 = value0;
          this.value1 = value1;
      };
      Tuple.create = function (value0) {
          return function (value1) {
              return new Tuple(value0, value1);
          };
      };
      return Tuple;
  })();
  var curry = function (f) {
      return function (a) {
          return function (b) {
              return f(new Tuple(a, b));
          };
      };
  };
  exports["Tuple"] = Tuple;
  exports["curry"] = curry;;
 
})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["Data.Array"];
  var Prelude = PS["Prelude"];
  var Data_Traversable = PS["Data.Traversable"];
  var Control_Lazy = PS["Control.Lazy"];
  var Control_Alt = PS["Control.Alt"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Maybe_Unsafe = PS["Data.Maybe.Unsafe"];
  var Data_Foldable = PS["Data.Foldable"];
  var Control_Alternative = PS["Control.Alternative"];
  var Control_MonadPlus = PS["Control.MonadPlus"];
  var Control_Plus = PS["Control.Plus"];
  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
  var Data_Monoid = PS["Data.Monoid"];
  var Data_Tuple = PS["Data.Tuple"];
  var uncons = $foreign["uncons'"](Prelude["const"](Data_Maybe.Nothing.value))(function (x) {
      return function (xs) {
          return new Data_Maybe.Just({
              head: x, 
              tail: xs
          });
      };
  });
  var take = $foreign.slice(0);
  var tail = $foreign["uncons'"](Prelude["const"](Data_Maybe.Nothing.value))(function (_552) {
      return function (xs) {
          return new Data_Maybe.Just(xs);
      };
  });
  var head = $foreign["uncons'"](Prelude["const"](Data_Maybe.Nothing.value))(function (x) {
      return function (_551) {
          return new Data_Maybe.Just(x);
      };
  });
  exports["take"] = take;
  exports["uncons"] = uncons;
  exports["tail"] = tail;
  exports["head"] = head;
  exports["drop"] = $foreign.drop;
  exports["cons"] = $foreign.cons;;
 
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.fromCharCode = function (c) {
    return String.fromCharCode(c);
  };
 
})(PS["Data.Char"] = PS["Data.Char"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["Data.Char"];
  var Prelude = PS["Prelude"];
  exports["fromCharCode"] = $foreign.fromCharCode;;
 
})(PS["Data.Char"] = PS["Data.Char"] || {});
(function(exports) {
  /* global exports */
  "use strict";

  exports.fromCharArray = function (a) {
    return a.join("");
  };
 
})(PS["Data.String"] = PS["Data.String"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["Data.String"];
  var Data_Char = PS["Data.Char"];
  var Prelude = PS["Prelude"];
  var Data_String_Unsafe = PS["Data.String.Unsafe"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Monoid = PS["Data.Monoid"];
  exports["fromCharArray"] = $foreign.fromCharArray;;
 
})(PS["Data.String"] = PS["Data.String"] || {});
(function(exports) {
  // module System.ArrayBuffers.Types

  exports.toHex = function toHex(k){
	  var r = k.toString(16);
	  if (r.length < 2) {
		  r = "0"+r;
	  }
	  return "0x"+r;
  }
  exports.buffer = function buffer(aview){
	  return aview.buffer;
  };
  exports.uint8ArrayFromArrayBuffer = function int32ArrayFromArrayBuffer(abuf){
	  return new Int32Array(abuf);
  };
  exports.uint8ArrayFromArrayBuffer = function uint8ArrayFromArrayBuffer(abuf){
	  return new Uint8Array(abuf);
  };

  exports.uint8ArrayFromIntArray = function uint8ArrayFromNumberArray(abuf){
	  return new Uint8Array(abuf);
  };
  //FIXME can this just be named directly?
  exports.arrayFromTypedArray = function arrayFromTypedArray(tarr){
	  //return Array.from(tarr);
	  var arr = new Array(tarr.length);
	  for (var i = 0; i < tarr.length; i++) {
		  arr[i] = tarr[i];
	  }
	  return arr;
  }
})(PS["System.ArrayBuffers.Types"] = PS["System.ArrayBuffers.Types"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["System.ArrayBuffers.Types"];
  var Prelude = PS["Prelude"];
  var Data_Foldable = PS["Data.Foldable"];
  var Data_Monoid = PS["Data.Monoid"];     
  var TypedArrayContents = function (fromArrayBuffer) {
      this.fromArrayBuffer = fromArrayBuffer;
  };
  var uint8TAC = new TypedArrayContents($foreign.uint8ArrayFromArrayBuffer);  
  var showUint8Array = new Prelude.Show(function (bs) {
      return "[" + (Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)(",")(Prelude.map(Prelude.functorArray)($foreign.toHex)($foreign.arrayFromTypedArray(bs))) + "]");
  });                                                                       
  var fromArrayBuffer = function (dict) {
      return dict.fromArrayBuffer;
  };
  exports["TypedArrayContents"] = TypedArrayContents;
  exports["fromArrayBuffer"] = fromArrayBuffer;
  exports["uint8TAC"] = uint8TAC;
  exports["showUint8Array"] = showUint8Array;
  exports["arrayFromTypedArray"] = $foreign.arrayFromTypedArray;
  exports["uint8ArrayFromIntArray"] = $foreign.uint8ArrayFromIntArray;
  exports["buffer"] = $foreign.buffer;;
 
})(PS["System.ArrayBuffers.Types"] = PS["System.ArrayBuffers.Types"] || {});
(function(exports) {
  // module System.USB.HID
  exports.sendRaw = function sendRaw(toError, conn, rep, ab, errcb, cb) {
	  return function() {
		  chrome.hid.send(conn, rep, ab, function() {
			  if (chrome.runtime.lastError) {
				  errcb(toError(chrome.runtime.lastError.message))();
			  } else {
				  cb({})();
			  }
		  });
		  return {};
	  }
  }

  exports.receiveRaw = function receive(toError, connid, errcb, cb) {
	  return function() {
		  chrome.hid.receive(connid, function(rid, arrbuf) {
			  if (chrome.runtime.lastError) {
				  errcb(toError(chrome.runtime.lastError.message))();
			  } else {
				  cb(rid)(arrbuf)();
			  }
		  });
		  return {};
	  }
  }

  exports.disconnectRaw = function disconnectRaw(toError, connid, errcb, cb) {
	  return function() {
		  chrome.hid.disconnect(connid, function() {
			  if (chrome.runtime.lastError) {
				  errcb(toError(chrome.runtime.lastError.message))();
			  } else {
				  cb({})();
			  }
		  });
		  return {};
	  };
  }

  exports.getDevicesRaw = function getDevicesRaw(toError, opts, errcb, cb) {
	  return function() {
		  chrome.hid.getDevices({
			  filters: opts
		  }, function(devs) {
			  if (chrome.runtime.lastError) {
				  errcb(toError(chrome.runtime.lastError.message))();
			  } else {
				  cb(devs)();
			  }
		  });

		  return {};
	  };
  }

  exports.connectRaw = function connectRaw(toError, did, errcb, cb) {
	  return function() {
		  chrome.hid.connect(did, function(conn) {
			  if (chrome.runtime.lastError) {
				  errcb(toError(chrome.runtime.lastError.message))();
			  } else {
				  cb(conn)();
			  }
		  });
		  return {};
	  };
  }

  exports.receiveFeatureReportRaw = function(toError, cid, rid, errcb, cb) {
	  return function() {
		  chrome.hid.receiveFeatureReport(cid, rid, function(arrbuf) {
			  if (chrome.runtime.lastError) {
				  errcb(toError(chrome.runtime.lastError.message))();
			  } else {
				  cb(arrbuf)();
			  }
		  });
		  return {};
	  };
  }

  exports.sendFeatureReportRaw = function(toError, cid, rid, abuf, errcb, cb) {
	  return function() {
		  chrome.hid.sendFeatureReport(cid, rid, abuf, function() {
			  if (chrome.runtime.lastError) {
				  errcb(toError(chrome.runtime.lastError.message))();
			  } else {
				  cb({})();
			  }
		  });
		  return {};
	  };
  }

  exports.getConnectionId = function getConnectionId(conn) {
	  return conn.connectionId;
  }
 
})(PS["System.USB.HID"] = PS["System.USB.HID"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["System.USB.HID"];
  var Data_Function = PS["Data.Function"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Data_Tuple = PS["Data.Tuple"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var System_ArrayBuffers_Types = PS["System.ArrayBuffers.Types"];
  var sendFeatureReport = Data_Function.runFn6($foreign.sendFeatureReportRaw)(Control_Monad_Eff_Exception.error);
  var sendFRAff = function (cid) {
      return function (rid) {
          return function (abuf) {
              return Control_Monad_Aff.makeAff(function (error) {
                  return function (success) {
                      return sendFeatureReport(cid)(rid)(abuf)(error)(success);
                  };
              });
          };
      };
  };
  var send = Data_Function.runFn6($foreign.sendRaw)(Control_Monad_Eff_Exception.error);
  var sendAff = function (cid) {
      return function (rid) {
          return function (abuf) {
              return Control_Monad_Aff.makeAff(function (error) {
                  return function (success) {
                      return send(cid)(rid)(abuf)(error)(success);
                  };
              });
          };
      };
  };
  var receiveFeatureReport = Data_Function.runFn5($foreign.receiveFeatureReportRaw)(Control_Monad_Eff_Exception.error);
  var receiveFRAff = function (cid) {
      return function (rid) {
          return Control_Monad_Aff.makeAff(function (error) {
              return function (success) {
                  return receiveFeatureReport(cid)(rid)(error)(success);
              };
          });
      };
  };
  var receive = function (c) {
      return function (ecb) {
          return function (scb) {
              return $foreign.receiveRaw(Control_Monad_Eff_Exception.error, c, ecb, Data_Tuple.curry(scb));
          };
      };
  };
  var receiveAff = function (cid) {
      return Control_Monad_Aff.makeAff(function (error) {
          return function (success) {
              return receive(cid)(error)(success);
          };
      });
  };
  var getReportIdInt = function (_596) {
      return _596;
  };
  var getDevices = function (ds) {
      return function (ecb) {
          return function (cb) {
              return $foreign.getDevicesRaw(Control_Monad_Eff_Exception.error, ds, ecb, cb);
          };
      };
  };
  var getDevicesAff = function (devfs) {
      return Control_Monad_Aff.makeAff(function (error) {
          return function (success) {
              return getDevices(devfs)(error)(success);
          };
      });
  };
  var disconnect = Data_Function.runFn4($foreign.disconnectRaw)(Control_Monad_Eff_Exception.error);
  var disconnectAff = function (cid) {
      return Control_Monad_Aff.makeAff(function (error) {
          return function (success) {
              return disconnect(cid)(error)(success);
          };
      });
  };
  var connect = Data_Function.runFn4($foreign.connectRaw)(Control_Monad_Eff_Exception.error);
  var connectAff = function (did) {
      return Control_Monad_Aff.makeAff(function (error) {
          return function (success) {
              return connect(did)(error)(success);
          };
      });
  };
  exports["sendFRAff"] = sendFRAff;
  exports["receiveFRAff"] = receiveFRAff;
  exports["receiveAff"] = receiveAff;
  exports["sendAff"] = sendAff;
  exports["getDevicesAff"] = getDevicesAff;
  exports["disconnectAff"] = disconnectAff;
  exports["connectAff"] = connectAff;
  exports["sendFeatureReport"] = sendFeatureReport;
  exports["receiveFeatureReport"] = receiveFeatureReport;
  exports["connect"] = connect;
  exports["getDevices"] = getDevices;
  exports["disconnect"] = disconnect;
  exports["receive"] = receive;
  exports["send"] = send;
  exports["getReportIdInt"] = getReportIdInt;
  exports["getConnectionId"] = $foreign.getConnectionId;;
 
})(PS["System.USB.HID"] = PS["System.USB.HID"] || {});
(function(exports) {
  // module System.Serial

  exports.getDevicesRaw = function getDevicesRaw(asp2e){
	  return function(){
		  chrome.serial.getDevices(function(ports){
			  asp2e(ports)();
		  });
	  };
  }

  exports.connectRaw = function connectRaw(str){
	  return function(connopts){
		  return function(cb){
			  return function(){
				  chrome.serial.connect(str,connopts,function(conninfo){
					  cb(conninfo)();
				  });
			  };
		  };
	  };
  }

  exports.disconnectRaw = function disconnectRaw(connid){
	  return function(cb){
		  return function(){
			  chrome.serial.disconnect(connid,function(bool){
				  cb(bool)();
			  });
		  };
	  };
  }

  exports.defaultConnOpts = {bufferSize: 1024, bitrate: 9600}
})(PS["System.Serial"] = PS["System.Serial"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var $foreign = PS["System.Serial"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Prelude = PS["Prelude"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Nullable = PS["Data.Nullable"];
  var System_ArrayBuffers_Types = PS["System.ArrayBuffers.Types"];
  var getDevices = Control_Monad_Aff.makeAff(function (err) {
      return function (succ) {
          return $foreign.getDevicesRaw(succ);
      };
  });
  var disconnect = function (cid) {
      return Control_Monad_Aff.makeAff(function (err) {
          return function (succ) {
              return $foreign.disconnectRaw(cid)(succ);
          };
      });
  };
  var connect = function (path) {
      return function (conopt) {
          return Control_Monad_Aff.makeAff(function (err) {
              return function (success) {
                  return $foreign.connectRaw(path)(conopt)(success);
              };
          });
      };
  };
  exports["disconnect"] = disconnect;
  exports["connect"] = connect;
  exports["getDevices"] = getDevices;
  exports["defaultConnOpts"] = $foreign.defaultConnOpts;;
 
})(PS["System.Serial"] = PS["System.Serial"] || {});
(function(exports) {
  // Generated by psc version 0.7.3.0
  "use strict";
  var System_ArrayBuffers_Types = PS["System.ArrayBuffers.Types"];
  var Data_Int_Bits = PS["Data.Int.Bits"];
  var Prelude = PS["Prelude"];
  var Data_Char = PS["Data.Char"];
  var Data_Array = PS["Data.Array"];
  var Data_String = PS["Data.String"];
  var Data_Array_Unsafe = PS["Data.Array.Unsafe"];
  var System_USB_HID = PS["System.USB.HID"];
  var Control_Monad_Aff = PS["Control.Monad.Aff"];
  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
  var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
  var Control_Monad_Eff_Console_Unsafe = PS["Control.Monad.Eff.Console.Unsafe"];
  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
  var System_Serial = PS["System.Serial"];
  var Control_Monad_Eff = PS["Control.Monad.Eff"];
  var Data_Maybe = PS["Data.Maybe"];
  var Data_Tuple = PS["Data.Tuple"];
  var Data_Foldable = PS["Data.Foldable"];     
  var wireUint16toInt = function (x) {
      var _13 = Data_Array.uncons(x);
      if (_13 instanceof Data_Maybe.Just) {
          var _14 = Data_Array.uncons(_13.value0.tail);
          if (_14 instanceof Data_Maybe.Just) {
              return (_13.value0.head * 255 | 0) + _14.value0.head | 0;
          };
          if (_14 instanceof Data_Maybe.Nothing) {
              return -1;
          };
          throw new Error("Failed pattern match at Main line 77, column 1 - line 83, column 1: " + [ _14.constructor.name ]);
      };
      if (_13 instanceof Data_Maybe.Nothing) {
          return -1;
      };
      throw new Error("Failed pattern match at Main line 77, column 1 - line 83, column 1: " + [ _13.constructor.name ]);
  };
  var usbutf16toChar = function (a) {
      return function (b) {
          return Data_Char.fromCharCode(a + (255 * b | 0) | 0);
      };
  };
  var usbstr2str = function (x) {
      var _21 = Data_Array.uncons(x);
      if (_21 instanceof Data_Maybe.Just) {
          var _22 = Data_Array.uncons(_21.value0.tail);
          if (_22 instanceof Data_Maybe.Just) {
              return Data_Array.cons(usbutf16toChar(_21.value0.head)(_22.value0.head))(usbstr2str(_22.value0.tail));
          };
          if (_22 instanceof Data_Maybe.Nothing) {
              return [  ];
          };
          throw new Error("Failed pattern match: " + [ _22.constructor.name ]);
      };
      if (_21 instanceof Data_Maybe.Nothing) {
          return [  ];
      };
      throw new Error("Failed pattern match: " + [ _21.constructor.name ]);
  };
  var thearrbuf = System_ArrayBuffers_Types.uint8ArrayFromIntArray([ 1, 1, 0, 0, 0, 0, 0, 0 ]);
  var showByte$prime = function (n) {
      var show$prime = function (x) {
          if (x < 10) {
              return Prelude.show(Prelude.showInt)(x);
          };
          if (x === 10) {
              return "A";
          };
          if (x === 11) {
              return "B";
          };
          if (x === 12) {
              return "C";
          };
          if (x === 13) {
              return "D";
          };
          if (x === 14) {
              return "E";
          };
          if (x === 15) {
              return "F";
          };
          throw new Error("Failed pattern match at Main line 47, column 9 - line 48, column 9: " + [ x.constructor.name ]);
      };
      var low = n & 15;
      var high = n >>> 4 & 15;
      return show$prime(high) + show$prime(low);
  };
  var showByte2$prime = function (n) {
      var lo = n & 255;
      var hi = n >>> 8 & 255;
      return showByte$prime(hi) + showByte$prime(lo);
  };
  var showByte2 = function (x) {
      return "0x" + showByte2$prime(x);
  };
  var showByte = function (x) {
      return "0x" + showByte$prime(x);
  };
  var serialmain = Control_Monad_Aff.runAff(function (err) {
      return Control_Monad_Eff_Console.log(Control_Monad_Eff_Exception.message(err));
  })(Prelude["const"](Control_Monad_Eff_Console.log("error didn't happen")))(Prelude.bind(Control_Monad_Aff.bindAff)(System_Serial.getDevices)(function (_12) {
      var paths = Prelude.map(Prelude.functorArray)(function (r) {
          return r.path;
      })(_12);
      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.print(Prelude.showArray(Prelude.showString))(paths)))(function () {
          return Prelude.bind(Control_Monad_Aff.bindAff)(System_Serial.connect(paths[5])(System_Serial.defaultConnOpts))(function (_11) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log("connected")))(function () {
                  return System_Serial.disconnect(_11.connectionId);
              });
          });
      });
  }));
  var request_string_bf = System_ArrayBuffers_Types.uint8ArrayFromIntArray([ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]);
  var processusbFRstring = function (x) {
      return {
          length: wireUint16toInt(Data_Array.drop(1)(Data_Array.take(3)(x))), 
          rem: wireUint16toInt(Data_Array.drop(3)(Data_Array.take(5)(x))), 
          msgpart: Data_String.fromCharArray(usbstr2str(Data_Array.take(x[4])(Data_Array.drop(5)(x))))
      };
  };
  var manyreps = function (n) {
      return function (cid) {
          if (n > 0) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.receiveAff(cid))(function (_7) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)((function () {
                      var _35 = System_USB_HID.getReportIdInt(_7.value0) === 4;
                      if (_35) {
                          return Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.print(Prelude.showArray(Prelude.showInt))(System_ArrayBuffers_Types.arrayFromTypedArray(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)(_7.value1))));
                      };
                      if (!_35) {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude["<<<"](Prelude.semigroupoidFn)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff))(Control_Monad_Eff_Console.log)("got the wrong report in manyreps "))(function () {
                              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.print(Prelude.showInt)(System_USB_HID.getReportIdInt(_7.value0))))(function () {
                                  return Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.print(Prelude.showArray(Prelude.showInt))(System_ArrayBuffers_Types.arrayFromTypedArray(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)(_7.value1))));
                              });
                          });
                      };
                      throw new Error("Failed pattern match: " + [ _35.constructor.name ]);
                  })())(function () {
                      return manyreps(n - 1)(cid);
                  });
              });
          };
          return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
      };
  };
  var make_string_request = function (sid) {
      return function (offset) {
          return System_ArrayBuffers_Types.uint8ArrayFromIntArray([ sid, offset, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]);
      };
  };
  var ledbuf_3 = System_ArrayBuffers_Types.uint8ArrayFromIntArray([ 0, 0, 1, 0, 0, 0, 0, 0 ]);
  var ledbuf_2 = System_ArrayBuffers_Types.uint8ArrayFromIntArray([ 0, 1, 0, 0, 0, 0, 0, 0 ]);
  var ledbuf_1 = System_ArrayBuffers_Types.uint8ArrayFromIntArray([ 1, 0, 0, 0, 0, 0, 0, 0 ]);
  var justConnect = function (f) {
      return Control_Monad_Aff.runAff(function (err) {
          return Control_Monad_Eff_Console.log(Control_Monad_Eff_Exception.message(err));
      })(f)(Prelude.bind(Control_Monad_Aff.bindAff)(Prelude["<$>"](Control_Monad_Aff.functorAff)(Data_Array.head)(System_USB_HID.getDevicesAff([  ])))(function (_9) {
          if (_9 instanceof Data_Maybe.Nothing) {
              return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadErrorAff)(Control_Monad_Eff_Exception.error("no devices"));
          };
          if (_9 instanceof Data_Maybe.Just) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.connectAff(_9.value0.deviceId))(function (_8) {
                  return Prelude["return"](Control_Monad_Aff.applicativeAff)(_8);
              });
          };
          throw new Error("Failed pattern match at Main line 168, column 1 - line 169, column 1: " + [ _9.constructor.name ]);
      }));
  };
  var getStringDesc = function (cid) {
      return function (sid) {
          var go = function (str) {
              return function (oset) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.sendFRAff(cid)(2)(System_ArrayBuffers_Types.buffer(make_string_request(sid)(oset))))(function () {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.receiveFRAff(cid)(2))(function (_0) {
                          var sbuf = Prelude["<<<"](Prelude.semigroupoidFn)(processusbFRstring)(Prelude["<<<"](Prelude.semigroupoidFn)(System_ArrayBuffers_Types.arrayFromTypedArray)(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)))(_0);
                          var _43 = sbuf.rem > 30;
                          if (_43) {
                              return go(str + sbuf.msgpart)(oset + 30 | 0);
                          };
                          if (!_43) {
                              return Prelude["return"](Control_Monad_Aff.applicativeAff)(str + sbuf.msgpart);
                          };
                          throw new Error("Failed pattern match at Main line 97, column 1 - line 98, column 1: " + [ _43.constructor.name ]);
                      });
                  });
              };
          };
          return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.sendFRAff(cid)(2)(System_ArrayBuffers_Types.buffer(make_string_request(sid)(0))))(function () {
              return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.receiveFRAff(cid)(2))(function (_1) {
                  var sbuf = Prelude["<<<"](Prelude.semigroupoidFn)(processusbFRstring)(Prelude["<<<"](Prelude.semigroupoidFn)(System_ArrayBuffers_Types.arrayFromTypedArray)(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)))(_1);
                  var _45 = sbuf.rem > 30;
                  if (_45) {
                      return go(sbuf.msgpart)(30);
                  };
                  if (!_45) {
                      return Prelude["return"](Control_Monad_Aff.applicativeAff)(sbuf.msgpart);
                  };
                  throw new Error("Failed pattern match at Main line 97, column 1 - line 98, column 1: " + [ _45.constructor.name ]);
              });
          });
      };
  };
  var usbmain = Control_Monad_Aff.runAff(function (err) {
      return Control_Monad_Eff_Console.log(Control_Monad_Eff_Exception.message(err));
  })(Prelude["const"](Control_Monad_Eff_Console.log("error didn't happen")))(Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log("starting")))(function () {
      return Prelude.bind(Control_Monad_Aff.bindAff)(Prelude["<$>"](Control_Monad_Aff.functorAff)(Data_Array.head)(System_USB_HID.getDevicesAff([  ])))(function (_6) {
          return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log("after")))(function () {
              if (_6 instanceof Data_Maybe.Nothing) {
                  return Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log("no devices"));
              };
              if (_6 instanceof Data_Maybe.Just) {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console_Unsafe.logAny(_6.value0)))(function () {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.print(System_ArrayBuffers_Types.showUint8Array)(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)(_6.value0.reportDescriptor))))(function () {
                          return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.connectAff(_6.value0.deviceId))(function (_5) {
                              var cid = System_USB_HID.getConnectionId(_5);
                              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log("connected!")))(function () {
                                  return Prelude.bind(Control_Monad_Aff.bindAff)(manyreps(10)(cid))(function () {
                                      return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.sendAff(cid)(1)(System_ArrayBuffers_Types.buffer(thearrbuf)))(function () {
                                          return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log("sent")))(function () {
                                              return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.receiveAff(cid))(function (_4) {
                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.receiveFRAff(cid)(1))(function (_3) {
                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(function __do() {
                                                          Control_Monad_Eff_Console.log("feature report")();
                                                          Control_Monad_Eff_Console_Unsafe.logAny(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)(_3))();
                                                          Control_Monad_Eff_Console.log("received_ps")();
                                                          Control_Monad_Eff_Console_Unsafe.logAny(_4.value0)();
                                                          Control_Monad_Eff_Console_Unsafe.logAny(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)(_4.value1))();
                                                          return Control_Monad_Eff_Console.log("about to blink")();
                                                      }))(function () {
                                                          return Prelude.bind(Control_Monad_Aff.bindAff)(getStringDesc(cid)(2))(function (_2) {
                                                              return Prelude.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log(_2)))(function () {
                                                                  return Prelude.bind(Control_Monad_Aff.bindAff)(manyreps(500000)(cid))(function () {
                                                                      return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.disconnectAff(cid))(function () {
                                                                          return Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Console.log("done"));
                                                                      });
                                                                  });
                                                              });
                                                          });
                                                      });
                                                  });
                                              });
                                          });
                                      });
                                  });
                              });
                          });
                      });
                  });
              };
              throw new Error("Failed pattern match at Main line 115, column 1 - line 147, column 1: " + [ _6.constructor.name ]);
          });
      });
  }));
  var main = usbmain;
  var fixup_adc_values = function (x) {
      var _55 = Data_Array.uncons(x);
      if (_55 instanceof Data_Maybe.Just) {
          var _56 = Data_Array.uncons(_55.value0.tail);
          if (_56 instanceof Data_Maybe.Just) {
              return Data_Array.cons((256 * _55.value0.head | 0) + _56.value0.head | 0)(fixup_adc_values(_56.value0.tail));
          };
          if (_56 instanceof Data_Maybe.Nothing) {
              return [  ];
          };
          throw new Error("Failed pattern match: " + [ _56.constructor.name ]);
      };
      if (_55 instanceof Data_Maybe.Nothing) {
          return [  ];
      };
      throw new Error("Failed pattern match: " + [ _55.constructor.name ]);
  };
  var getRawSensorData = function (cid) {
      return function (f) {
          return Control_Monad_Aff.runAff(function (err) {
              return Control_Monad_Eff_Console.log(Control_Monad_Eff_Exception.message(err));
          })(f)(Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.receiveAff(cid))(function (_10) {
              var vals = fixup_adc_values(System_ArrayBuffers_Types.arrayFromTypedArray(System_ArrayBuffers_Types.fromArrayBuffer(System_ArrayBuffers_Types.uint8TAC)(_10.value1)));
              return Prelude["return"](Control_Monad_Aff.applicativeAff)(vals);
          }));
      };
  };
  var blinkLights = function (n) {
      return function (cid) {
          if (n > 0) {
              return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.sendAff(cid)(1)(System_ArrayBuffers_Types.buffer(ledbuf_1)))(function () {
                  return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.sendAff(cid)(1)(System_ArrayBuffers_Types.buffer(ledbuf_2)))(function () {
                      return Prelude.bind(Control_Monad_Aff.bindAff)(System_USB_HID.sendAff(cid)(1)(System_ArrayBuffers_Types.buffer(ledbuf_3)))(function () {
                          return blinkLights(n - 1)(cid);
                      });
                  });
              });
          };
          return Prelude["return"](Control_Monad_Aff.applicativeAff)(Prelude.unit);
      };
  };
  exports["main"] = main;
  exports["serialmain"] = serialmain;
  exports["getRawSensorData"] = getRawSensorData;
  exports["justConnect"] = justConnect;
  exports["manyreps"] = manyreps;
  exports["blinkLights"] = blinkLights;
  exports["ledbuf_3"] = ledbuf_3;
  exports["ledbuf_2"] = ledbuf_2;
  exports["ledbuf_1"] = ledbuf_1;
  exports["usbmain"] = usbmain;
  exports["getStringDesc"] = getStringDesc;
  exports["processusbFRstring"] = processusbFRstring;
  exports["fixup_adc_values"] = fixup_adc_values;
  exports["wireUint16toInt"] = wireUint16toInt;
  exports["usbstr2str"] = usbstr2str;
  exports["usbutf16toChar"] = usbutf16toChar;
  exports["make_string_request"] = make_string_request;
  exports["request_string_bf"] = request_string_bf;
  exports["showByte2"] = showByte2;
  exports["showByte"] = showByte;
  exports["showByte2'"] = showByte2$prime;
  exports["showByte'"] = showByte$prime;
  exports["thearrbuf"] = thearrbuf;;
 
})(PS["Main"] = PS["Main"] || {});