Merge Speedometer 2.0 fixes up to r217121 to browserbench.org
[WebKit-https.git] / Websites / browserbench.org / Speedometer2.0 / resources / todomvc / functional-prog-examples / elm / dist / elm.js
1
2 (function() {
3 'use strict';
4
5 function F2(fun)
6 {
7   function wrapper(a) { return function(b) { return fun(a,b); }; }
8   wrapper.arity = 2;
9   wrapper.func = fun;
10   return wrapper;
11 }
12
13 function F3(fun)
14 {
15   function wrapper(a) {
16     return function(b) { return function(c) { return fun(a, b, c); }; };
17   }
18   wrapper.arity = 3;
19   wrapper.func = fun;
20   return wrapper;
21 }
22
23 function F4(fun)
24 {
25   function wrapper(a) { return function(b) { return function(c) {
26     return function(d) { return fun(a, b, c, d); }; }; };
27   }
28   wrapper.arity = 4;
29   wrapper.func = fun;
30   return wrapper;
31 }
32
33 function F5(fun)
34 {
35   function wrapper(a) { return function(b) { return function(c) {
36     return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
37   }
38   wrapper.arity = 5;
39   wrapper.func = fun;
40   return wrapper;
41 }
42
43 function F6(fun)
44 {
45   function wrapper(a) { return function(b) { return function(c) {
46     return function(d) { return function(e) { return function(f) {
47     return fun(a, b, c, d, e, f); }; }; }; }; };
48   }
49   wrapper.arity = 6;
50   wrapper.func = fun;
51   return wrapper;
52 }
53
54 function F7(fun)
55 {
56   function wrapper(a) { return function(b) { return function(c) {
57     return function(d) { return function(e) { return function(f) {
58     return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
59   }
60   wrapper.arity = 7;
61   wrapper.func = fun;
62   return wrapper;
63 }
64
65 function F8(fun)
66 {
67   function wrapper(a) { return function(b) { return function(c) {
68     return function(d) { return function(e) { return function(f) {
69     return function(g) { return function(h) {
70     return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
71   }
72   wrapper.arity = 8;
73   wrapper.func = fun;
74   return wrapper;
75 }
76
77 function F9(fun)
78 {
79   function wrapper(a) { return function(b) { return function(c) {
80     return function(d) { return function(e) { return function(f) {
81     return function(g) { return function(h) { return function(i) {
82     return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
83   }
84   wrapper.arity = 9;
85   wrapper.func = fun;
86   return wrapper;
87 }
88
89 function A2(fun, a, b)
90 {
91   return fun.arity === 2
92     ? fun.func(a, b)
93     : fun(a)(b);
94 }
95 function A3(fun, a, b, c)
96 {
97   return fun.arity === 3
98     ? fun.func(a, b, c)
99     : fun(a)(b)(c);
100 }
101 function A4(fun, a, b, c, d)
102 {
103   return fun.arity === 4
104     ? fun.func(a, b, c, d)
105     : fun(a)(b)(c)(d);
106 }
107 function A5(fun, a, b, c, d, e)
108 {
109   return fun.arity === 5
110     ? fun.func(a, b, c, d, e)
111     : fun(a)(b)(c)(d)(e);
112 }
113 function A6(fun, a, b, c, d, e, f)
114 {
115   return fun.arity === 6
116     ? fun.func(a, b, c, d, e, f)
117     : fun(a)(b)(c)(d)(e)(f);
118 }
119 function A7(fun, a, b, c, d, e, f, g)
120 {
121   return fun.arity === 7
122     ? fun.func(a, b, c, d, e, f, g)
123     : fun(a)(b)(c)(d)(e)(f)(g);
124 }
125 function A8(fun, a, b, c, d, e, f, g, h)
126 {
127   return fun.arity === 8
128     ? fun.func(a, b, c, d, e, f, g, h)
129     : fun(a)(b)(c)(d)(e)(f)(g)(h);
130 }
131 function A9(fun, a, b, c, d, e, f, g, h, i)
132 {
133   return fun.arity === 9
134     ? fun.func(a, b, c, d, e, f, g, h, i)
135     : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
136 }
137
138 //import Native.Utils //
139
140 var _elm_lang$core$Native_Basics = function() {
141
142 function div(a, b)
143 {
144     return (a / b) | 0;
145 }
146 function rem(a, b)
147 {
148     return a % b;
149 }
150 function mod(a, b)
151 {
152     if (b === 0)
153     {
154         throw new Error('Cannot perform mod 0. Division by zero error.');
155     }
156     var r = a % b;
157     var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r + b) : -mod(-a, -b));
158
159     return m === b ? 0 : m;
160 }
161 function logBase(base, n)
162 {
163     return Math.log(n) / Math.log(base);
164 }
165 function negate(n)
166 {
167     return -n;
168 }
169 function abs(n)
170 {
171     return n < 0 ? -n : n;
172 }
173
174 function min(a, b)
175 {
176     return _elm_lang$core$Native_Utils.cmp(a, b) < 0 ? a : b;
177 }
178 function max(a, b)
179 {
180     return _elm_lang$core$Native_Utils.cmp(a, b) > 0 ? a : b;
181 }
182 function clamp(lo, hi, n)
183 {
184     return _elm_lang$core$Native_Utils.cmp(n, lo) < 0
185         ? lo
186         : _elm_lang$core$Native_Utils.cmp(n, hi) > 0
187             ? hi
188             : n;
189 }
190
191 var ord = ['LT', 'EQ', 'GT'];
192
193 function compare(x, y)
194 {
195     return { ctor: ord[_elm_lang$core$Native_Utils.cmp(x, y) + 1] };
196 }
197
198 function xor(a, b)
199 {
200     return a !== b;
201 }
202 function not(b)
203 {
204     return !b;
205 }
206 function isInfinite(n)
207 {
208     return n === Infinity || n === -Infinity;
209 }
210
211 function truncate(n)
212 {
213     return n | 0;
214 }
215
216 function degrees(d)
217 {
218     return d * Math.PI / 180;
219 }
220 function turns(t)
221 {
222     return 2 * Math.PI * t;
223 }
224 function fromPolar(point)
225 {
226     var r = point._0;
227     var t = point._1;
228     return _elm_lang$core$Native_Utils.Tuple2(r * Math.cos(t), r * Math.sin(t));
229 }
230 function toPolar(point)
231 {
232     var x = point._0;
233     var y = point._1;
234     return _elm_lang$core$Native_Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y, x));
235 }
236
237 return {
238     div: F2(div),
239     rem: F2(rem),
240     mod: F2(mod),
241
242     pi: Math.PI,
243     e: Math.E,
244     cos: Math.cos,
245     sin: Math.sin,
246     tan: Math.tan,
247     acos: Math.acos,
248     asin: Math.asin,
249     atan: Math.atan,
250     atan2: F2(Math.atan2),
251
252     degrees: degrees,
253     turns: turns,
254     fromPolar: fromPolar,
255     toPolar: toPolar,
256
257     sqrt: Math.sqrt,
258     logBase: F2(logBase),
259     negate: negate,
260     abs: abs,
261     min: F2(min),
262     max: F2(max),
263     clamp: F3(clamp),
264     compare: F2(compare),
265
266     xor: F2(xor),
267     not: not,
268
269     truncate: truncate,
270     ceiling: Math.ceil,
271     floor: Math.floor,
272     round: Math.round,
273     toFloat: function(x) { return x; },
274     isNaN: isNaN,
275     isInfinite: isInfinite
276 };
277
278 }();
279 //import //
280
281 var _elm_lang$core$Native_Utils = function() {
282
283 // COMPARISONS
284
285 function eq(x, y)
286 {
287     var stack = [];
288     var isEqual = eqHelp(x, y, 0, stack);
289     var pair;
290     while (isEqual && (pair = stack.pop()))
291     {
292         isEqual = eqHelp(pair.x, pair.y, 0, stack);
293     }
294     return isEqual;
295 }
296
297
298 function eqHelp(x, y, depth, stack)
299 {
300     if (depth > 100)
301     {
302         stack.push({ x: x, y: y });
303         return true;
304     }
305
306     if (x === y)
307     {
308         return true;
309     }
310
311     if (typeof x !== 'object')
312     {
313         if (typeof x === 'function')
314         {
315             throw new Error(
316                 'Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense.'
317                 + ' Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#=='
318                 + ' which describes why it is this way and what the better version will look like.'
319             );
320         }
321         return false;
322     }
323
324     if (x === null || y === null)
325     {
326         return false
327     }
328
329     if (x instanceof Date)
330     {
331         return x.getTime() === y.getTime();
332     }
333
334     if (!('ctor' in x))
335     {
336         for (var key in x)
337         {
338             if (!eqHelp(x[key], y[key], depth + 1, stack))
339             {
340                 return false;
341             }
342         }
343         return true;
344     }
345
346     // convert Dicts and Sets to lists
347     if (x.ctor === 'RBNode_elm_builtin' || x.ctor === 'RBEmpty_elm_builtin')
348     {
349         x = _elm_lang$core$Dict$toList(x);
350         y = _elm_lang$core$Dict$toList(y);
351     }
352     if (x.ctor === 'Set_elm_builtin')
353     {
354         x = _elm_lang$core$Set$toList(x);
355         y = _elm_lang$core$Set$toList(y);
356     }
357
358     // check if lists are equal without recursion
359     if (x.ctor === '::')
360     {
361         var a = x;
362         var b = y;
363         while (a.ctor === '::' && b.ctor === '::')
364         {
365             if (!eqHelp(a._0, b._0, depth + 1, stack))
366             {
367                 return false;
368             }
369             a = a._1;
370             b = b._1;
371         }
372         return a.ctor === b.ctor;
373     }
374
375     // check if Arrays are equal
376     if (x.ctor === '_Array')
377     {
378         var xs = _elm_lang$core$Native_Array.toJSArray(x);
379         var ys = _elm_lang$core$Native_Array.toJSArray(y);
380         if (xs.length !== ys.length)
381         {
382             return false;
383         }
384         for (var i = 0; i < xs.length; i++)
385         {
386             if (!eqHelp(xs[i], ys[i], depth + 1, stack))
387             {
388                 return false;
389             }
390         }
391         return true;
392     }
393
394     if (!eqHelp(x.ctor, y.ctor, depth + 1, stack))
395     {
396         return false;
397     }
398
399     for (var key in x)
400     {
401         if (!eqHelp(x[key], y[key], depth + 1, stack))
402         {
403             return false;
404         }
405     }
406     return true;
407 }
408
409 // Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
410 // the particular integer values assigned to LT, EQ, and GT.
411
412 var LT = -1, EQ = 0, GT = 1;
413
414 function cmp(x, y)
415 {
416     if (typeof x !== 'object')
417     {
418         return x === y ? EQ : x < y ? LT : GT;
419     }
420
421     if (x instanceof String)
422     {
423         var a = x.valueOf();
424         var b = y.valueOf();
425         return a === b ? EQ : a < b ? LT : GT;
426     }
427
428     if (x.ctor === '::' || x.ctor === '[]')
429     {
430         while (x.ctor === '::' && y.ctor === '::')
431         {
432             var ord = cmp(x._0, y._0);
433             if (ord !== EQ)
434             {
435                 return ord;
436             }
437             x = x._1;
438             y = y._1;
439         }
440         return x.ctor === y.ctor ? EQ : x.ctor === '[]' ? LT : GT;
441     }
442
443     if (x.ctor.slice(0, 6) === '_Tuple')
444     {
445         var ord;
446         var n = x.ctor.slice(6) - 0;
447         var err = 'cannot compare tuples with more than 6 elements.';
448         if (n === 0) return EQ;
449         if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord;
450         if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord;
451         if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord;
452         if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord;
453         if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord;
454         if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord;
455         if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } }
456         return EQ;
457     }
458
459     throw new Error(
460         'Comparison error: comparison is only defined on ints, '
461         + 'floats, times, chars, strings, lists of comparable values, '
462         + 'and tuples of comparable values.'
463     );
464 }
465
466
467 // COMMON VALUES
468
469 var Tuple0 = {
470     ctor: '_Tuple0'
471 };
472
473 function Tuple2(x, y)
474 {
475     return {
476         ctor: '_Tuple2',
477         _0: x,
478         _1: y
479     };
480 }
481
482 function chr(c)
483 {
484     return new String(c);
485 }
486
487
488 // GUID
489
490 var count = 0;
491 function guid(_)
492 {
493     return count++;
494 }
495
496
497 // RECORDS
498
499 function update(oldRecord, updatedFields)
500 {
501     var newRecord = {};
502     for (var key in oldRecord)
503     {
504         var value = (key in updatedFields) ? updatedFields[key] : oldRecord[key];
505         newRecord[key] = value;
506     }
507     return newRecord;
508 }
509
510
511 //// LIST STUFF ////
512
513 var Nil = { ctor: '[]' };
514
515 function Cons(hd, tl)
516 {
517     return {
518         ctor: '::',
519         _0: hd,
520         _1: tl
521     };
522 }
523
524 function append(xs, ys)
525 {
526     // append Strings
527     if (typeof xs === 'string')
528     {
529         return xs + ys;
530     }
531
532     // append Lists
533     if (xs.ctor === '[]')
534     {
535         return ys;
536     }
537     var root = Cons(xs._0, Nil);
538     var curr = root;
539     xs = xs._1;
540     while (xs.ctor !== '[]')
541     {
542         curr._1 = Cons(xs._0, Nil);
543         xs = xs._1;
544         curr = curr._1;
545     }
546     curr._1 = ys;
547     return root;
548 }
549
550
551 // CRASHES
552
553 function crash(moduleName, region)
554 {
555     return function(message) {
556         throw new Error(
557             'Ran into a `Debug.crash` in module `' + moduleName + '` ' + regionToString(region) + '\n'
558             + 'The message provided by the code author is:\n\n    '
559             + message
560         );
561     };
562 }
563
564 function crashCase(moduleName, region, value)
565 {
566     return function(message) {
567         throw new Error(
568             'Ran into a `Debug.crash` in module `' + moduleName + '`\n\n'
569             + 'This was caused by the `case` expression ' + regionToString(region) + '.\n'
570             + 'One of the branches ended with a crash and the following value got through:\n\n    ' + toString(value) + '\n\n'
571             + 'The message provided by the code author is:\n\n    '
572             + message
573         );
574     };
575 }
576
577 function regionToString(region)
578 {
579     if (region.start.line == region.end.line)
580     {
581         return 'on line ' + region.start.line;
582     }
583     return 'between lines ' + region.start.line + ' and ' + region.end.line;
584 }
585
586
587 // TO STRING
588
589 function toString(v)
590 {
591     var type = typeof v;
592     if (type === 'function')
593     {
594         var name = v.func ? v.func.name : v.name;
595         return '<function' + (name === '' ? '' : ':') + name + '>';
596     }
597
598     if (type === 'boolean')
599     {
600         return v ? 'True' : 'False';
601     }
602
603     if (type === 'number')
604     {
605         return v + '';
606     }
607
608     if (v instanceof String)
609     {
610         return '\'' + addSlashes(v, true) + '\'';
611     }
612
613     if (type === 'string')
614     {
615         return '"' + addSlashes(v, false) + '"';
616     }
617
618     if (v === null)
619     {
620         return 'null';
621     }
622
623     if (type === 'object' && 'ctor' in v)
624     {
625         var ctorStarter = v.ctor.substring(0, 5);
626
627         if (ctorStarter === '_Tupl')
628         {
629             var output = [];
630             for (var k in v)
631             {
632                 if (k === 'ctor') continue;
633                 output.push(toString(v[k]));
634             }
635             return '(' + output.join(',') + ')';
636         }
637
638         if (ctorStarter === '_Task')
639         {
640             return '<task>'
641         }
642
643         if (v.ctor === '_Array')
644         {
645             var list = _elm_lang$core$Array$toList(v);
646             return 'Array.fromList ' + toString(list);
647         }
648
649         if (v.ctor === '<decoder>')
650         {
651             return '<decoder>';
652         }
653
654         if (v.ctor === '_Process')
655         {
656             return '<process:' + v.id + '>';
657         }
658
659         if (v.ctor === '::')
660         {
661             var output = '[' + toString(v._0);
662             v = v._1;
663             while (v.ctor === '::')
664             {
665                 output += ',' + toString(v._0);
666                 v = v._1;
667             }
668             return output + ']';
669         }
670
671         if (v.ctor === '[]')
672         {
673             return '[]';
674         }
675
676         if (v.ctor === 'Set_elm_builtin')
677         {
678             return 'Set.fromList ' + toString(_elm_lang$core$Set$toList(v));
679         }
680
681         if (v.ctor === 'RBNode_elm_builtin' || v.ctor === 'RBEmpty_elm_builtin')
682         {
683             return 'Dict.fromList ' + toString(_elm_lang$core$Dict$toList(v));
684         }
685
686         var output = '';
687         for (var i in v)
688         {
689             if (i === 'ctor') continue;
690             var str = toString(v[i]);
691             var c0 = str[0];
692             var parenless = c0 === '{' || c0 === '(' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
693             output += ' ' + (parenless ? str : '(' + str + ')');
694         }
695         return v.ctor + output;
696     }
697
698     if (type === 'object')
699     {
700         if (v instanceof Date)
701         {
702             return '<' + v.toString() + '>';
703         }
704
705         if (v.elm_web_socket)
706         {
707             return '<websocket>';
708         }
709
710         var output = [];
711         for (var k in v)
712         {
713             output.push(k + ' = ' + toString(v[k]));
714         }
715         if (output.length === 0)
716         {
717             return '{}';
718         }
719         return '{ ' + output.join(', ') + ' }';
720     }
721
722     return '<internal structure>';
723 }
724
725 function addSlashes(str, isChar)
726 {
727     var s = str.replace(/\\/g, '\\\\')
728               .replace(/\n/g, '\\n')
729               .replace(/\t/g, '\\t')
730               .replace(/\r/g, '\\r')
731               .replace(/\v/g, '\\v')
732               .replace(/\0/g, '\\0');
733     if (isChar)
734     {
735         return s.replace(/\'/g, '\\\'');
736     }
737     else
738     {
739         return s.replace(/\"/g, '\\"');
740     }
741 }
742
743
744 return {
745     eq: eq,
746     cmp: cmp,
747     Tuple0: Tuple0,
748     Tuple2: Tuple2,
749     chr: chr,
750     update: update,
751     guid: guid,
752
753     append: F2(append),
754
755     crash: crash,
756     crashCase: crashCase,
757
758     toString: toString
759 };
760
761 }();
762 var _elm_lang$core$Basics$uncurry = F2(
763     function (f, _p0) {
764         var _p1 = _p0;
765         return A2(f, _p1._0, _p1._1);
766     });
767 var _elm_lang$core$Basics$curry = F3(
768     function (f, a, b) {
769         return f(
770             {ctor: '_Tuple2', _0: a, _1: b});
771     });
772 var _elm_lang$core$Basics$flip = F3(
773     function (f, b, a) {
774         return A2(f, a, b);
775     });
776 var _elm_lang$core$Basics$snd = function (_p2) {
777     var _p3 = _p2;
778     return _p3._1;
779 };
780 var _elm_lang$core$Basics$fst = function (_p4) {
781     var _p5 = _p4;
782     return _p5._0;
783 };
784 var _elm_lang$core$Basics$always = F2(
785     function (a, _p6) {
786         return a;
787     });
788 var _elm_lang$core$Basics$identity = function (x) {
789     return x;
790 };
791 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
792 _elm_lang$core$Basics_ops['<|'] = F2(
793     function (f, x) {
794         return f(x);
795     });
796 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
797 _elm_lang$core$Basics_ops['|>'] = F2(
798     function (x, f) {
799         return f(x);
800     });
801 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
802 _elm_lang$core$Basics_ops['>>'] = F3(
803     function (f, g, x) {
804         return g(
805             f(x));
806     });
807 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
808 _elm_lang$core$Basics_ops['<<'] = F3(
809     function (g, f, x) {
810         return g(
811             f(x));
812     });
813 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
814 _elm_lang$core$Basics_ops['++'] = _elm_lang$core$Native_Utils.append;
815 var _elm_lang$core$Basics$toString = _elm_lang$core$Native_Utils.toString;
816 var _elm_lang$core$Basics$isInfinite = _elm_lang$core$Native_Basics.isInfinite;
817 var _elm_lang$core$Basics$isNaN = _elm_lang$core$Native_Basics.isNaN;
818 var _elm_lang$core$Basics$toFloat = _elm_lang$core$Native_Basics.toFloat;
819 var _elm_lang$core$Basics$ceiling = _elm_lang$core$Native_Basics.ceiling;
820 var _elm_lang$core$Basics$floor = _elm_lang$core$Native_Basics.floor;
821 var _elm_lang$core$Basics$truncate = _elm_lang$core$Native_Basics.truncate;
822 var _elm_lang$core$Basics$round = _elm_lang$core$Native_Basics.round;
823 var _elm_lang$core$Basics$not = _elm_lang$core$Native_Basics.not;
824 var _elm_lang$core$Basics$xor = _elm_lang$core$Native_Basics.xor;
825 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
826 _elm_lang$core$Basics_ops['||'] = _elm_lang$core$Native_Basics.or;
827 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
828 _elm_lang$core$Basics_ops['&&'] = _elm_lang$core$Native_Basics.and;
829 var _elm_lang$core$Basics$max = _elm_lang$core$Native_Basics.max;
830 var _elm_lang$core$Basics$min = _elm_lang$core$Native_Basics.min;
831 var _elm_lang$core$Basics$compare = _elm_lang$core$Native_Basics.compare;
832 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
833 _elm_lang$core$Basics_ops['>='] = _elm_lang$core$Native_Basics.ge;
834 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
835 _elm_lang$core$Basics_ops['<='] = _elm_lang$core$Native_Basics.le;
836 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
837 _elm_lang$core$Basics_ops['>'] = _elm_lang$core$Native_Basics.gt;
838 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
839 _elm_lang$core$Basics_ops['<'] = _elm_lang$core$Native_Basics.lt;
840 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
841 _elm_lang$core$Basics_ops['/='] = _elm_lang$core$Native_Basics.neq;
842 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
843 _elm_lang$core$Basics_ops['=='] = _elm_lang$core$Native_Basics.eq;
844 var _elm_lang$core$Basics$e = _elm_lang$core$Native_Basics.e;
845 var _elm_lang$core$Basics$pi = _elm_lang$core$Native_Basics.pi;
846 var _elm_lang$core$Basics$clamp = _elm_lang$core$Native_Basics.clamp;
847 var _elm_lang$core$Basics$logBase = _elm_lang$core$Native_Basics.logBase;
848 var _elm_lang$core$Basics$abs = _elm_lang$core$Native_Basics.abs;
849 var _elm_lang$core$Basics$negate = _elm_lang$core$Native_Basics.negate;
850 var _elm_lang$core$Basics$sqrt = _elm_lang$core$Native_Basics.sqrt;
851 var _elm_lang$core$Basics$atan2 = _elm_lang$core$Native_Basics.atan2;
852 var _elm_lang$core$Basics$atan = _elm_lang$core$Native_Basics.atan;
853 var _elm_lang$core$Basics$asin = _elm_lang$core$Native_Basics.asin;
854 var _elm_lang$core$Basics$acos = _elm_lang$core$Native_Basics.acos;
855 var _elm_lang$core$Basics$tan = _elm_lang$core$Native_Basics.tan;
856 var _elm_lang$core$Basics$sin = _elm_lang$core$Native_Basics.sin;
857 var _elm_lang$core$Basics$cos = _elm_lang$core$Native_Basics.cos;
858 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
859 _elm_lang$core$Basics_ops['^'] = _elm_lang$core$Native_Basics.exp;
860 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
861 _elm_lang$core$Basics_ops['%'] = _elm_lang$core$Native_Basics.mod;
862 var _elm_lang$core$Basics$rem = _elm_lang$core$Native_Basics.rem;
863 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
864 _elm_lang$core$Basics_ops['//'] = _elm_lang$core$Native_Basics.div;
865 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
866 _elm_lang$core$Basics_ops['/'] = _elm_lang$core$Native_Basics.floatDiv;
867 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
868 _elm_lang$core$Basics_ops['*'] = _elm_lang$core$Native_Basics.mul;
869 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
870 _elm_lang$core$Basics_ops['-'] = _elm_lang$core$Native_Basics.sub;
871 var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
872 _elm_lang$core$Basics_ops['+'] = _elm_lang$core$Native_Basics.add;
873 var _elm_lang$core$Basics$toPolar = _elm_lang$core$Native_Basics.toPolar;
874 var _elm_lang$core$Basics$fromPolar = _elm_lang$core$Native_Basics.fromPolar;
875 var _elm_lang$core$Basics$turns = _elm_lang$core$Native_Basics.turns;
876 var _elm_lang$core$Basics$degrees = _elm_lang$core$Native_Basics.degrees;
877 var _elm_lang$core$Basics$radians = function (t) {
878     return t;
879 };
880 var _elm_lang$core$Basics$GT = {ctor: 'GT'};
881 var _elm_lang$core$Basics$EQ = {ctor: 'EQ'};
882 var _elm_lang$core$Basics$LT = {ctor: 'LT'};
883 var _elm_lang$core$Basics$Never = function (a) {
884     return {ctor: 'Never', _0: a};
885 };
886
887 //import Native.Utils //
888
889 var _elm_lang$core$Native_Debug = function() {
890
891 function log(tag, value)
892 {
893     var msg = tag + ': ' + _elm_lang$core$Native_Utils.toString(value);
894     var process = process || {};
895     if (process.stdout)
896     {
897         process.stdout.write(msg);
898     }
899     else
900     {
901         // console.log(msg);
902     }
903     return value;
904 }
905
906 function crash(message)
907 {
908     throw new Error(message);
909 }
910
911 return {
912     crash: crash,
913     log: F2(log)
914 };
915
916 }();
917 var _elm_lang$core$Debug$crash = _elm_lang$core$Native_Debug.crash;
918 var _elm_lang$core$Debug$log = _elm_lang$core$Native_Debug.log;
919
920 var _elm_lang$core$Maybe$withDefault = F2(
921     function ($default, maybe) {
922         var _p0 = maybe;
923         if (_p0.ctor === 'Just') {
924             return _p0._0;
925         } else {
926             return $default;
927         }
928     });
929 var _elm_lang$core$Maybe$Nothing = {ctor: 'Nothing'};
930 var _elm_lang$core$Maybe$oneOf = function (maybes) {
931     oneOf:
932     while (true) {
933         var _p1 = maybes;
934         if (_p1.ctor === '[]') {
935             return _elm_lang$core$Maybe$Nothing;
936         } else {
937             var _p3 = _p1._0;
938             var _p2 = _p3;
939             if (_p2.ctor === 'Nothing') {
940                 var _v3 = _p1._1;
941                 maybes = _v3;
942                 continue oneOf;
943             } else {
944                 return _p3;
945             }
946         }
947     }
948 };
949 var _elm_lang$core$Maybe$andThen = F2(
950     function (maybeValue, callback) {
951         var _p4 = maybeValue;
952         if (_p4.ctor === 'Just') {
953             return callback(_p4._0);
954         } else {
955             return _elm_lang$core$Maybe$Nothing;
956         }
957     });
958 var _elm_lang$core$Maybe$Just = function (a) {
959     return {ctor: 'Just', _0: a};
960 };
961 var _elm_lang$core$Maybe$map = F2(
962     function (f, maybe) {
963         var _p5 = maybe;
964         if (_p5.ctor === 'Just') {
965             return _elm_lang$core$Maybe$Just(
966                 f(_p5._0));
967         } else {
968             return _elm_lang$core$Maybe$Nothing;
969         }
970     });
971 var _elm_lang$core$Maybe$map2 = F3(
972     function (func, ma, mb) {
973         var _p6 = {ctor: '_Tuple2', _0: ma, _1: mb};
974         if (((_p6.ctor === '_Tuple2') && (_p6._0.ctor === 'Just')) && (_p6._1.ctor === 'Just')) {
975             return _elm_lang$core$Maybe$Just(
976                 A2(func, _p6._0._0, _p6._1._0));
977         } else {
978             return _elm_lang$core$Maybe$Nothing;
979         }
980     });
981 var _elm_lang$core$Maybe$map3 = F4(
982     function (func, ma, mb, mc) {
983         var _p7 = {ctor: '_Tuple3', _0: ma, _1: mb, _2: mc};
984         if ((((_p7.ctor === '_Tuple3') && (_p7._0.ctor === 'Just')) && (_p7._1.ctor === 'Just')) && (_p7._2.ctor === 'Just')) {
985             return _elm_lang$core$Maybe$Just(
986                 A3(func, _p7._0._0, _p7._1._0, _p7._2._0));
987         } else {
988             return _elm_lang$core$Maybe$Nothing;
989         }
990     });
991 var _elm_lang$core$Maybe$map4 = F5(
992     function (func, ma, mb, mc, md) {
993         var _p8 = {ctor: '_Tuple4', _0: ma, _1: mb, _2: mc, _3: md};
994         if (((((_p8.ctor === '_Tuple4') && (_p8._0.ctor === 'Just')) && (_p8._1.ctor === 'Just')) && (_p8._2.ctor === 'Just')) && (_p8._3.ctor === 'Just')) {
995             return _elm_lang$core$Maybe$Just(
996                 A4(func, _p8._0._0, _p8._1._0, _p8._2._0, _p8._3._0));
997         } else {
998             return _elm_lang$core$Maybe$Nothing;
999         }
1000     });
1001 var _elm_lang$core$Maybe$map5 = F6(
1002     function (func, ma, mb, mc, md, me) {
1003         var _p9 = {ctor: '_Tuple5', _0: ma, _1: mb, _2: mc, _3: md, _4: me};
1004         if ((((((_p9.ctor === '_Tuple5') && (_p9._0.ctor === 'Just')) && (_p9._1.ctor === 'Just')) && (_p9._2.ctor === 'Just')) && (_p9._3.ctor === 'Just')) && (_p9._4.ctor === 'Just')) {
1005             return _elm_lang$core$Maybe$Just(
1006                 A5(func, _p9._0._0, _p9._1._0, _p9._2._0, _p9._3._0, _p9._4._0));
1007         } else {
1008             return _elm_lang$core$Maybe$Nothing;
1009         }
1010     });
1011
1012 //import Native.Utils //
1013
1014 var _elm_lang$core$Native_List = function() {
1015
1016 var Nil = { ctor: '[]' };
1017
1018 function Cons(hd, tl)
1019 {
1020     return { ctor: '::', _0: hd, _1: tl };
1021 }
1022
1023 function fromArray(arr)
1024 {
1025     var out = Nil;
1026     for (var i = arr.length; i--; )
1027     {
1028         out = Cons(arr[i], out);
1029     }
1030     return out;
1031 }
1032
1033 function toArray(xs)
1034 {
1035     var out = [];
1036     while (xs.ctor !== '[]')
1037     {
1038         out.push(xs._0);
1039         xs = xs._1;
1040     }
1041     return out;
1042 }
1043
1044
1045 function range(lo, hi)
1046 {
1047     var list = Nil;
1048     if (lo <= hi)
1049     {
1050         do
1051         {
1052             list = Cons(hi, list);
1053         }
1054         while (hi-- > lo);
1055     }
1056     return list;
1057 }
1058
1059 function foldr(f, b, xs)
1060 {
1061     var arr = toArray(xs);
1062     var acc = b;
1063     for (var i = arr.length; i--; )
1064     {
1065         acc = A2(f, arr[i], acc);
1066     }
1067     return acc;
1068 }
1069
1070 function map2(f, xs, ys)
1071 {
1072     var arr = [];
1073     while (xs.ctor !== '[]' && ys.ctor !== '[]')
1074     {
1075         arr.push(A2(f, xs._0, ys._0));
1076         xs = xs._1;
1077         ys = ys._1;
1078     }
1079     return fromArray(arr);
1080 }
1081
1082 function map3(f, xs, ys, zs)
1083 {
1084     var arr = [];
1085     while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]')
1086     {
1087         arr.push(A3(f, xs._0, ys._0, zs._0));
1088         xs = xs._1;
1089         ys = ys._1;
1090         zs = zs._1;
1091     }
1092     return fromArray(arr);
1093 }
1094
1095 function map4(f, ws, xs, ys, zs)
1096 {
1097     var arr = [];
1098     while (   ws.ctor !== '[]'
1099            && xs.ctor !== '[]'
1100            && ys.ctor !== '[]'
1101            && zs.ctor !== '[]')
1102     {
1103         arr.push(A4(f, ws._0, xs._0, ys._0, zs._0));
1104         ws = ws._1;
1105         xs = xs._1;
1106         ys = ys._1;
1107         zs = zs._1;
1108     }
1109     return fromArray(arr);
1110 }
1111
1112 function map5(f, vs, ws, xs, ys, zs)
1113 {
1114     var arr = [];
1115     while (   vs.ctor !== '[]'
1116            && ws.ctor !== '[]'
1117            && xs.ctor !== '[]'
1118            && ys.ctor !== '[]'
1119            && zs.ctor !== '[]')
1120     {
1121         arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0));
1122         vs = vs._1;
1123         ws = ws._1;
1124         xs = xs._1;
1125         ys = ys._1;
1126         zs = zs._1;
1127     }
1128     return fromArray(arr);
1129 }
1130
1131 function sortBy(f, xs)
1132 {
1133     return fromArray(toArray(xs).sort(function(a, b) {
1134         return _elm_lang$core$Native_Utils.cmp(f(a), f(b));
1135     }));
1136 }
1137
1138 function sortWith(f, xs)
1139 {
1140     return fromArray(toArray(xs).sort(function(a, b) {
1141         var ord = f(a)(b).ctor;
1142         return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1;
1143     }));
1144 }
1145
1146 return {
1147     Nil: Nil,
1148     Cons: Cons,
1149     cons: F2(Cons),
1150     toArray: toArray,
1151     fromArray: fromArray,
1152     range: range,
1153
1154     foldr: F3(foldr),
1155
1156     map2: F3(map2),
1157     map3: F4(map3),
1158     map4: F5(map4),
1159     map5: F6(map5),
1160     sortBy: F2(sortBy),
1161     sortWith: F2(sortWith)
1162 };
1163
1164 }();
1165 var _elm_lang$core$List$sortWith = _elm_lang$core$Native_List.sortWith;
1166 var _elm_lang$core$List$sortBy = _elm_lang$core$Native_List.sortBy;
1167 var _elm_lang$core$List$sort = function (xs) {
1168     return A2(_elm_lang$core$List$sortBy, _elm_lang$core$Basics$identity, xs);
1169 };
1170 var _elm_lang$core$List$drop = F2(
1171     function (n, list) {
1172         drop:
1173         while (true) {
1174             if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
1175                 return list;
1176             } else {
1177                 var _p0 = list;
1178                 if (_p0.ctor === '[]') {
1179                     return list;
1180                 } else {
1181                     var _v1 = n - 1,
1182                         _v2 = _p0._1;
1183                     n = _v1;
1184                     list = _v2;
1185                     continue drop;
1186                 }
1187             }
1188         }
1189     });
1190 var _elm_lang$core$List$map5 = _elm_lang$core$Native_List.map5;
1191 var _elm_lang$core$List$map4 = _elm_lang$core$Native_List.map4;
1192 var _elm_lang$core$List$map3 = _elm_lang$core$Native_List.map3;
1193 var _elm_lang$core$List$map2 = _elm_lang$core$Native_List.map2;
1194 var _elm_lang$core$List$any = F2(
1195     function (isOkay, list) {
1196         any:
1197         while (true) {
1198             var _p1 = list;
1199             if (_p1.ctor === '[]') {
1200                 return false;
1201             } else {
1202                 if (isOkay(_p1._0)) {
1203                     return true;
1204                 } else {
1205                     var _v4 = isOkay,
1206                         _v5 = _p1._1;
1207                     isOkay = _v4;
1208                     list = _v5;
1209                     continue any;
1210                 }
1211             }
1212         }
1213     });
1214 var _elm_lang$core$List$all = F2(
1215     function (isOkay, list) {
1216         return _elm_lang$core$Basics$not(
1217             A2(
1218                 _elm_lang$core$List$any,
1219                 function (_p2) {
1220                     return _elm_lang$core$Basics$not(
1221                         isOkay(_p2));
1222                 },
1223                 list));
1224     });
1225 var _elm_lang$core$List$foldr = _elm_lang$core$Native_List.foldr;
1226 var _elm_lang$core$List$foldl = F3(
1227     function (func, acc, list) {
1228         foldl:
1229         while (true) {
1230             var _p3 = list;
1231             if (_p3.ctor === '[]') {
1232                 return acc;
1233             } else {
1234                 var _v7 = func,
1235                     _v8 = A2(func, _p3._0, acc),
1236                     _v9 = _p3._1;
1237                 func = _v7;
1238                 acc = _v8;
1239                 list = _v9;
1240                 continue foldl;
1241             }
1242         }
1243     });
1244 var _elm_lang$core$List$length = function (xs) {
1245     return A3(
1246         _elm_lang$core$List$foldl,
1247         F2(
1248             function (_p4, i) {
1249                 return i + 1;
1250             }),
1251         0,
1252         xs);
1253 };
1254 var _elm_lang$core$List$sum = function (numbers) {
1255     return A3(
1256         _elm_lang$core$List$foldl,
1257         F2(
1258             function (x, y) {
1259                 return x + y;
1260             }),
1261         0,
1262         numbers);
1263 };
1264 var _elm_lang$core$List$product = function (numbers) {
1265     return A3(
1266         _elm_lang$core$List$foldl,
1267         F2(
1268             function (x, y) {
1269                 return x * y;
1270             }),
1271         1,
1272         numbers);
1273 };
1274 var _elm_lang$core$List$maximum = function (list) {
1275     var _p5 = list;
1276     if (_p5.ctor === '::') {
1277         return _elm_lang$core$Maybe$Just(
1278             A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$max, _p5._0, _p5._1));
1279     } else {
1280         return _elm_lang$core$Maybe$Nothing;
1281     }
1282 };
1283 var _elm_lang$core$List$minimum = function (list) {
1284     var _p6 = list;
1285     if (_p6.ctor === '::') {
1286         return _elm_lang$core$Maybe$Just(
1287             A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$min, _p6._0, _p6._1));
1288     } else {
1289         return _elm_lang$core$Maybe$Nothing;
1290     }
1291 };
1292 var _elm_lang$core$List$indexedMap = F2(
1293     function (f, xs) {
1294         return A3(
1295             _elm_lang$core$List$map2,
1296             f,
1297             _elm_lang$core$Native_List.range(
1298                 0,
1299                 _elm_lang$core$List$length(xs) - 1),
1300             xs);
1301     });
1302 var _elm_lang$core$List$member = F2(
1303     function (x, xs) {
1304         return A2(
1305             _elm_lang$core$List$any,
1306             function (a) {
1307                 return _elm_lang$core$Native_Utils.eq(a, x);
1308             },
1309             xs);
1310     });
1311 var _elm_lang$core$List$isEmpty = function (xs) {
1312     var _p7 = xs;
1313     if (_p7.ctor === '[]') {
1314         return true;
1315     } else {
1316         return false;
1317     }
1318 };
1319 var _elm_lang$core$List$tail = function (list) {
1320     var _p8 = list;
1321     if (_p8.ctor === '::') {
1322         return _elm_lang$core$Maybe$Just(_p8._1);
1323     } else {
1324         return _elm_lang$core$Maybe$Nothing;
1325     }
1326 };
1327 var _elm_lang$core$List$head = function (list) {
1328     var _p9 = list;
1329     if (_p9.ctor === '::') {
1330         return _elm_lang$core$Maybe$Just(_p9._0);
1331     } else {
1332         return _elm_lang$core$Maybe$Nothing;
1333     }
1334 };
1335 var _elm_lang$core$List_ops = _elm_lang$core$List_ops || {};
1336 _elm_lang$core$List_ops['::'] = _elm_lang$core$Native_List.cons;
1337 var _elm_lang$core$List$map = F2(
1338     function (f, xs) {
1339         return A3(
1340             _elm_lang$core$List$foldr,
1341             F2(
1342                 function (x, acc) {
1343                     return A2(
1344                         _elm_lang$core$List_ops['::'],
1345                         f(x),
1346                         acc);
1347                 }),
1348             _elm_lang$core$Native_List.fromArray(
1349                 []),
1350             xs);
1351     });
1352 var _elm_lang$core$List$filter = F2(
1353     function (pred, xs) {
1354         var conditionalCons = F2(
1355             function (x, xs$) {
1356                 return pred(x) ? A2(_elm_lang$core$List_ops['::'], x, xs$) : xs$;
1357             });
1358         return A3(
1359             _elm_lang$core$List$foldr,
1360             conditionalCons,
1361             _elm_lang$core$Native_List.fromArray(
1362                 []),
1363             xs);
1364     });
1365 var _elm_lang$core$List$maybeCons = F3(
1366     function (f, mx, xs) {
1367         var _p10 = f(mx);
1368         if (_p10.ctor === 'Just') {
1369             return A2(_elm_lang$core$List_ops['::'], _p10._0, xs);
1370         } else {
1371             return xs;
1372         }
1373     });
1374 var _elm_lang$core$List$filterMap = F2(
1375     function (f, xs) {
1376         return A3(
1377             _elm_lang$core$List$foldr,
1378             _elm_lang$core$List$maybeCons(f),
1379             _elm_lang$core$Native_List.fromArray(
1380                 []),
1381             xs);
1382     });
1383 var _elm_lang$core$List$reverse = function (list) {
1384     return A3(
1385         _elm_lang$core$List$foldl,
1386         F2(
1387             function (x, y) {
1388                 return A2(_elm_lang$core$List_ops['::'], x, y);
1389             }),
1390         _elm_lang$core$Native_List.fromArray(
1391             []),
1392         list);
1393 };
1394 var _elm_lang$core$List$scanl = F3(
1395     function (f, b, xs) {
1396         var scan1 = F2(
1397             function (x, accAcc) {
1398                 var _p11 = accAcc;
1399                 if (_p11.ctor === '::') {
1400                     return A2(
1401                         _elm_lang$core$List_ops['::'],
1402                         A2(f, x, _p11._0),
1403                         accAcc);
1404                 } else {
1405                     return _elm_lang$core$Native_List.fromArray(
1406                         []);
1407                 }
1408             });
1409         return _elm_lang$core$List$reverse(
1410             A3(
1411                 _elm_lang$core$List$foldl,
1412                 scan1,
1413                 _elm_lang$core$Native_List.fromArray(
1414                     [b]),
1415                 xs));
1416     });
1417 var _elm_lang$core$List$append = F2(
1418     function (xs, ys) {
1419         var _p12 = ys;
1420         if (_p12.ctor === '[]') {
1421             return xs;
1422         } else {
1423             return A3(
1424                 _elm_lang$core$List$foldr,
1425                 F2(
1426                     function (x, y) {
1427                         return A2(_elm_lang$core$List_ops['::'], x, y);
1428                     }),
1429                 ys,
1430                 xs);
1431         }
1432     });
1433 var _elm_lang$core$List$concat = function (lists) {
1434     return A3(
1435         _elm_lang$core$List$foldr,
1436         _elm_lang$core$List$append,
1437         _elm_lang$core$Native_List.fromArray(
1438             []),
1439         lists);
1440 };
1441 var _elm_lang$core$List$concatMap = F2(
1442     function (f, list) {
1443         return _elm_lang$core$List$concat(
1444             A2(_elm_lang$core$List$map, f, list));
1445     });
1446 var _elm_lang$core$List$partition = F2(
1447     function (pred, list) {
1448         var step = F2(
1449             function (x, _p13) {
1450                 var _p14 = _p13;
1451                 var _p16 = _p14._0;
1452                 var _p15 = _p14._1;
1453                 return pred(x) ? {
1454                     ctor: '_Tuple2',
1455                     _0: A2(_elm_lang$core$List_ops['::'], x, _p16),
1456                     _1: _p15
1457                 } : {
1458                     ctor: '_Tuple2',
1459                     _0: _p16,
1460                     _1: A2(_elm_lang$core$List_ops['::'], x, _p15)
1461                 };
1462             });
1463         return A3(
1464             _elm_lang$core$List$foldr,
1465             step,
1466             {
1467                 ctor: '_Tuple2',
1468                 _0: _elm_lang$core$Native_List.fromArray(
1469                     []),
1470                 _1: _elm_lang$core$Native_List.fromArray(
1471                     [])
1472             },
1473             list);
1474     });
1475 var _elm_lang$core$List$unzip = function (pairs) {
1476     var step = F2(
1477         function (_p18, _p17) {
1478             var _p19 = _p18;
1479             var _p20 = _p17;
1480             return {
1481                 ctor: '_Tuple2',
1482                 _0: A2(_elm_lang$core$List_ops['::'], _p19._0, _p20._0),
1483                 _1: A2(_elm_lang$core$List_ops['::'], _p19._1, _p20._1)
1484             };
1485         });
1486     return A3(
1487         _elm_lang$core$List$foldr,
1488         step,
1489         {
1490             ctor: '_Tuple2',
1491             _0: _elm_lang$core$Native_List.fromArray(
1492                 []),
1493             _1: _elm_lang$core$Native_List.fromArray(
1494                 [])
1495         },
1496         pairs);
1497 };
1498 var _elm_lang$core$List$intersperse = F2(
1499     function (sep, xs) {
1500         var _p21 = xs;
1501         if (_p21.ctor === '[]') {
1502             return _elm_lang$core$Native_List.fromArray(
1503                 []);
1504         } else {
1505             var step = F2(
1506                 function (x, rest) {
1507                     return A2(
1508                         _elm_lang$core$List_ops['::'],
1509                         sep,
1510                         A2(_elm_lang$core$List_ops['::'], x, rest));
1511                 });
1512             var spersed = A3(
1513                 _elm_lang$core$List$foldr,
1514                 step,
1515                 _elm_lang$core$Native_List.fromArray(
1516                     []),
1517                 _p21._1);
1518             return A2(_elm_lang$core$List_ops['::'], _p21._0, spersed);
1519         }
1520     });
1521 var _elm_lang$core$List$takeReverse = F3(
1522     function (n, list, taken) {
1523         takeReverse:
1524         while (true) {
1525             if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
1526                 return taken;
1527             } else {
1528                 var _p22 = list;
1529                 if (_p22.ctor === '[]') {
1530                     return taken;
1531                 } else {
1532                     var _v23 = n - 1,
1533                         _v24 = _p22._1,
1534                         _v25 = A2(_elm_lang$core$List_ops['::'], _p22._0, taken);
1535                     n = _v23;
1536                     list = _v24;
1537                     taken = _v25;
1538                     continue takeReverse;
1539                 }
1540             }
1541         }
1542     });
1543 var _elm_lang$core$List$takeTailRec = F2(
1544     function (n, list) {
1545         return _elm_lang$core$List$reverse(
1546             A3(
1547                 _elm_lang$core$List$takeReverse,
1548                 n,
1549                 list,
1550                 _elm_lang$core$Native_List.fromArray(
1551                     [])));
1552     });
1553 var _elm_lang$core$List$takeFast = F3(
1554     function (ctr, n, list) {
1555         if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
1556             return _elm_lang$core$Native_List.fromArray(
1557                 []);
1558         } else {
1559             var _p23 = {ctor: '_Tuple2', _0: n, _1: list};
1560             _v26_5:
1561             do {
1562                 _v26_1:
1563                 do {
1564                     if (_p23.ctor === '_Tuple2') {
1565                         if (_p23._1.ctor === '[]') {
1566                             return list;
1567                         } else {
1568                             if (_p23._1._1.ctor === '::') {
1569                                 switch (_p23._0) {
1570                                     case 1:
1571                                         break _v26_1;
1572                                     case 2:
1573                                         return _elm_lang$core$Native_List.fromArray(
1574                                             [_p23._1._0, _p23._1._1._0]);
1575                                     case 3:
1576                                         if (_p23._1._1._1.ctor === '::') {
1577                                             return _elm_lang$core$Native_List.fromArray(
1578                                                 [_p23._1._0, _p23._1._1._0, _p23._1._1._1._0]);
1579                                         } else {
1580                                             break _v26_5;
1581                                         }
1582                                     default:
1583                                         if ((_p23._1._1._1.ctor === '::') && (_p23._1._1._1._1.ctor === '::')) {
1584                                             var _p28 = _p23._1._1._1._0;
1585                                             var _p27 = _p23._1._1._0;
1586                                             var _p26 = _p23._1._0;
1587                                             var _p25 = _p23._1._1._1._1._0;
1588                                             var _p24 = _p23._1._1._1._1._1;
1589                                             return (_elm_lang$core$Native_Utils.cmp(ctr, 1000) > 0) ? A2(
1590                                                 _elm_lang$core$List_ops['::'],
1591                                                 _p26,
1592                                                 A2(
1593                                                     _elm_lang$core$List_ops['::'],
1594                                                     _p27,
1595                                                     A2(
1596                                                         _elm_lang$core$List_ops['::'],
1597                                                         _p28,
1598                                                         A2(
1599                                                             _elm_lang$core$List_ops['::'],
1600                                                             _p25,
1601                                                             A2(_elm_lang$core$List$takeTailRec, n - 4, _p24))))) : A2(
1602                                                 _elm_lang$core$List_ops['::'],
1603                                                 _p26,
1604                                                 A2(
1605                                                     _elm_lang$core$List_ops['::'],
1606                                                     _p27,
1607                                                     A2(
1608                                                         _elm_lang$core$List_ops['::'],
1609                                                         _p28,
1610                                                         A2(
1611                                                             _elm_lang$core$List_ops['::'],
1612                                                             _p25,
1613                                                             A3(_elm_lang$core$List$takeFast, ctr + 1, n - 4, _p24)))));
1614                                         } else {
1615                                             break _v26_5;
1616                                         }
1617                                 }
1618                             } else {
1619                                 if (_p23._0 === 1) {
1620                                     break _v26_1;
1621                                 } else {
1622                                     break _v26_5;
1623                                 }
1624                             }
1625                         }
1626                     } else {
1627                         break _v26_5;
1628                     }
1629                 } while(false);
1630                 return _elm_lang$core$Native_List.fromArray(
1631                     [_p23._1._0]);
1632             } while(false);
1633             return list;
1634         }
1635     });
1636 var _elm_lang$core$List$take = F2(
1637     function (n, list) {
1638         return A3(_elm_lang$core$List$takeFast, 0, n, list);
1639     });
1640 var _elm_lang$core$List$repeatHelp = F3(
1641     function (result, n, value) {
1642         repeatHelp:
1643         while (true) {
1644             if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
1645                 return result;
1646             } else {
1647                 var _v27 = A2(_elm_lang$core$List_ops['::'], value, result),
1648                     _v28 = n - 1,
1649                     _v29 = value;
1650                 result = _v27;
1651                 n = _v28;
1652                 value = _v29;
1653                 continue repeatHelp;
1654             }
1655         }
1656     });
1657 var _elm_lang$core$List$repeat = F2(
1658     function (n, value) {
1659         return A3(
1660             _elm_lang$core$List$repeatHelp,
1661             _elm_lang$core$Native_List.fromArray(
1662                 []),
1663             n,
1664             value);
1665     });
1666
1667 var _elm_lang$core$Result$toMaybe = function (result) {
1668     var _p0 = result;
1669     if (_p0.ctor === 'Ok') {
1670         return _elm_lang$core$Maybe$Just(_p0._0);
1671     } else {
1672         return _elm_lang$core$Maybe$Nothing;
1673     }
1674 };
1675 var _elm_lang$core$Result$withDefault = F2(
1676     function (def, result) {
1677         var _p1 = result;
1678         if (_p1.ctor === 'Ok') {
1679             return _p1._0;
1680         } else {
1681             return def;
1682         }
1683     });
1684 var _elm_lang$core$Result$Err = function (a) {
1685     return {ctor: 'Err', _0: a};
1686 };
1687 var _elm_lang$core$Result$andThen = F2(
1688     function (result, callback) {
1689         var _p2 = result;
1690         if (_p2.ctor === 'Ok') {
1691             return callback(_p2._0);
1692         } else {
1693             return _elm_lang$core$Result$Err(_p2._0);
1694         }
1695     });
1696 var _elm_lang$core$Result$Ok = function (a) {
1697     return {ctor: 'Ok', _0: a};
1698 };
1699 var _elm_lang$core$Result$map = F2(
1700     function (func, ra) {
1701         var _p3 = ra;
1702         if (_p3.ctor === 'Ok') {
1703             return _elm_lang$core$Result$Ok(
1704                 func(_p3._0));
1705         } else {
1706             return _elm_lang$core$Result$Err(_p3._0);
1707         }
1708     });
1709 var _elm_lang$core$Result$map2 = F3(
1710     function (func, ra, rb) {
1711         var _p4 = {ctor: '_Tuple2', _0: ra, _1: rb};
1712         if (_p4._0.ctor === 'Ok') {
1713             if (_p4._1.ctor === 'Ok') {
1714                 return _elm_lang$core$Result$Ok(
1715                     A2(func, _p4._0._0, _p4._1._0));
1716             } else {
1717                 return _elm_lang$core$Result$Err(_p4._1._0);
1718             }
1719         } else {
1720             return _elm_lang$core$Result$Err(_p4._0._0);
1721         }
1722     });
1723 var _elm_lang$core$Result$map3 = F4(
1724     function (func, ra, rb, rc) {
1725         var _p5 = {ctor: '_Tuple3', _0: ra, _1: rb, _2: rc};
1726         if (_p5._0.ctor === 'Ok') {
1727             if (_p5._1.ctor === 'Ok') {
1728                 if (_p5._2.ctor === 'Ok') {
1729                     return _elm_lang$core$Result$Ok(
1730                         A3(func, _p5._0._0, _p5._1._0, _p5._2._0));
1731                 } else {
1732                     return _elm_lang$core$Result$Err(_p5._2._0);
1733                 }
1734             } else {
1735                 return _elm_lang$core$Result$Err(_p5._1._0);
1736             }
1737         } else {
1738             return _elm_lang$core$Result$Err(_p5._0._0);
1739         }
1740     });
1741 var _elm_lang$core$Result$map4 = F5(
1742     function (func, ra, rb, rc, rd) {
1743         var _p6 = {ctor: '_Tuple4', _0: ra, _1: rb, _2: rc, _3: rd};
1744         if (_p6._0.ctor === 'Ok') {
1745             if (_p6._1.ctor === 'Ok') {
1746                 if (_p6._2.ctor === 'Ok') {
1747                     if (_p6._3.ctor === 'Ok') {
1748                         return _elm_lang$core$Result$Ok(
1749                             A4(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0));
1750                     } else {
1751                         return _elm_lang$core$Result$Err(_p6._3._0);
1752                     }
1753                 } else {
1754                     return _elm_lang$core$Result$Err(_p6._2._0);
1755                 }
1756             } else {
1757                 return _elm_lang$core$Result$Err(_p6._1._0);
1758             }
1759         } else {
1760             return _elm_lang$core$Result$Err(_p6._0._0);
1761         }
1762     });
1763 var _elm_lang$core$Result$map5 = F6(
1764     function (func, ra, rb, rc, rd, re) {
1765         var _p7 = {ctor: '_Tuple5', _0: ra, _1: rb, _2: rc, _3: rd, _4: re};
1766         if (_p7._0.ctor === 'Ok') {
1767             if (_p7._1.ctor === 'Ok') {
1768                 if (_p7._2.ctor === 'Ok') {
1769                     if (_p7._3.ctor === 'Ok') {
1770                         if (_p7._4.ctor === 'Ok') {
1771                             return _elm_lang$core$Result$Ok(
1772                                 A5(func, _p7._0._0, _p7._1._0, _p7._2._0, _p7._3._0, _p7._4._0));
1773                         } else {
1774                             return _elm_lang$core$Result$Err(_p7._4._0);
1775                         }
1776                     } else {
1777                         return _elm_lang$core$Result$Err(_p7._3._0);
1778                     }
1779                 } else {
1780                     return _elm_lang$core$Result$Err(_p7._2._0);
1781                 }
1782             } else {
1783                 return _elm_lang$core$Result$Err(_p7._1._0);
1784             }
1785         } else {
1786             return _elm_lang$core$Result$Err(_p7._0._0);
1787         }
1788     });
1789 var _elm_lang$core$Result$formatError = F2(
1790     function (f, result) {
1791         var _p8 = result;
1792         if (_p8.ctor === 'Ok') {
1793             return _elm_lang$core$Result$Ok(_p8._0);
1794         } else {
1795             return _elm_lang$core$Result$Err(
1796                 f(_p8._0));
1797         }
1798     });
1799 var _elm_lang$core$Result$fromMaybe = F2(
1800     function (err, maybe) {
1801         var _p9 = maybe;
1802         if (_p9.ctor === 'Just') {
1803             return _elm_lang$core$Result$Ok(_p9._0);
1804         } else {
1805             return _elm_lang$core$Result$Err(err);
1806         }
1807     });
1808
1809 //import //
1810
1811 var _elm_lang$core$Native_Platform = function() {
1812
1813
1814 // PROGRAMS
1815
1816 function addPublicModule(object, name, main)
1817 {
1818     var init = main ? makeEmbed(name, main) : mainIsUndefined(name);
1819
1820     object['worker'] = function worker(flags)
1821     {
1822         return init(undefined, flags, false);
1823     }
1824
1825     object['embed'] = function embed(domNode, flags)
1826     {
1827         return init(domNode, flags, true);
1828     }
1829
1830     object['fullscreen'] = function fullscreen(flags)
1831     {
1832         return init(document.body, flags, true);
1833     };
1834 }
1835
1836
1837 // PROGRAM FAIL
1838
1839 function mainIsUndefined(name)
1840 {
1841     return function(domNode)
1842     {
1843         var message = 'Cannot initialize module `' + name +
1844             '` because it has no `main` value!\nWhat should I show on screen?';
1845         domNode.innerHTML = errorHtml(message);
1846         throw new Error(message);
1847     };
1848 }
1849
1850 function errorHtml(message)
1851 {
1852     return '<div style="padding-left:1em;">'
1853         + '<h2 style="font-weight:normal;"><b>Oops!</b> Something went wrong when starting your Elm program.</h2>'
1854         + '<pre style="padding-left:1em;">' + message + '</pre>'
1855         + '</div>';
1856 }
1857
1858
1859 // PROGRAM SUCCESS
1860
1861 function makeEmbed(moduleName, main)
1862 {
1863     return function embed(rootDomNode, flags, withRenderer)
1864     {
1865         try
1866         {
1867             var program = mainToProgram(moduleName, main);
1868             if (!withRenderer)
1869             {
1870                 program.renderer = dummyRenderer;
1871             }
1872             return makeEmbedHelp(moduleName, program, rootDomNode, flags);
1873         }
1874         catch (e)
1875         {
1876             rootDomNode.innerHTML = errorHtml(e.message);
1877             throw e;
1878         }
1879     };
1880 }
1881
1882 function dummyRenderer()
1883 {
1884     return { update: function() {} };
1885 }
1886
1887
1888 // MAIN TO PROGRAM
1889
1890 function mainToProgram(moduleName, wrappedMain)
1891 {
1892     var main = wrappedMain.main;
1893
1894     if (typeof main.init === 'undefined')
1895     {
1896         var emptyBag = batch(_elm_lang$core$Native_List.Nil);
1897         var noChange = _elm_lang$core$Native_Utils.Tuple2(
1898             _elm_lang$core$Native_Utils.Tuple0,
1899             emptyBag
1900         );
1901
1902         return _elm_lang$virtual_dom$VirtualDom$programWithFlags({
1903             init: function() { return noChange; },
1904             view: function() { return main; },
1905             update: F2(function() { return noChange; }),
1906             subscriptions: function () { return emptyBag; }
1907         });
1908     }
1909
1910     var flags = wrappedMain.flags;
1911     var init = flags
1912         ? initWithFlags(moduleName, main.init, flags)
1913         : initWithoutFlags(moduleName, main.init);
1914
1915     return _elm_lang$virtual_dom$VirtualDom$programWithFlags({
1916         init: init,
1917         view: main.view,
1918         update: main.update,
1919         subscriptions: main.subscriptions,
1920     });
1921 }
1922
1923 function initWithoutFlags(moduleName, realInit)
1924 {
1925     return function init(flags)
1926     {
1927         if (typeof flags !== 'undefined')
1928         {
1929             throw new Error(
1930                 'You are giving module `' + moduleName + '` an argument in JavaScript.\n'
1931                 + 'This module does not take arguments though! You probably need to change the\n'
1932                 + 'initialization code to something like `Elm.' + moduleName + '.fullscreen()`'
1933             );
1934         }
1935         return realInit();
1936     };
1937 }
1938
1939 function initWithFlags(moduleName, realInit, flagDecoder)
1940 {
1941     return function init(flags)
1942     {
1943         var result = A2(_elm_lang$core$Native_Json.run, flagDecoder, flags);
1944         if (result.ctor === 'Err')
1945         {
1946             throw new Error(
1947                 'You are trying to initialize module `' + moduleName + '` with an unexpected argument.\n'
1948                 + 'When trying to convert it to a usable Elm value, I run into this problem:\n\n'
1949                 + result._0
1950             );
1951         }
1952         return realInit(result._0);
1953     };
1954 }
1955
1956
1957 // SETUP RUNTIME SYSTEM
1958
1959 function makeEmbedHelp(moduleName, program, rootDomNode, flags)
1960 {
1961     var init = program.init;
1962     var update = program.update;
1963     var subscriptions = program.subscriptions;
1964     var view = program.view;
1965     var makeRenderer = program.renderer;
1966
1967     // ambient state
1968     var managers = {};
1969     var renderer;
1970
1971     // init and update state in main process
1972     var initApp = _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) {
1973         var results = init(flags);
1974         var model = results._0;
1975         renderer = makeRenderer(rootDomNode, enqueue, view(model));
1976         var cmds = results._1;
1977         var subs = subscriptions(model);
1978         dispatchEffects(managers, cmds, subs);
1979         callback(_elm_lang$core$Native_Scheduler.succeed(model));
1980     });
1981
1982     function onMessage(msg, model)
1983     {
1984         return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) {
1985             var results = A2(update, msg, model);
1986             model = results._0;
1987             renderer.update(view(model));
1988             var cmds = results._1;
1989             var subs = subscriptions(model);
1990             dispatchEffects(managers, cmds, subs);
1991             callback(_elm_lang$core$Native_Scheduler.succeed(model));
1992         });
1993     }
1994
1995     var mainProcess = spawnLoop(initApp, onMessage);
1996
1997     function enqueue(msg)
1998     {
1999         _elm_lang$core$Native_Scheduler.rawSend(mainProcess, msg);
2000     }
2001
2002     var ports = setupEffects(managers, enqueue);
2003
2004     return ports ? { ports: ports } : {};
2005 }
2006
2007
2008 // EFFECT MANAGERS
2009
2010 var effectManagers = {};
2011
2012 function setupEffects(managers, callback)
2013 {
2014     var ports;
2015
2016     // setup all necessary effect managers
2017     for (var key in effectManagers)
2018     {
2019         var manager = effectManagers[key];
2020
2021         if (manager.isForeign)
2022         {
2023             ports = ports || {};
2024             ports[key] = manager.tag === 'cmd'
2025                 ? setupOutgoingPort(key)
2026                 : setupIncomingPort(key, callback);
2027         }
2028
2029         managers[key] = makeManager(manager, callback);
2030     }
2031
2032     return ports;
2033 }
2034
2035 function makeManager(info, callback)
2036 {
2037     var router = {
2038         main: callback,
2039         self: undefined
2040     };
2041
2042     var tag = info.tag;
2043     var onEffects = info.onEffects;
2044     var onSelfMsg = info.onSelfMsg;
2045
2046     function onMessage(msg, state)
2047     {
2048         if (msg.ctor === 'self')
2049         {
2050             return A3(onSelfMsg, router, msg._0, state);
2051         }
2052
2053         var fx = msg._0;
2054         switch (tag)
2055         {
2056             case 'cmd':
2057                 return A3(onEffects, router, fx.cmds, state);
2058
2059             case 'sub':
2060                 return A3(onEffects, router, fx.subs, state);
2061
2062             case 'fx':
2063                 return A4(onEffects, router, fx.cmds, fx.subs, state);
2064         }
2065     }
2066
2067     var process = spawnLoop(info.init, onMessage);
2068     router.self = process;
2069     return process;
2070 }
2071
2072 function sendToApp(router, msg)
2073 {
2074     return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback)
2075     {
2076         router.main(msg);
2077         callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0));
2078     });
2079 }
2080
2081 function sendToSelf(router, msg)
2082 {
2083     return A2(_elm_lang$core$Native_Scheduler.send, router.self, {
2084         ctor: 'self',
2085         _0: msg
2086     });
2087 }
2088
2089
2090 // HELPER for STATEFUL LOOPS
2091
2092 function spawnLoop(init, onMessage)
2093 {
2094     var andThen = _elm_lang$core$Native_Scheduler.andThen;
2095
2096     function loop(state)
2097     {
2098         var handleMsg = _elm_lang$core$Native_Scheduler.receive(function(msg) {
2099             return onMessage(msg, state);
2100         });
2101         return A2(andThen, handleMsg, loop);
2102     }
2103
2104     var task = A2(andThen, init, loop);
2105
2106     return _elm_lang$core$Native_Scheduler.rawSpawn(task);
2107 }
2108
2109
2110 // BAGS
2111
2112 function leaf(home)
2113 {
2114     return function(value)
2115     {
2116         return {
2117             type: 'leaf',
2118             home: home,
2119             value: value
2120         };
2121     };
2122 }
2123
2124 function batch(list)
2125 {
2126     return {
2127         type: 'node',
2128         branches: list
2129     };
2130 }
2131
2132 function map(tagger, bag)
2133 {
2134     return {
2135         type: 'map',
2136         tagger: tagger,
2137         tree: bag
2138     }
2139 }
2140
2141
2142 // PIPE BAGS INTO EFFECT MANAGERS
2143
2144 function dispatchEffects(managers, cmdBag, subBag)
2145 {
2146     var effectsDict = {};
2147     gatherEffects(true, cmdBag, effectsDict, null);
2148     gatherEffects(false, subBag, effectsDict, null);
2149
2150     for (var home in managers)
2151     {
2152         var fx = home in effectsDict
2153             ? effectsDict[home]
2154             : {
2155                 cmds: _elm_lang$core$Native_List.Nil,
2156                 subs: _elm_lang$core$Native_List.Nil
2157             };
2158
2159         _elm_lang$core$Native_Scheduler.rawSend(managers[home], { ctor: 'fx', _0: fx });
2160     }
2161 }
2162
2163 function gatherEffects(isCmd, bag, effectsDict, taggers)
2164 {
2165     switch (bag.type)
2166     {
2167         case 'leaf':
2168             var home = bag.home;
2169             var effect = toEffect(isCmd, home, taggers, bag.value);
2170             effectsDict[home] = insert(isCmd, effect, effectsDict[home]);
2171             return;
2172
2173         case 'node':
2174             var list = bag.branches;
2175             while (list.ctor !== '[]')
2176             {
2177                 gatherEffects(isCmd, list._0, effectsDict, taggers);
2178                 list = list._1;
2179             }
2180             return;
2181
2182         case 'map':
2183             gatherEffects(isCmd, bag.tree, effectsDict, {
2184                 tagger: bag.tagger,
2185                 rest: taggers
2186             });
2187             return;
2188     }
2189 }
2190
2191 function toEffect(isCmd, home, taggers, value)
2192 {
2193     function applyTaggers(x)
2194     {
2195         var temp = taggers;
2196         while (temp)
2197         {
2198             x = temp.tagger(x);
2199             temp = temp.rest;
2200         }
2201         return x;
2202     }
2203
2204     var map = isCmd
2205         ? effectManagers[home].cmdMap
2206         : effectManagers[home].subMap;
2207
2208     return A2(map, applyTaggers, value)
2209 }
2210
2211 function insert(isCmd, newEffect, effects)
2212 {
2213     effects = effects || {
2214         cmds: _elm_lang$core$Native_List.Nil,
2215         subs: _elm_lang$core$Native_List.Nil
2216     };
2217     if (isCmd)
2218     {
2219         effects.cmds = _elm_lang$core$Native_List.Cons(newEffect, effects.cmds);
2220         return effects;
2221     }
2222     effects.subs = _elm_lang$core$Native_List.Cons(newEffect, effects.subs);
2223     return effects;
2224 }
2225
2226
2227 // PORTS
2228
2229 function checkPortName(name)
2230 {
2231     if (name in effectManagers)
2232     {
2233         throw new Error('There can only be one port named `' + name + '`, but your program has multiple.');
2234     }
2235 }
2236
2237
2238 // OUTGOING PORTS
2239
2240 function outgoingPort(name, converter)
2241 {
2242     checkPortName(name);
2243     effectManagers[name] = {
2244         tag: 'cmd',
2245         cmdMap: outgoingPortMap,
2246         converter: converter,
2247         isForeign: true
2248     };
2249     return leaf(name);
2250 }
2251
2252 var outgoingPortMap = F2(function cmdMap(tagger, value) {
2253     return value;
2254 });
2255
2256 function setupOutgoingPort(name)
2257 {
2258     var subs = [];
2259     var converter = effectManagers[name].converter;
2260
2261     // CREATE MANAGER
2262
2263     var init = _elm_lang$core$Native_Scheduler.succeed(null);
2264
2265     function onEffects(router, cmdList, state)
2266     {
2267         while (cmdList.ctor !== '[]')
2268         {
2269             var value = converter(cmdList._0);
2270             for (var i = 0; i < subs.length; i++)
2271             {
2272                 subs[i](value);
2273             }
2274             cmdList = cmdList._1;
2275         }
2276         return init;
2277     }
2278
2279     effectManagers[name].init = init;
2280     effectManagers[name].onEffects = F3(onEffects);
2281
2282     // PUBLIC API
2283
2284     function subscribe(callback)
2285     {
2286         subs.push(callback);
2287     }
2288
2289     function unsubscribe(callback)
2290     {
2291         var index = subs.indexOf(callback);
2292         if (index >= 0)
2293         {
2294             subs.splice(index, 1);
2295         }
2296     }
2297
2298     return {
2299         subscribe: subscribe,
2300         unsubscribe: unsubscribe
2301     };
2302 }
2303
2304
2305 // INCOMING PORTS
2306
2307 function incomingPort(name, converter)
2308 {
2309     checkPortName(name);
2310     effectManagers[name] = {
2311         tag: 'sub',
2312         subMap: incomingPortMap,
2313         converter: converter,
2314         isForeign: true
2315     };
2316     return leaf(name);
2317 }
2318
2319 var incomingPortMap = F2(function subMap(tagger, finalTagger)
2320 {
2321     return function(value)
2322     {
2323         return tagger(finalTagger(value));
2324     };
2325 });
2326
2327 function setupIncomingPort(name, callback)
2328 {
2329     var sentBeforeInit = [];
2330     var subs = _elm_lang$core$Native_List.Nil;
2331     var converter = effectManagers[name].converter;
2332     var currentOnEffects = preInitOnEffects;
2333     var currentSend = preInitSend;
2334
2335     // CREATE MANAGER
2336
2337     var init = _elm_lang$core$Native_Scheduler.succeed(null);
2338
2339     function preInitOnEffects(router, subList, state)
2340     {
2341         var postInitResult = postInitOnEffects(router, subList, state);
2342
2343         for(var i = 0; i < sentBeforeInit.length; i++)
2344         {
2345             postInitSend(sentBeforeInit[i]);
2346         }
2347
2348         sentBeforeInit = null; // to release objects held in queue
2349         currentSend = postInitSend;
2350         currentOnEffects = postInitOnEffects;
2351         return postInitResult;
2352     }
2353
2354     function postInitOnEffects(router, subList, state)
2355     {
2356         subs = subList;
2357         return init;
2358     }
2359
2360     function onEffects(router, subList, state)
2361     {
2362         return currentOnEffects(router, subList, state);
2363     }
2364
2365     effectManagers[name].init = init;
2366     effectManagers[name].onEffects = F3(onEffects);
2367
2368     // PUBLIC API
2369
2370     function preInitSend(value)
2371     {
2372         sentBeforeInit.push(value);
2373     }
2374
2375     function postInitSend(incomingValue)
2376     {
2377         var result = A2(_elm_lang$core$Json_Decode$decodeValue, converter, incomingValue);
2378         if (result.ctor === 'Err')
2379         {
2380             throw new Error('Trying to send an unexpected type of value through port `' + name + '`:\n' + result._0);
2381         }
2382
2383         var value = result._0;
2384         var temp = subs;
2385         while (temp.ctor !== '[]')
2386         {
2387             callback(temp._0(value));
2388             temp = temp._1;
2389         }
2390     }
2391
2392     function send(incomingValue)
2393     {
2394         currentSend(incomingValue);
2395     }
2396
2397     return { send: send };
2398 }
2399
2400 return {
2401     // routers
2402     sendToApp: F2(sendToApp),
2403     sendToSelf: F2(sendToSelf),
2404
2405     // global setup
2406     mainToProgram: mainToProgram,
2407     effectManagers: effectManagers,
2408     outgoingPort: outgoingPort,
2409     incomingPort: incomingPort,
2410     addPublicModule: addPublicModule,
2411
2412     // effect bags
2413     leaf: leaf,
2414     batch: batch,
2415     map: F2(map)
2416 };
2417
2418 }();
2419
2420 //import Native.Utils //
2421
2422 var _elm_lang$core$Native_Scheduler = function() {
2423
2424 var MAX_STEPS = 10000;
2425
2426
2427 // TASKS
2428
2429 function succeed(value)
2430 {
2431     return {
2432         ctor: '_Task_succeed',
2433         value: value
2434     };
2435 }
2436
2437 function fail(error)
2438 {
2439     return {
2440         ctor: '_Task_fail',
2441         value: error
2442     };
2443 }
2444
2445 function nativeBinding(callback)
2446 {
2447     return {
2448         ctor: '_Task_nativeBinding',
2449         callback: callback,
2450         cancel: null
2451     };
2452 }
2453
2454 function andThen(task, callback)
2455 {
2456     return {
2457         ctor: '_Task_andThen',
2458         task: task,
2459         callback: callback
2460     };
2461 }
2462
2463 function onError(task, callback)
2464 {
2465     return {
2466         ctor: '_Task_onError',
2467         task: task,
2468         callback: callback
2469     };
2470 }
2471
2472 function receive(callback)
2473 {
2474     return {
2475         ctor: '_Task_receive',
2476         callback: callback
2477     };
2478 }
2479
2480
2481 // PROCESSES
2482
2483 function rawSpawn(task)
2484 {
2485     var process = {
2486         ctor: '_Process',
2487         id: _elm_lang$core$Native_Utils.guid(),
2488         root: task,
2489         stack: null,
2490         mailbox: []
2491     };
2492
2493     enqueue(process);
2494
2495     return process;
2496 }
2497
2498 function spawn(task)
2499 {
2500     return nativeBinding(function(callback) {
2501         var process = rawSpawn(task);
2502         callback(succeed(process));
2503     });
2504 }
2505
2506 function rawSend(process, msg)
2507 {
2508     process.mailbox.push(msg);
2509     enqueue(process);
2510 }
2511
2512 function send(process, msg)
2513 {
2514     return nativeBinding(function(callback) {
2515         rawSend(process, msg);
2516         callback(succeed(_elm_lang$core$Native_Utils.Tuple0));
2517     });
2518 }
2519
2520 function kill(process)
2521 {
2522     return nativeBinding(function(callback) {
2523         var root = process.root;
2524         if (root.ctor === '_Task_nativeBinding' && root.cancel)
2525         {
2526             root.cancel();
2527         }
2528
2529         process.root = null;
2530
2531         callback(succeed(_elm_lang$core$Native_Utils.Tuple0));
2532     });
2533 }
2534
2535 function sleep(time)
2536 {
2537     return nativeBinding(function(callback) {
2538         var id = setTimeout(function() {
2539             callback(succeed(_elm_lang$core$Native_Utils.Tuple0));
2540         }, time);
2541
2542         return function() { clearTimeout(id); };
2543     });
2544 }
2545
2546
2547 // STEP PROCESSES
2548
2549 function step(numSteps, process)
2550 {
2551     while (numSteps < MAX_STEPS)
2552     {
2553         var ctor = process.root.ctor;
2554
2555         if (ctor === '_Task_succeed')
2556         {
2557             while (process.stack && process.stack.ctor === '_Task_onError')
2558             {
2559                 process.stack = process.stack.rest;
2560             }
2561             if (process.stack === null)
2562             {
2563                 break;
2564             }
2565             process.root = process.stack.callback(process.root.value);
2566             process.stack = process.stack.rest;
2567             ++numSteps;
2568             continue;
2569         }
2570
2571         if (ctor === '_Task_fail')
2572         {
2573             while (process.stack && process.stack.ctor === '_Task_andThen')
2574             {
2575                 process.stack = process.stack.rest;
2576             }
2577             if (process.stack === null)
2578             {
2579                 break;
2580             }
2581             process.root = process.stack.callback(process.root.value);
2582             process.stack = process.stack.rest;
2583             ++numSteps;
2584             continue;
2585         }
2586
2587         if (ctor === '_Task_andThen')
2588         {
2589             process.stack = {
2590                 ctor: '_Task_andThen',
2591                 callback: process.root.callback,
2592                 rest: process.stack
2593             };
2594             process.root = process.root.task;
2595             ++numSteps;
2596             continue;
2597         }
2598
2599         if (ctor === '_Task_onError')
2600         {
2601             process.stack = {
2602                 ctor: '_Task_onError',
2603                 callback: process.root.callback,
2604                 rest: process.stack
2605             };
2606             process.root = process.root.task;
2607             ++numSteps;
2608             continue;
2609         }
2610
2611         if (ctor === '_Task_nativeBinding')
2612         {
2613             process.root.cancel = process.root.callback(function(newRoot) {
2614                 process.root = newRoot;
2615                 enqueue(process);
2616             });
2617
2618             break;
2619         }
2620
2621         if (ctor === '_Task_receive')
2622         {
2623             var mailbox = process.mailbox;
2624             if (mailbox.length === 0)
2625             {
2626                 break;
2627             }
2628
2629             process.root = process.root.callback(mailbox.shift());
2630             ++numSteps;
2631             continue;
2632         }
2633
2634         throw new Error(ctor);
2635     }
2636
2637     if (numSteps < MAX_STEPS)
2638     {
2639         return numSteps + 1;
2640     }
2641     enqueue(process);
2642
2643     return numSteps;
2644 }
2645
2646
2647 // WORK QUEUE
2648
2649 var working = false;
2650 var workQueue = [];
2651
2652 function enqueue(process)
2653 {
2654     workQueue.push(process);
2655
2656     if (!working)
2657     {
2658         setTimeout(work, 0);
2659         working = true;
2660     }
2661 }
2662
2663 function work()
2664 {
2665     var numSteps = 0;
2666     var process;
2667     while (numSteps < MAX_STEPS && (process = workQueue.shift()))
2668     {
2669         if (process.root)
2670         {
2671             numSteps = step(numSteps, process);
2672         }
2673     }
2674     if (!process)
2675     {
2676         working = false;
2677         return;
2678     }
2679     setTimeout(work, 0);
2680 }
2681 window.elmWork = work;
2682
2683 return {
2684     succeed: succeed,
2685     fail: fail,
2686     nativeBinding: nativeBinding,
2687     andThen: F2(andThen),
2688     onError: F2(onError),
2689     receive: receive,
2690
2691     spawn: spawn,
2692     kill: kill,
2693     sleep: sleep,
2694     send: F2(send),
2695
2696     rawSpawn: rawSpawn,
2697     rawSend: rawSend
2698 };
2699
2700 }();
2701 var _elm_lang$core$Platform$hack = _elm_lang$core$Native_Scheduler.succeed;
2702 var _elm_lang$core$Platform$sendToSelf = _elm_lang$core$Native_Platform.sendToSelf;
2703 var _elm_lang$core$Platform$sendToApp = _elm_lang$core$Native_Platform.sendToApp;
2704 var _elm_lang$core$Platform$Program = {ctor: 'Program'};
2705 var _elm_lang$core$Platform$Task = {ctor: 'Task'};
2706 var _elm_lang$core$Platform$ProcessId = {ctor: 'ProcessId'};
2707 var _elm_lang$core$Platform$Router = {ctor: 'Router'};
2708
2709 var _elm_lang$core$Platform_Cmd$batch = _elm_lang$core$Native_Platform.batch;
2710 var _elm_lang$core$Platform_Cmd$none = _elm_lang$core$Platform_Cmd$batch(
2711     _elm_lang$core$Native_List.fromArray(
2712         []));
2713 var _elm_lang$core$Platform_Cmd_ops = _elm_lang$core$Platform_Cmd_ops || {};
2714 _elm_lang$core$Platform_Cmd_ops['!'] = F2(
2715     function (model, commands) {
2716         return {
2717             ctor: '_Tuple2',
2718             _0: model,
2719             _1: _elm_lang$core$Platform_Cmd$batch(commands)
2720         };
2721     });
2722 var _elm_lang$core$Platform_Cmd$map = _elm_lang$core$Native_Platform.map;
2723 var _elm_lang$core$Platform_Cmd$Cmd = {ctor: 'Cmd'};
2724
2725 var _elm_lang$core$Platform_Sub$batch = _elm_lang$core$Native_Platform.batch;
2726 var _elm_lang$core$Platform_Sub$none = _elm_lang$core$Platform_Sub$batch(
2727     _elm_lang$core$Native_List.fromArray(
2728         []));
2729 var _elm_lang$core$Platform_Sub$map = _elm_lang$core$Native_Platform.map;
2730 var _elm_lang$core$Platform_Sub$Sub = {ctor: 'Sub'};
2731
2732 //import Maybe, Native.List, Native.Utils, Result //
2733
2734 var _elm_lang$core$Native_String = function() {
2735
2736 function isEmpty(str)
2737 {
2738     return str.length === 0;
2739 }
2740 function cons(chr, str)
2741 {
2742     return chr + str;
2743 }
2744 function uncons(str)
2745 {
2746     var hd = str[0];
2747     if (hd)
2748     {
2749         return _elm_lang$core$Maybe$Just(_elm_lang$core$Native_Utils.Tuple2(_elm_lang$core$Native_Utils.chr(hd), str.slice(1)));
2750     }
2751     return _elm_lang$core$Maybe$Nothing;
2752 }
2753 function append(a, b)
2754 {
2755     return a + b;
2756 }
2757 function concat(strs)
2758 {
2759     return _elm_lang$core$Native_List.toArray(strs).join('');
2760 }
2761 function length(str)
2762 {
2763     return str.length;
2764 }
2765 function map(f, str)
2766 {
2767     var out = str.split('');
2768     for (var i = out.length; i--; )
2769     {
2770         out[i] = f(_elm_lang$core$Native_Utils.chr(out[i]));
2771     }
2772     return out.join('');
2773 }
2774 function filter(pred, str)
2775 {
2776     return str.split('').map(_elm_lang$core$Native_Utils.chr).filter(pred).join('');
2777 }
2778 function reverse(str)
2779 {
2780     return str.split('').reverse().join('');
2781 }
2782 function foldl(f, b, str)
2783 {
2784     var len = str.length;
2785     for (var i = 0; i < len; ++i)
2786     {
2787         b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b);
2788     }
2789     return b;
2790 }
2791 function foldr(f, b, str)
2792 {
2793     for (var i = str.length; i--; )
2794     {
2795         b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b);
2796     }
2797     return b;
2798 }
2799 function split(sep, str)
2800 {
2801     return _elm_lang$core$Native_List.fromArray(str.split(sep));
2802 }
2803 function join(sep, strs)
2804 {
2805     return _elm_lang$core$Native_List.toArray(strs).join(sep);
2806 }
2807 function repeat(n, str)
2808 {
2809     var result = '';
2810     while (n > 0)
2811     {
2812         if (n & 1)
2813         {
2814             result += str;
2815         }
2816         n >>= 1, str += str;
2817     }
2818     return result;
2819 }
2820 function slice(start, end, str)
2821 {
2822     return str.slice(start, end);
2823 }
2824 function left(n, str)
2825 {
2826     return n < 1 ? '' : str.slice(0, n);
2827 }
2828 function right(n, str)
2829 {
2830     return n < 1 ? '' : str.slice(-n);
2831 }
2832 function dropLeft(n, str)
2833 {
2834     return n < 1 ? str : str.slice(n);
2835 }
2836 function dropRight(n, str)
2837 {
2838     return n < 1 ? str : str.slice(0, -n);
2839 }
2840 function pad(n, chr, str)
2841 {
2842     var half = (n - str.length) / 2;
2843     return repeat(Math.ceil(half), chr) + str + repeat(half | 0, chr);
2844 }
2845 function padRight(n, chr, str)
2846 {
2847     return str + repeat(n - str.length, chr);
2848 }
2849 function padLeft(n, chr, str)
2850 {
2851     return repeat(n - str.length, chr) + str;
2852 }
2853
2854 function trim(str)
2855 {
2856     return str.trim();
2857 }
2858 function trimLeft(str)
2859 {
2860     return str.replace(/^\s+/, '');
2861 }
2862 function trimRight(str)
2863 {
2864     return str.replace(/\s+$/, '');
2865 }
2866
2867 function words(str)
2868 {
2869     return _elm_lang$core$Native_List.fromArray(str.trim().split(/\s+/g));
2870 }
2871 function lines(str)
2872 {
2873     return _elm_lang$core$Native_List.fromArray(str.split(/\r\n|\r|\n/g));
2874 }
2875
2876 function toUpper(str)
2877 {
2878     return str.toUpperCase();
2879 }
2880 function toLower(str)
2881 {
2882     return str.toLowerCase();
2883 }
2884
2885 function any(pred, str)
2886 {
2887     for (var i = str.length; i--; )
2888     {
2889         if (pred(_elm_lang$core$Native_Utils.chr(str[i])))
2890         {
2891             return true;
2892         }
2893     }
2894     return false;
2895 }
2896 function all(pred, str)
2897 {
2898     for (var i = str.length; i--; )
2899     {
2900         if (!pred(_elm_lang$core$Native_Utils.chr(str[i])))
2901         {
2902             return false;
2903         }
2904     }
2905     return true;
2906 }
2907
2908 function contains(sub, str)
2909 {
2910     return str.indexOf(sub) > -1;
2911 }
2912 function startsWith(sub, str)
2913 {
2914     return str.indexOf(sub) === 0;
2915 }
2916 function endsWith(sub, str)
2917 {
2918     return str.length >= sub.length &&
2919         str.lastIndexOf(sub) === str.length - sub.length;
2920 }
2921 function indexes(sub, str)
2922 {
2923     var subLen = sub.length;
2924     
2925     if (subLen < 1)
2926     {
2927         return _elm_lang$core$Native_List.Nil;
2928     }
2929
2930     var i = 0;