CS3seZLw

1(function(scope){
2'use strict';
3
4function F(arity, fun, wrapper) {
5  wrapper.a = arity;
6  wrapper.f = fun;
7  return wrapper;
8}
9
10function F2(fun) {
11  return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
12}
13function F3(fun) {
14  return F(3, fun, function(a) {
15    return function(b) { return function(c) { return fun(a, b, c); }; };
16  });
17}
18function F4(fun) {
19  return F(4, fun, function(a) { return function(b) { return function(c) {
20    return function(d) { return fun(a, b, c, d); }; }; };
21  });
22}
23function F5(fun) {
24  return F(5, fun, function(a) { return function(b) { return function(c) {
25    return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
26  });
27}
28function F6(fun) {
29  return F(6, fun, function(a) { return function(b) { return function(c) {
30    return function(d) { return function(e) { return function(f) {
31    return fun(a, b, c, d, e, f); }; }; }; }; };
32  });
33}
34function F7(fun) {
35  return F(7, fun, function(a) { return function(b) { return function(c) {
36    return function(d) { return function(e) { return function(f) {
37    return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
38  });
39}
40function F8(fun) {
41  return F(8, fun, function(a) { return function(b) { return function(c) {
42    return function(d) { return function(e) { return function(f) {
43    return function(g) { return function(h) {
44    return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
45  });
46}
47function F9(fun) {
48  return F(9, fun, function(a) { return function(b) { return function(c) {
49    return function(d) { return function(e) { return function(f) {
50    return function(g) { return function(h) { return function(i) {
51    return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
52  });
53}
54
55function A2(fun, a, b) {
56  return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
57}
58function A3(fun, a, b, c) {
59  return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
60}
61function A4(fun, a, b, c, d) {
62  return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
63}
64function A5(fun, a, b, c, d, e) {
65  return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
66}
67function A6(fun, a, b, c, d, e, f) {
68  return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
69}
70function A7(fun, a, b, c, d, e, f, g) {
71  return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
72}
73function A8(fun, a, b, c, d, e, f, g, h) {
74  return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
75}
76function A9(fun, a, b, c, d, e, f, g, h, i) {
77  return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
78}
79
80console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.');
81
82
83var _List_Nil_UNUSED = { $: 0 };
84var _List_Nil = { $: '[]' };
85
86function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }
87function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }
88
89
90var _List_cons = F2(_List_Cons);
91
92function _List_fromArray(arr)
93{
94	var out = _List_Nil;
95	for (var i = arr.length; i--; )
96	{
97		out = _List_Cons(arr[i], out);
98	}
99	return out;
100}
101
102function _List_toArray(xs)
103{
104	for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
105	{
106		out.push(xs.a);
107	}
108	return out;
109}
110
111var _List_map2 = F3(function(f, xs, ys)
112{
113	for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
114	{
115		arr.push(A2(f, xs.a, ys.a));
116	}
117	return _List_fromArray(arr);
118});
119
120var _List_map3 = F4(function(f, xs, ys, zs)
121{
122	for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
123	{
124		arr.push(A3(f, xs.a, ys.a, zs.a));
125	}
126	return _List_fromArray(arr);
127});
128
129var _List_map4 = F5(function(f, ws, xs, ys, zs)
130{
131	for (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
132	{
133		arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
134	}
135	return _List_fromArray(arr);
136});
137
138var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
139{
140	for (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
141	{
142		arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
143	}
144	return _List_fromArray(arr);
145});
146
147var _List_sortBy = F2(function(f, xs)
148{
149	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
150		return _Utils_cmp(f(a), f(b));
151	}));
152});
153
154var _List_sortWith = F2(function(f, xs)
155{
156	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
157		var ord = A2(f, a, b);
158		return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
159	}));
160});
161
162
163
164var _JsArray_empty = [];
165
166function _JsArray_singleton(value)
167{
168    return [value];
169}
170
171function _JsArray_length(array)
172{
173    return array.length;
174}
175
176var _JsArray_initialize = F3(function(size, offset, func)
177{
178    var result = new Array(size);
179
180    for (var i = 0; i < size; i++)
181    {
182        result[i] = func(offset + i);
183    }
184
185    return result;
186});
187
188var _JsArray_initializeFromList = F2(function (max, ls)
189{
190    var result = new Array(max);
191
192    for (var i = 0; i < max && ls.b; i++)
193    {
194        result[i] = ls.a;
195        ls = ls.b;
196    }
197
198    result.length = i;
199    return _Utils_Tuple2(result, ls);
200});
201
202var _JsArray_unsafeGet = F2(function(index, array)
203{
204    return array[index];
205});
206
207var _JsArray_unsafeSet = F3(function(index, value, array)
208{
209    var length = array.length;
210    var result = new Array(length);
211
212    for (var i = 0; i < length; i++)
213    {
214        result[i] = array[i];
215    }
216
217    result[index] = value;
218    return result;
219});
220
221var _JsArray_push = F2(function(value, array)
222{
223    var length = array.length;
224    var result = new Array(length + 1);
225
226    for (var i = 0; i < length; i++)
227    {
228        result[i] = array[i];
229    }
230
231    result[length] = value;
232    return result;
233});
234
235var _JsArray_foldl = F3(function(func, acc, array)
236{
237    var length = array.length;
238
239    for (var i = 0; i < length; i++)
240    {
241        acc = A2(func, array[i], acc);
242    }
243
244    return acc;
245});
246
247var _JsArray_foldr = F3(function(func, acc, array)
248{
249    for (var i = array.length - 1; i >= 0; i--)
250    {
251        acc = A2(func, array[i], acc);
252    }
253
254    return acc;
255});
256
257var _JsArray_map = F2(function(func, array)
258{
259    var length = array.length;
260    var result = new Array(length);
261
262    for (var i = 0; i < length; i++)
263    {
264        result[i] = func(array[i]);
265    }
266
267    return result;
268});
269
270var _JsArray_indexedMap = F3(function(func, offset, array)
271{
272    var length = array.length;
273    var result = new Array(length);
274
275    for (var i = 0; i < length; i++)
276    {
277        result[i] = A2(func, offset + i, array[i]);
278    }
279
280    return result;
281});
282
283var _JsArray_slice = F3(function(from, to, array)
284{
285    return array.slice(from, to);
286});
287
288var _JsArray_appendN = F3(function(n, dest, source)
289{
290    var destLen = dest.length;
291    var itemsToCopy = n - destLen;
292
293    if (itemsToCopy > source.length)
294    {
295        itemsToCopy = source.length;
296    }
297
298    var size = destLen + itemsToCopy;
299    var result = new Array(size);
300
301    for (var i = 0; i < destLen; i++)
302    {
303        result[i] = dest[i];
304    }
305
306    for (var i = 0; i < itemsToCopy; i++)
307    {
308        result[i + destLen] = source[i];
309    }
310
311    return result;
312});
313
314
315
316// LOG
317
318var _Debug_log_UNUSED = F2(function(tag, value)
319{
320	return value;
321});
322
323var _Debug_log = F2(function(tag, value)
324{
325	console.log(tag + ': ' + _Debug_toString(value));
326	return value;
327});
328
329
330// TODOS
331
332function _Debug_todo(moduleName, region)
333{
334	return function(message) {
335		_Debug_crash(8, moduleName, region, message);
336	};
337}
338
339function _Debug_todoCase(moduleName, region, value)
340{
341	return function(message) {
342		_Debug_crash(9, moduleName, region, value, message);
343	};
344}
345
346
347// TO STRING
348
349function _Debug_toString_UNUSED(value)
350{
351	return '<internals>';
352}
353
354function _Debug_toString(value)
355{
356	return _Debug_toAnsiString(false, value);
357}
358
359function _Debug_toAnsiString(ansi, value)
360{
361	if (typeof value === 'function')
362	{
363		return _Debug_internalColor(ansi, '<function>');
364	}
365
366	if (typeof value === 'boolean')
367	{
368		return _Debug_ctorColor(ansi, value ? 'True' : 'False');
369	}
370
371	if (typeof value === 'number')
372	{
373		return _Debug_numberColor(ansi, value + '');
374	}
375
376	if (value instanceof String)
377	{
378		return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
379	}
380
381	if (typeof value === 'string')
382	{
383		return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
384	}
385
386	if (typeof value === 'object' && '$' in value)
387	{
388		var tag = value.$;
389
390		if (typeof tag === 'number')
391		{
392			return _Debug_internalColor(ansi, '<internals>');
393		}
394
395		if (tag[0] === '#')
396		{
397			var output = [];
398			for (var k in value)
399			{
400				if (k === '$') continue;
401				output.push(_Debug_toAnsiString(ansi, value[k]));
402			}
403			return '(' + output.join(',') + ')';
404		}
405
406		if (tag === 'Set_elm_builtin')
407		{
408			return _Debug_ctorColor(ansi, 'Set')
409				+ _Debug_fadeColor(ansi, '.fromList') + ' '
410				+ _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
411		}
412
413		if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
414		{
415			return _Debug_ctorColor(ansi, 'Dict')
416				+ _Debug_fadeColor(ansi, '.fromList') + ' '
417				+ _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
418		}
419
420		if (tag === 'Array_elm_builtin')
421		{
422			return _Debug_ctorColor(ansi, 'Array')
423				+ _Debug_fadeColor(ansi, '.fromList') + ' '
424				+ _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
425		}
426
427		if (tag === '::' || tag === '[]')
428		{
429			var output = '[';
430
431			value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
432
433			for (; value.b; value = value.b) // WHILE_CONS
434			{
435				output += ',' + _Debug_toAnsiString(ansi, value.a);
436			}
437			return output + ']';
438		}
439
440		var output = '';
441		for (var i in value)
442		{
443			if (i === '$') continue;
444			var str = _Debug_toAnsiString(ansi, value[i]);
445			var c0 = str[0];
446			var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
447			output += ' ' + (parenless ? str : '(' + str + ')');
448		}
449		return _Debug_ctorColor(ansi, tag) + output;
450	}
451
452	if (typeof DataView === 'function' && value instanceof DataView)
453	{
454		return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
455	}
456
457	if (typeof File === 'function' && value instanceof File)
458	{
459		return _Debug_internalColor(ansi, '<' + value.name + '>');
460	}
461
462	if (typeof value === 'object')
463	{
464		var output = [];
465		for (var key in value)
466		{
467			var field = key[0] === '_' ? key.slice(1) : key;
468			output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
469		}
470		if (output.length === 0)
471		{
472			return '{}';
473		}
474		return '{ ' + output.join(', ') + ' }';
475	}
476
477	return _Debug_internalColor(ansi, '<internals>');
478}
479
480function _Debug_addSlashes(str, isChar)
481{
482	var s = str
483		.replace(/\\/g, '\\\\')
484		.replace(/\n/g, '\\n')
485		.replace(/\t/g, '\\t')
486		.replace(/\r/g, '\\r')
487		.replace(/\v/g, '\\v')
488		.replace(/\0/g, '\\0');
489
490	if (isChar)
491	{
492		return s.replace(/\'/g, '\\\'');
493	}
494	else
495	{
496		return s.replace(/\"/g, '\\"');
497	}
498}
499
500function _Debug_ctorColor(ansi, string)
501{
502	return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
503}
504
505function _Debug_numberColor(ansi, string)
506{
507	return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
508}
509
510function _Debug_stringColor(ansi, string)
511{
512	return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
513}
514
515function _Debug_charColor(ansi, string)
516{
517	return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
518}
519
520function _Debug_fadeColor(ansi, string)
521{
522	return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
523}
524
525function _Debug_internalColor(ansi, string)
526{
527	return ansi ? '\x1b[94m' + string + '\x1b[0m' : string;
528}
529
530function _Debug_toHexDigit(n)
531{
532	return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
533}
534
535
536// CRASH
537
538
539function _Debug_crash_UNUSED(identifier)
540{
541	throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
542}
543
544
545function _Debug_crash(identifier, fact1, fact2, fact3, fact4)
546{
547	switch(identifier)
548	{
549		case 0:
550			throw new Error('What node should I take over? In JavaScript I need something like:\n\n    Elm.Main.init({\n        node: document.getElementById("elm-node")\n    })\n\nYou need to do this with any Browser.sandbox or Browser.element program.');
551
552		case 1:
553			throw new Error('Browser.application programs cannot handle URLs like this:\n\n    ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');
554
555		case 2:
556			var jsonErrorString = fact1;
557			throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
558
559		case 3:
560			var portName = fact1;
561			throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
562
563		case 4:
564			var portName = fact1;
565			var problem = fact2;
566			throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
567
568		case 5:
569			throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
570
571		case 6:
572			var moduleName = fact1;
573			throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');
574
575		case 8:
576			var moduleName = fact1;
577			var region = fact2;
578			var message = fact3;
579			throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
580
581		case 9:
582			var moduleName = fact1;
583			var region = fact2;
584			var value = fact3;
585			var message = fact4;
586			throw new Error(
587				'TODO in module `' + moduleName + '` from the `case` expression '
588				+ _Debug_regionToString(region) + '\n\nIt received the following value:\n\n    '
589				+ _Debug_toString(value).replace('\n', '\n    ')
590				+ '\n\nBut the branch that handles it says:\n\n    ' + message.replace('\n', '\n    ')
591			);
592
593		case 10:
594			throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
595
596		case 11:
597			throw new Error('Cannot perform mod 0. Division by zero error.');
598	}
599}
600
601function _Debug_regionToString(region)
602{
603	if (region.start.line === region.end.line)
604	{
605		return 'on line ' + region.start.line;
606	}
607	return 'on lines ' + region.start.line + ' through ' + region.end.line;
608}
609
610
611
612// EQUALITY
613
614function _Utils_eq(x, y)
615{
616	for (
617		var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
618		isEqual && (pair = stack.pop());
619		isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
620		)
621	{}
622
623	return isEqual;
624}
625
626function _Utils_eqHelp(x, y, depth, stack)
627{
628	if (depth > 100)
629	{
630		stack.push(_Utils_Tuple2(x,y));
631		return true;
632	}
633
634	if (x === y)
635	{
636		return true;
637	}
638
639	if (typeof x !== 'object' || x === null || y === null)
640	{
641		typeof x === 'function' && _Debug_crash(5);
642		return false;
643	}
644
645	/**/
646	if (x.$ === 'Set_elm_builtin')
647	{
648		x = $elm$core$Set$toList(x);
649		y = $elm$core$Set$toList(y);
650	}
651	if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
652	{
653		x = $elm$core$Dict$toList(x);
654		y = $elm$core$Dict$toList(y);
655	}
656	//*/
657
658	/**_UNUSED/
659	if (x.$ < 0)
660	{
661		x = $elm$core$Dict$toList(x);
662		y = $elm$core$Dict$toList(y);
663	}
664	//*/
665
666	for (var key in x)
667	{
668		if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
669		{
670			return false;
671		}
672	}
673	return true;
674}
675
676var _Utils_equal = F2(_Utils_eq);
677var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
678
679
680
681// COMPARISONS
682
683// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
684// the particular integer values assigned to LT, EQ, and GT.
685
686function _Utils_cmp(x, y, ord)
687{
688	if (typeof x !== 'object')
689	{
690		return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
691	}
692
693	/**/
694	if (x instanceof String)
695	{
696		var a = x.valueOf();
697		var b = y.valueOf();
698		return a === b ? 0 : a < b ? -1 : 1;
699	}
700	//*/
701
702	/**_UNUSED/
703	if (typeof x.$ === 'undefined')
704	//*/
705	/**/
706	if (x.$[0] === '#')
707	//*/
708	{
709		return (ord = _Utils_cmp(x.a, y.a))
710			? ord
711			: (ord = _Utils_cmp(x.b, y.b))
712				? ord
713				: _Utils_cmp(x.c, y.c);
714	}
715
716	// traverse conses until end of a list or a mismatch
717	for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
718	return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
719}
720
721var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
722var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
723var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
724var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
725
726var _Utils_compare = F2(function(x, y)
727{
728	var n = _Utils_cmp(x, y);
729	return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
730});
731
732
733// COMMON VALUES
734
735var _Utils_Tuple0_UNUSED = 0;
736var _Utils_Tuple0 = { $: '#0' };
737
738function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }
739function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }
740
741function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }
742function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
743
744function _Utils_chr_UNUSED(c) { return c; }
745function _Utils_chr(c) { return new String(c); }
746
747
748// RECORDS
749
750function _Utils_update(oldRecord, updatedFields)
751{
752	var newRecord = {};
753
754	for (var key in oldRecord)
755	{
756		newRecord[key] = oldRecord[key];
757	}
758
759	for (var key in updatedFields)
760	{
761		newRecord[key] = updatedFields[key];
762	}
763
764	return newRecord;
765}
766
767
768// APPEND
769
770var _Utils_append = F2(_Utils_ap);
771
772function _Utils_ap(xs, ys)
773{
774	// append Strings
775	if (typeof xs === 'string')
776	{
777		return xs + ys;
778	}
779
780	// append Lists
781	if (!xs.b)
782	{
783		return ys;
784	}
785	var root = _List_Cons(xs.a, ys);
786	xs = xs.b
787	for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
788	{
789		curr = curr.b = _List_Cons(xs.a, ys);
790	}
791	return root;
792}
793
794
795
796// TASKS
797
798function _Scheduler_succeed(value)
799{
800	return {
801		$: 0,
802		a: value
803	};
804}
805
806function _Scheduler_fail(error)
807{
808	return {
809		$: 1,
810		a: error
811	};
812}
813
814function _Scheduler_binding(callback)
815{
816	return {
817		$: 2,
818		b: callback,
819		c: null
820	};
821}
822
823var _Scheduler_andThen = F2(function(callback, task)
824{
825	return {
826		$: 3,
827		b: callback,
828		d: task
829	};
830});
831
832var _Scheduler_onError = F2(function(callback, task)
833{
834	return {
835		$: 4,
836		b: callback,
837		d: task
838	};
839});
840
841function _Scheduler_receive(callback)
842{
843	return {
844		$: 5,
845		b: callback
846	};
847}
848
849
850// PROCESSES
851
852var _Scheduler_guid = 0;
853
854function _Scheduler_rawSpawn(task)
855{
856	var proc = {
857		$: 0,
858		e: _Scheduler_guid++,
859		f: task,
860		g: null,
861		h: []
862	};
863
864	_Scheduler_enqueue(proc);
865
866	return proc;
867}
868
869function _Scheduler_spawn(task)
870{
871	return _Scheduler_binding(function(callback) {
872		callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
873	});
874}
875
876function _Scheduler_rawSend(proc, msg)
877{
878	proc.h.push(msg);
879	_Scheduler_enqueue(proc);
880}
881
882var _Scheduler_send = F2(function(proc, msg)
883{
884	return _Scheduler_binding(function(callback) {
885		_Scheduler_rawSend(proc, msg);
886		callback(_Scheduler_succeed(_Utils_Tuple0));
887	});
888});
889
890function _Scheduler_kill(proc)
891{
892	return _Scheduler_binding(function(callback) {
893		var task = proc.f;
894		if (task.$ === 2 && task.c)
895		{
896			task.c();
897		}
898
899		proc.f = null;
900
901		callback(_Scheduler_succeed(_Utils_Tuple0));
902	});
903}
904
905
906/* STEP PROCESSES
907
908type alias Process =
909  { $ : tag
910  , id : unique_id
911  , root : Task
912  , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
913  , mailbox : [msg]
914  }
915
916*/
917
918
919var _Scheduler_working = false;
920var _Scheduler_queue = [];
921
922
923function _Scheduler_enqueue(proc)
924{
925	_Scheduler_queue.push(proc);
926	if (_Scheduler_working)
927	{
928		return;
929	}
930	_Scheduler_working = true;
931	while (proc = _Scheduler_queue.shift())
932	{
933		_Scheduler_step(proc);
934	}
935	_Scheduler_working = false;
936}
937
938
939function _Scheduler_step(proc)
940{
941	while (proc.f)
942	{
943		var rootTag = proc.f.$;
944		if (rootTag === 0 || rootTag === 1)
945		{
946			while (proc.g && proc.g.$ !== rootTag)
947			{
948				proc.g = proc.g.i;
949			}
950			if (!proc.g)
951			{
952				return;
953			}
954			proc.f = proc.g.b(proc.f.a);
955			proc.g = proc.g.i;
956		}
957		else if (rootTag === 2)
958		{
959			proc.f.c = proc.f.b(function(newRoot) {
960				proc.f = newRoot;
961				_Scheduler_enqueue(proc);
962			});
963			return;
964		}
965		else if (rootTag === 5)
966		{
967			if (proc.h.length === 0)
968			{
969				return;
970			}
971			proc.f = proc.f.b(proc.h.shift());
972		}
973		else // if (rootTag === 3 || rootTag === 4)
974		{
975			proc.g = {
976				$: rootTag === 3 ? 0 : 1,
977				b: proc.f.b,
978				i: proc.g
979			};
980			proc.f = proc.f.d;
981		}
982	}
983}
984
985
986
987// MATH
988
989var _Basics_add = F2(function(a, b) { return a + b; });
990var _Basics_sub = F2(function(a, b) { return a - b; });
991var _Basics_mul = F2(function(a, b) { return a * b; });
992var _Basics_fdiv = F2(function(a, b) { return a / b; });
993var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
994var _Basics_pow = F2(Math.pow);
995
996var _Basics_remainderBy = F2(function(b, a) { return a % b; });
997
998// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
999var _Basics_modBy = F2(function(modulus, x)
1000{
1001	var answer = x % modulus;
1002	return modulus === 0
1003		? _Debug_crash(11)
1004		:
1005	((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
1006		? answer + modulus
1007		: answer;
1008});
1009
1010
1011// TRIGONOMETRY
1012
1013var _Basics_pi = Math.PI;
1014var _Basics_e = Math.E;
1015var _Basics_cos = Math.cos;
1016var _Basics_sin = Math.sin;
1017var _Basics_tan = Math.tan;
1018var _Basics_acos = Math.acos;
1019var _Basics_asin = Math.asin;
1020var _Basics_atan = Math.atan;
1021var _Basics_atan2 = F2(Math.atan2);
1022
1023
1024// MORE MATH
1025
1026function _Basics_toFloat(x) { return x; }
1027function _Basics_truncate(n) { return n | 0; }
1028function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
1029
1030var _Basics_ceiling = Math.ceil;
1031var _Basics_floor = Math.floor;
1032var _Basics_round = Math.round;
1033var _Basics_sqrt = Math.sqrt;
1034var _Basics_log = Math.log;
1035var _Basics_isNaN = isNaN;
1036
1037
1038// BOOLEANS
1039
1040function _Basics_not(bool) { return !bool; }
1041var _Basics_and = F2(function(a, b) { return a && b; });
1042var _Basics_or  = F2(function(a, b) { return a || b; });
1043var _Basics_xor = F2(function(a, b) { return a !== b; });
1044
1045
1046
1047var _String_cons = F2(function(chr, str)
1048{
1049	return chr + str;
1050});
1051
1052function _String_uncons(string)
1053{
1054	var word = string.charCodeAt(0);
1055	return word
1056		? $elm$core$Maybe$Just(
1057			0xD800 <= word && word <= 0xDBFF
1058				? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
1059				: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
1060		)
1061		: $elm$core$Maybe$Nothing;
1062}
1063
1064var _String_append = F2(function(a, b)
1065{
1066	return a + b;
1067});
1068
1069function _String_length(str)
1070{
1071	return str.length;
1072}
1073
1074var _String_map = F2(function(func, string)
1075{
1076	var len = string.length;
1077	var array = new Array(len);
1078	var i = 0;
1079	while (i < len)
1080	{
1081		var word = string.charCodeAt(i);
1082		if (0xD800 <= word && word <= 0xDBFF)
1083		{
1084			array[i] = func(_Utils_chr(string[i] + string[i+1]));
1085			i += 2;
1086			continue;
1087		}
1088		array[i] = func(_Utils_chr(string[i]));
1089		i++;
1090	}
1091	return array.join('');
1092});
1093
1094var _String_filter = F2(function(isGood, str)
1095{
1096	var arr = [];
1097	var len = str.length;
1098	var i = 0;
1099	while (i < len)
1100	{
1101		var char = str[i];
1102		var word = str.charCodeAt(i);
1103		i++;
1104		if (0xD800 <= word && word <= 0xDBFF)
1105		{
1106			char += str[i];
1107			i++;
1108		}
1109
1110		if (isGood(_Utils_chr(char)))
1111		{
1112			arr.push(char);
1113		}
1114	}
1115	return arr.join('');
1116});
1117
1118function _String_reverse(str)
1119{
1120	var len = str.length;
1121	var arr = new Array(len);
1122	var i = 0;
1123	while (i < len)
1124	{
1125		var word = str.charCodeAt(i);
1126		if (0xD800 <= word && word <= 0xDBFF)
1127		{
1128			arr[len - i] = str[i + 1];
1129			i++;
1130			arr[len - i] = str[i - 1];
1131			i++;
1132		}
1133		else
1134		{
1135			arr[len - i] = str[i];
1136			i++;
1137		}
1138	}
1139	return arr.join('');
1140}
1141
1142var _String_foldl = F3(function(func, state, string)
1143{
1144	var len = string.length;
1145	var i = 0;
1146	while (i < len)
1147	{
1148		var char = string[i];
1149		var word = string.charCodeAt(i);
1150		i++;
1151		if (0xD800 <= word && word <= 0xDBFF)
1152		{
1153			char += string[i];
1154			i++;
1155		}
1156		state = A2(func, _Utils_chr(char), state);
1157	}
1158	return state;
1159});
1160
1161var _String_foldr = F3(function(func, state, string)
1162{
1163	var i = string.length;
1164	while (i--)
1165	{
1166		var char = string[i];
1167		var word = string.charCodeAt(i);
1168		if (0xDC00 <= word && word <= 0xDFFF)
1169		{
1170			i--;
1171			char = string[i] + char;
1172		}
1173		state = A2(func, _Utils_chr(char), state);
1174	}
1175	return state;
1176});
1177
1178var _String_split = F2(function(sep, str)
1179{
1180	return str.split(sep);
1181});
1182
1183var _String_join = F2(function(sep, strs)
1184{
1185	return strs.join(sep);
1186});
1187
1188var _String_slice = F3(function(start, end, str) {
1189	return str.slice(start, end);
1190});
1191
1192function _String_trim(str)
1193{
1194	return str.trim();
1195}
1196
1197function _String_trimLeft(str)
1198{
1199	return str.replace(/^\s+/, '');
1200}
1201
1202function _String_trimRight(str)
1203{
1204	return str.replace(/\s+$/, '');
1205}
1206
1207function _String_words(str)
1208{
1209	return _List_fromArray(str.trim().split(/\s+/g));
1210}
1211
1212function _String_lines(str)
1213{
1214	return _List_fromArray(str.split(/\r\n|\r|\n/g));
1215}
1216
1217function _String_toUpper(str)
1218{
1219	return str.toUpperCase();
1220}
1221
1222function _String_toLower(str)
1223{
1224	return str.toLowerCase();
1225}
1226
1227var _String_any = F2(function(isGood, string)
1228{
1229	var i = string.length;
1230	while (i--)
1231	{
1232		var char = string[i];
1233		var word = string.charCodeAt(i);
1234		if (0xDC00 <= word && word <= 0xDFFF)
1235		{
1236			i--;
1237			char = string[i] + char;
1238		}
1239		if (isGood(_Utils_chr(char)))
1240		{
1241			return true;
1242		}
1243	}
1244	return false;
1245});
1246
1247var _String_all = F2(function(isGood, string)
1248{
1249	var i = string.length;
1250	while (i--)
1251	{
1252		var char = string[i];
1253		var word = string.charCodeAt(i);
1254		if (0xDC00 <= word && word <= 0xDFFF)
1255		{
1256			i--;
1257			char = string[i] + char;
1258		}
1259		if (!isGood(_Utils_chr(char)))
1260		{
1261			return false;
1262		}
1263	}
1264	return true;
1265});
1266
1267var _String_contains = F2(function(sub, str)
1268{
1269	return str.indexOf(sub) > -1;
1270});
1271
1272var _String_startsWith = F2(function(sub, str)
1273{
1274	return str.indexOf(sub) === 0;
1275});
1276
1277var _String_endsWith = F2(function(sub, str)
1278{
1279	return str.length >= sub.length &&
1280		str.lastIndexOf(sub) === str.length - sub.length;
1281});
1282
1283var _String_indexes = F2(function(sub, str)
1284{
1285	var subLen = sub.length;
1286
1287	if (subLen < 1)
1288	{
1289		return _List_Nil;
1290	}
1291
1292	var i = 0;
1293	var is = [];
1294
1295	while ((i = str.indexOf(sub, i)) > -1)
1296	{
1297		is.push(i);
1298		i = i + subLen;
1299	}
1300
1301	return _List_fromArray(is);
1302});
1303
1304
1305// TO STRING
1306
1307function _String_fromNumber(number)
1308{
1309	return number + '';
1310}
1311
1312
1313// INT CONVERSIONS
1314
1315function _String_toInt(str)
1316{
1317	var total = 0;
1318	var code0 = str.charCodeAt(0);
1319	var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1320
1321	for (var i = start; i < str.length; ++i)
1322	{
1323		var code = str.charCodeAt(i);
1324		if (code < 0x30 || 0x39 < code)
1325		{
1326			return $elm$core$Maybe$Nothing;
1327		}
1328		total = 10 * total + code - 0x30;
1329	}
1330
1331	return i == start
1332		? $elm$core$Maybe$Nothing
1333		: $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1334}
1335
1336
1337// FLOAT CONVERSIONS
1338
1339function _String_toFloat(s)
1340{
1341	// check if it is a hex, octal, or binary number
1342	if (s.length === 0 || /[\sxbo]/.test(s))
1343	{
1344		return $elm$core$Maybe$Nothing;
1345	}
1346	var n = +s;
1347	// faster isNaN check
1348	return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1349}
1350
1351function _String_fromList(chars)
1352{
1353	return _List_toArray(chars).join('');
1354}
1355
1356
1357
1358
1359function _Char_toCode(char)
1360{
1361	var code = char.charCodeAt(0);
1362	if (0xD800 <= code && code <= 0xDBFF)
1363	{
1364		return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1365	}
1366	return code;
1367}
1368
1369function _Char_fromCode(code)
1370{
1371	return _Utils_chr(
1372		(code < 0 || 0x10FFFF < code)
1373			? '\uFFFD'
1374			:
1375		(code <= 0xFFFF)
1376			? String.fromCharCode(code)
1377			:
1378		(code -= 0x10000,
1379			String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1380		)
1381	);
1382}
1383
1384function _Char_toUpper(char)
1385{
1386	return _Utils_chr(char.toUpperCase());
1387}
1388
1389function _Char_toLower(char)
1390{
1391	return _Utils_chr(char.toLowerCase());
1392}
1393
1394function _Char_toLocaleUpper(char)
1395{
1396	return _Utils_chr(char.toLocaleUpperCase());
1397}
1398
1399function _Char_toLocaleLower(char)
1400{
1401	return _Utils_chr(char.toLocaleLowerCase());
1402}
1403
1404
1405
1406/**/
1407function _Json_errorToString(error)
1408{
1409	return $elm$json$Json$Decode$errorToString(error);
1410}
1411//*/
1412
1413
1414// CORE DECODERS
1415
1416function _Json_succeed(msg)
1417{
1418	return {
1419		$: 0,
1420		a: msg
1421	};
1422}
1423
1424function _Json_fail(msg)
1425{
1426	return {
1427		$: 1,
1428		a: msg
1429	};
1430}
1431
1432function _Json_decodePrim(decoder)
1433{
1434	return { $: 2, b: decoder };
1435}
1436
1437var _Json_decodeInt = _Json_decodePrim(function(value) {
1438	return (typeof value !== 'number')
1439		? _Json_expecting('an INT', value)
1440		:
1441	(-2147483647 < value && value < 2147483647 && (value | 0) === value)
1442		? $elm$core$Result$Ok(value)
1443		:
1444	(isFinite(value) && !(value % 1))
1445		? $elm$core$Result$Ok(value)
1446		: _Json_expecting('an INT', value);
1447});
1448
1449var _Json_decodeBool = _Json_decodePrim(function(value) {
1450	return (typeof value === 'boolean')
1451		? $elm$core$Result$Ok(value)
1452		: _Json_expecting('a BOOL', value);
1453});
1454
1455var _Json_decodeFloat = _Json_decodePrim(function(value) {
1456	return (typeof value === 'number')
1457		? $elm$core$Result$Ok(value)
1458		: _Json_expecting('a FLOAT', value);
1459});
1460
1461var _Json_decodeValue = _Json_decodePrim(function(value) {
1462	return $elm$core$Result$Ok(_Json_wrap(value));
1463});
1464
1465var _Json_decodeString = _Json_decodePrim(function(value) {
1466	return (typeof value === 'string')
1467		? $elm$core$Result$Ok(value)
1468		: (value instanceof String)
1469			? $elm$core$Result$Ok(value + '')
1470			: _Json_expecting('a STRING', value);
1471});
1472
1473function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1474function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1475
1476function _Json_decodeNull(value) { return { $: 5, c: value }; }
1477
1478var _Json_decodeField = F2(function(field, decoder)
1479{
1480	return {
1481		$: 6,
1482		d: field,
1483		b: decoder
1484	};
1485});
1486
1487var _Json_decodeIndex = F2(function(index, decoder)
1488{
1489	return {
1490		$: 7,
1491		e: index,
1492		b: decoder
1493	};
1494});
1495
1496function _Json_decodeKeyValuePairs(decoder)
1497{
1498	return {
1499		$: 8,
1500		b: decoder
1501	};
1502}
1503
1504function _Json_mapMany(f, decoders)
1505{
1506	return {
1507		$: 9,
1508		f: f,
1509		g: decoders
1510	};
1511}
1512
1513var _Json_andThen = F2(function(callback, decoder)
1514{
1515	return {
1516		$: 10,
1517		b: decoder,
1518		h: callback
1519	};
1520});
1521
1522function _Json_oneOf(decoders)
1523{
1524	return {
1525		$: 11,
1526		g: decoders
1527	};
1528}
1529
1530
1531// DECODING OBJECTS
1532
1533var _Json_map1 = F2(function(f, d1)
1534{
1535	return _Json_mapMany(f, [d1]);
1536});
1537
1538var _Json_map2 = F3(function(f, d1, d2)
1539{
1540	return _Json_mapMany(f, [d1, d2]);
1541});
1542
1543var _Json_map3 = F4(function(f, d1, d2, d3)
1544{
1545	return _Json_mapMany(f, [d1, d2, d3]);
1546});
1547
1548var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1549{
1550	return _Json_mapMany(f, [d1, d2, d3, d4]);
1551});
1552
1553var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1554{
1555	return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1556});
1557
1558var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1559{
1560	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1561});
1562
1563var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1564{
1565	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1566});
1567
1568var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1569{
1570	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1571});
1572
1573
1574// DECODE
1575
1576var _Json_runOnString = F2(function(decoder, string)
1577{
1578	try
1579	{
1580		var value = JSON.parse(string);
1581		return _Json_runHelp(decoder, value);
1582	}
1583	catch (e)
1584	{
1585		return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
1586	}
1587});
1588
1589var _Json_run = F2(function(decoder, value)
1590{
1591	return _Json_runHelp(decoder, _Json_unwrap(value));
1592});
1593
1594function _Json_runHelp(decoder, value)
1595{
1596	switch (decoder.$)
1597	{
1598		case 2:
1599			return decoder.b(value);
1600
1601		case 5:
1602			return (value === null)
1603				? $elm$core$Result$Ok(decoder.c)
1604				: _Json_expecting('null', value);
1605
1606		case 3:
1607			if (!_Json_isArray(value))
1608			{
1609				return _Json_expecting('a LIST', value);
1610			}
1611			return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1612
1613		case 4:
1614			if (!_Json_isArray(value))
1615			{
1616				return _Json_expecting('an ARRAY', value);
1617			}
1618			return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1619
1620		case 6:
1621			var field = decoder.d;
1622			if (typeof value !== 'object' || value === null || !(field in value))
1623			{
1624				return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1625			}
1626			var result = _Json_runHelp(decoder.b, value[field]);
1627			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1628
1629		case 7:
1630			var index = decoder.e;
1631			if (!_Json_isArray(value))
1632			{
1633				return _Json_expecting('an ARRAY', value);
1634			}
1635			if (index >= value.length)
1636			{
1637				return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1638			}
1639			var result = _Json_runHelp(decoder.b, value[index]);
1640			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1641
1642		case 8:
1643			if (typeof value !== 'object' || value === null || _Json_isArray(value))
1644			{
1645				return _Json_expecting('an OBJECT', value);
1646			}
1647
1648			var keyValuePairs = _List_Nil;
1649			// TODO test perf of Object.keys and switch when support is good enough
1650			for (var key in value)
1651			{
1652				if (value.hasOwnProperty(key))
1653				{
1654					var result = _Json_runHelp(decoder.b, value[key]);
1655					if (!$elm$core$Result$isOk(result))
1656					{
1657						return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1658					}
1659					keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1660				}
1661			}
1662			return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1663
1664		case 9:
1665			var answer = decoder.f;
1666			var decoders = decoder.g;
1667			for (var i = 0; i < decoders.length; i++)
1668			{
1669				var result = _Json_runHelp(decoders[i], value);
1670				if (!$elm$core$Result$isOk(result))
1671				{
1672					return result;
1673				}
1674				answer = answer(result.a);
1675			}
1676			return $elm$core$Result$Ok(answer);
1677
1678		case 10:
1679			var result = _Json_runHelp(decoder.b, value);
1680			return (!$elm$core$Result$isOk(result))
1681				? result
1682				: _Json_runHelp(decoder.h(result.a), value);
1683
1684		case 11:
1685			var errors = _List_Nil;
1686			for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1687			{
1688				var result = _Json_runHelp(temp.a, value);
1689				if ($elm$core$Result$isOk(result))
1690				{
1691					return result;
1692				}
1693				errors = _List_Cons(result.a, errors);
1694			}
1695			return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1696
1697		case 1:
1698			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1699
1700		case 0:
1701			return $elm$core$Result$Ok(decoder.a);
1702	}
1703}
1704
1705function _Json_runArrayDecoder(decoder, value, toElmValue)
1706{
1707	var len = value.length;
1708	var array = new Array(len);
1709	for (var i = 0; i < len; i++)
1710	{
1711		var result = _Json_runHelp(decoder, value[i]);
1712		if (!$elm$core$Result$isOk(result))
1713		{
1714			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1715		}
1716		array[i] = result.a;
1717	}
1718	return $elm$core$Result$Ok(toElmValue(array));
1719}
1720
1721function _Json_isArray(value)
1722{
1723	return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1724}
1725
1726function _Json_toElmArray(array)
1727{
1728	return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1729}
1730
1731function _Json_expecting(type, value)
1732{
1733	return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1734}
1735
1736
1737// EQUALITY
1738
1739function _Json_equality(x, y)
1740{
1741	if (x === y)
1742	{
1743		return true;
1744	}
1745
1746	if (x.$ !== y.$)
1747	{
1748		return false;
1749	}
1750
1751	switch (x.$)
1752	{
1753		case 0:
1754		case 1:
1755			return x.a === y.a;
1756
1757		case 2:
1758			return x.b === y.b;
1759
1760		case 5:
1761			return x.c === y.c;
1762
1763		case 3:
1764		case 4:
1765		case 8:
1766			return _Json_equality(x.b, y.b);
1767
1768		case 6:
1769			return x.d === y.d && _Json_equality(x.b, y.b);
1770
1771		case 7:
1772			return x.e === y.e && _Json_equality(x.b, y.b);
1773
1774		case 9:
1775			return x.f === y.f && _Json_listEquality(x.g, y.g);
1776
1777		case 10:
1778			return x.h === y.h && _Json_equality(x.b, y.b);
1779
1780		case 11:
1781			return _Json_listEquality(x.g, y.g);
1782	}
1783}
1784
1785function _Json_listEquality(aDecoders, bDecoders)
1786{
1787	var len = aDecoders.length;
1788	if (len !== bDecoders.length)
1789	{
1790		return false;
1791	}
1792	for (var i = 0; i < len; i++)
1793	{
1794		if (!_Json_equality(aDecoders[i], bDecoders[i]))
1795		{
1796			return false;
1797		}
1798	}
1799	return true;
1800}
1801
1802
1803// ENCODE
1804
1805var _Json_encode = F2(function(indentLevel, value)
1806{
1807	return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1808});
1809
1810function _Json_wrap(value) { return { $: 0, a: value }; }
1811function _Json_unwrap(value) { return value.a; }
1812
1813function _Json_wrap_UNUSED(value) { return value; }
1814function _Json_unwrap_UNUSED(value) { return value; }
1815
1816function _Json_emptyArray() { return []; }
1817function _Json_emptyObject() { return {}; }
1818
1819var _Json_addField = F3(function(key, value, object)
1820{
1821	object[key] = _Json_unwrap(value);
1822	return object;
1823});
1824
1825function _Json_addEntry(func)
1826{
1827	return F2(function(entry, array)
1828	{
1829		array.push(_Json_unwrap(func(entry)));
1830		return array;
1831	});
1832}
1833
1834var _Json_encodeNull = _Json_wrap(null);
1835
1836
1837
1838function _Process_sleep(time)
1839{
1840	return _Scheduler_binding(function(callback) {
1841		var id = setTimeout(function() {
1842			callback(_Scheduler_succeed(_Utils_Tuple0));
1843		}, time);
1844
1845		return function() { clearTimeout(id); };
1846	});
1847}
1848
1849
1850
1851
1852// PROGRAMS
1853
1854
1855var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
1856{
1857	return _Platform_initialize(
1858		flagDecoder,
1859		args,
1860		impl.init,
1861		impl.update,
1862		impl.subscriptions,
1863		function() { return function() {} }
1864	);
1865});
1866
1867
1868
1869// INITIALIZE A PROGRAM
1870
1871
1872function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
1873{
1874	var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
1875	$elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/);
1876	var managers = {};
1877	result = init(result.a);
1878	var model = result.a;
1879	var stepper = stepperBuilder(sendToApp, model);
1880	var ports = _Platform_setupEffects(managers, sendToApp);
1881
1882	function sendToApp(msg, viewMetadata)
1883	{
1884		result = A2(update, msg, model);
1885		stepper(model = result.a, viewMetadata);
1886		_Platform_dispatchEffects(managers, result.b, subscriptions(model));
1887	}
1888
1889	_Platform_dispatchEffects(managers, result.b, subscriptions(model));
1890
1891	return ports ? { ports: ports } : {};
1892}
1893
1894
1895
1896// TRACK PRELOADS
1897//
1898// This is used by code in elm/browser and elm/http
1899// to register any HTTP requests that are triggered by init.
1900//
1901
1902
1903var _Platform_preload;
1904
1905
1906function _Platform_registerPreload(url)
1907{
1908	_Platform_preload.add(url);
1909}
1910
1911
1912
1913// EFFECT MANAGERS
1914
1915
1916var _Platform_effectManagers = {};
1917
1918
1919function _Platform_setupEffects(managers, sendToApp)
1920{
1921	var ports;
1922
1923	// setup all necessary effect managers
1924	for (var key in _Platform_effectManagers)
1925	{
1926		var manager = _Platform_effectManagers[key];
1927
1928		if (manager.a)
1929		{
1930			ports = ports || {};
1931			ports[key] = manager.a(key, sendToApp);
1932		}
1933
1934		managers[key] = _Platform_instantiateManager(manager, sendToApp);
1935	}
1936
1937	return ports;
1938}
1939
1940
1941function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
1942{
1943	return {
1944		b: init,
1945		c: onEffects,
1946		d: onSelfMsg,
1947		e: cmdMap,
1948		f: subMap
1949	};
1950}
1951
1952
1953function _Platform_instantiateManager(info, sendToApp)
1954{
1955	var router = {
1956		g: sendToApp,
1957		h: undefined
1958	};
1959
1960	var onEffects = info.c;
1961	var onSelfMsg = info.d;
1962	var cmdMap = info.e;
1963	var subMap = info.f;
1964
1965	function loop(state)
1966	{
1967		return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
1968		{
1969			var value = msg.a;
1970
1971			if (msg.$ === 0)
1972			{
1973				return A3(onSelfMsg, router, value, state);
1974			}
1975
1976			return cmdMap && subMap
1977				? A4(onEffects, router, value.i, value.j, state)
1978				: A3(onEffects, router, cmdMap ? value.i : value.j, state);
1979		}));
1980	}
1981
1982	return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
1983}
1984
1985
1986
1987// ROUTING
1988
1989
1990var _Platform_sendToApp = F2(function(router, msg)
1991{
1992	return _Scheduler_binding(function(callback)
1993	{
1994		router.g(msg);
1995		callback(_Scheduler_succeed(_Utils_Tuple0));
1996	});
1997});
1998
1999
2000var _Platform_sendToSelf = F2(function(router, msg)
2001{
2002	return A2(_Scheduler_send, router.h, {
2003		$: 0,
2004		a: msg
2005	});
2006});
2007
2008
2009
2010// BAGS
2011
2012
2013function _Platform_leaf(home)
2014{
2015	return function(value)
2016	{
2017		return {
2018			$: 1,
2019			k: home,
2020			l: value
2021		};
2022	};
2023}
2024
2025
2026function _Platform_batch(list)
2027{
2028	return {
2029		$: 2,
2030		m: list
2031	};
2032}
2033
2034
2035var _Platform_map = F2(function(tagger, bag)
2036{
2037	return {
2038		$: 3,
2039		n: tagger,
2040		o: bag
2041	}
2042});
2043
2044
2045
2046// PIPE BAGS INTO EFFECT MANAGERS
2047
2048
2049function _Platform_dispatchEffects(managers, cmdBag, subBag)
2050{
2051	var effectsDict = {};
2052	_Platform_gatherEffects(true, cmdBag, effectsDict, null);
2053	_Platform_gatherEffects(false, subBag, effectsDict, null);
2054
2055	for (var home in managers)
2056	{
2057		_Scheduler_rawSend(managers[home], {
2058			$: 'fx',
2059			a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2060		});
2061	}
2062}
2063
2064
2065function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2066{
2067	switch (bag.$)
2068	{
2069		case 1:
2070			var home = bag.k;
2071			var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2072			effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2073			return;
2074
2075		case 2:
2076			for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2077			{
2078				_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2079			}
2080			return;
2081
2082		case 3:
2083			_Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2084				p: bag.n,
2085				q: taggers
2086			});
2087			return;
2088	}
2089}
2090
2091
2092function _Platform_toEffect(isCmd, home, taggers, value)
2093{
2094	function applyTaggers(x)
2095	{
2096		for (var temp = taggers; temp; temp = temp.q)
2097		{
2098			x = temp.p(x);
2099		}
2100		return x;
2101	}
2102
2103	var map = isCmd
2104		? _Platform_effectManagers[home].e
2105		: _Platform_effectManagers[home].f;
2106
2107	return A2(map, applyTaggers, value)
2108}
2109
2110
2111function _Platform_insert(isCmd, newEffect, effects)
2112{
2113	effects = effects || { i: _List_Nil, j: _List_Nil };
2114
2115	isCmd
2116		? (effects.i = _List_Cons(newEffect, effects.i))
2117		: (effects.j = _List_Cons(newEffect, effects.j));
2118
2119	return effects;
2120}
2121
2122
2123
2124// PORTS
2125
2126
2127function _Platform_checkPortName(name)
2128{
2129	if (_Platform_effectManagers[name])
2130	{
2131		_Debug_crash(3, name)
2132	}
2133}
2134
2135
2136
2137// OUTGOING PORTS
2138
2139
2140function _Platform_outgoingPort(name, converter)
2141{
2142	_Platform_checkPortName(name);
2143	_Platform_effectManagers[name] = {
2144		e: _Platform_outgoingPortMap,
2145		r: converter,
2146		a: _Platform_setupOutgoingPort
2147	};
2148	return _Platform_leaf(name);
2149}
2150
2151
2152var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2153
2154
2155function _Platform_setupOutgoingPort(name)
2156{
2157	var subs = [];
2158	var converter = _Platform_effectManagers[name].r;
2159
2160	// CREATE MANAGER
2161
2162	var init = _Process_sleep(0);
2163
2164	_Platform_effectManagers[name].b = init;
2165	_Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2166	{
2167		for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2168		{
2169			// grab a separate reference to subs in case unsubscribe is called
2170			var currentSubs = subs;
2171			var value = _Json_unwrap(converter(cmdList.a));
2172			for (var i = 0; i < currentSubs.length; i++)
2173			{
2174				currentSubs[i](value);
2175			}
2176		}
2177		return init;
2178	});
2179
2180	// PUBLIC API
2181
2182	function subscribe(callback)
2183	{
2184		subs.push(callback);
2185	}
2186
2187	function unsubscribe(callback)
2188	{
2189		// copy subs into a new array in case unsubscribe is called within a
2190		// subscribed callback
2191		subs = subs.slice();
2192		var index = subs.indexOf(callback);
2193		if (index >= 0)
2194		{
2195			subs.splice(index, 1);
2196		}
2197	}
2198
2199	return {
2200		subscribe: subscribe,
2201		unsubscribe: unsubscribe
2202	};
2203}
2204
2205
2206
2207// INCOMING PORTS
2208
2209
2210function _Platform_incomingPort(name, converter)
2211{
2212	_Platform_checkPortName(name);
2213	_Platform_effectManagers[name] = {
2214		f: _Platform_incomingPortMap,
2215		r: converter,
2216		a: _Platform_setupIncomingPort
2217	};
2218	return _Platform_leaf(name);
2219}
2220
2221
2222var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2223{
2224	return function(value)
2225	{
2226		return tagger(finalTagger(value));
2227	};
2228});
2229
2230
2231function _Platform_setupIncomingPort(name, sendToApp)
2232{
2233	var subs = _List_Nil;
2234	var converter = _Platform_effectManagers[name].r;
2235
2236	// CREATE MANAGER
2237
2238	var init = _Scheduler_succeed(null);
2239
2240	_Platform_effectManagers[name].b = init;
2241	_Platform_effectManagers[name].c = F3(function(router, subList, state)
2242	{
2243		subs = subList;
2244		return init;
2245	});
2246
2247	// PUBLIC API
2248
2249	function send(incomingValue)
2250	{
2251		var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2252
2253		$elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2254
2255		var value = result.a;
2256		for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2257		{
2258			sendToApp(temp.a(value));
2259		}
2260	}
2261
2262	return { send: send };
2263}
2264
2265
2266
2267// EXPORT ELM MODULES
2268//
2269// Have DEBUG and PROD versions so that we can (1) give nicer errors in
2270// debug mode and (2) not pay for the bits needed for that in prod mode.
2271//
2272
2273
2274function _Platform_export_UNUSED(exports)
2275{
2276	scope['Elm']
2277		? _Platform_mergeExportsProd(scope['Elm'], exports)
2278		: scope['Elm'] = exports;
2279}
2280
2281
2282function _Platform_mergeExportsProd(obj, exports)
2283{
2284	for (var name in exports)
2285	{
2286		(name in obj)
2287			? (name == 'init')
2288				? _Debug_crash(6)
2289				: _Platform_mergeExportsProd(obj[name], exports[name])
2290			: (obj[name] = exports[name]);
2291	}
2292}
2293
2294
2295function _Platform_export(exports)
2296{
2297	scope['Elm']
2298		? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
2299		: scope['Elm'] = exports;
2300}
2301
2302
2303function _Platform_mergeExportsDebug(moduleName, obj, exports)
2304{
2305	for (var name in exports)
2306	{
2307		(name in obj)
2308			? (name == 'init')
2309				? _Debug_crash(6, moduleName)
2310				: _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
2311			: (obj[name] = exports[name]);
2312	}
2313}
2314
2315
2316
2317// SEND REQUEST
2318
2319var _Http_toTask = F3(function(router, toTask, request)
2320{
2321	return _Scheduler_binding(function(callback)
2322	{
2323		function done(response) {
2324			callback(toTask(request.expect.a(response)));
2325		}
2326
2327		var xhr = new XMLHttpRequest();
2328		xhr.addEventListener('error', function() { done($elm$http$Http$NetworkError_); });
2329		xhr.addEventListener('timeout', function() { done($elm$http$Http$Timeout_); });
2330		xhr.addEventListener('load', function() { done(_Http_toResponse(request.expect.b, xhr)); });
2331		$elm$core$Maybe$isJust(request.tracker) && _Http_track(router, xhr, request.tracker.a);
2332
2333		try {
2334			xhr.open(request.method, request.url, true);
2335		} catch (e) {
2336			return done($elm$http$Http$BadUrl_(request.url));
2337		}
2338
2339		_Http_configureRequest(xhr, request);
2340
2341		request.body.a && xhr.setRequestHeader('Content-Type', request.body.a);
2342		xhr.send(request.body.b);
2343
2344		return function() { xhr.c = true; xhr.abort(); };
2345	});
2346});
2347
2348
2349// CONFIGURE
2350
2351function _Http_configureRequest(xhr, request)
2352{
2353	for (var headers = request.headers; headers.b; headers = headers.b) // WHILE_CONS
2354	{
2355		xhr.setRequestHeader(headers.a.a, headers.a.b);
2356	}
2357	xhr.timeout = request.timeout.a || 0;
2358	xhr.responseType = request.expect.d;
2359	xhr.withCredentials = request.allowCookiesFromOtherDomains;
2360}
2361
2362
2363// RESPONSES
2364
2365function _Http_toResponse(toBody, xhr)
2366{
2367	return A2(
2368		200 <= xhr.status && xhr.status < 300 ? $elm$http$Http$GoodStatus_ : $elm$http$Http$BadStatus_,
2369		_Http_toMetadata(xhr),
2370		toBody(xhr.response)
2371	);
2372}
2373
2374
2375// METADATA
2376
2377function _Http_toMetadata(xhr)
2378{
2379	return {
2380		url: xhr.responseURL,
2381		statusCode: xhr.status,
2382		statusText: xhr.statusText,
2383		headers: _Http_parseHeaders(xhr.getAllResponseHeaders())
2384	};
2385}
2386
2387
2388// HEADERS
2389
2390function _Http_parseHeaders(rawHeaders)
2391{
2392	if (!rawHeaders)
2393	{
2394		return $elm$core$Dict$empty;
2395	}
2396
2397	var headers = $elm$core$Dict$empty;
2398	var headerPairs = rawHeaders.split('\r\n');
2399	for (var i = headerPairs.length; i--; )
2400	{
2401		var headerPair = headerPairs[i];
2402		var index = headerPair.indexOf(': ');
2403		if (index > 0)
2404		{
2405			var key = headerPair.substring(0, index);
2406			var value = headerPair.substring(index + 2);
2407
2408			headers = A3($elm$core$Dict$update, key, function(oldValue) {
2409				return $elm$core$Maybe$Just($elm$core$Maybe$isJust(oldValue)
2410					? value + ', ' + oldValue.a
2411					: value
2412				);
2413			}, headers);
2414		}
2415	}
2416	return headers;
2417}
2418
2419
2420// EXPECT
2421
2422var _Http_expect = F3(function(type, toBody, toValue)
2423{
2424	return {
2425		$: 0,
2426		d: type,
2427		b: toBody,
2428		a: toValue
2429	};
2430});
2431
2432var _Http_mapExpect = F2(function(func, expect)
2433{
2434	return {
2435		$: 0,
2436		d: expect.d,
2437		b: expect.b,
2438		a: function(x) { return func(expect.a(x)); }
2439	};
2440});
2441
2442function _Http_toDataView(arrayBuffer)
2443{
2444	return new DataView(arrayBuffer);
2445}
2446
2447
2448// BODY and PARTS
2449
2450var _Http_emptyBody = { $: 0 };
2451var _Http_pair = F2(function(a, b) { return { $: 0, a: a, b: b }; });
2452
2453function _Http_toFormData(parts)
2454{
2455	for (var formData = new FormData(); parts.b; parts = parts.b) // WHILE_CONS
2456	{
2457		var part = parts.a;
2458		formData.append(part.a, part.b);
2459	}
2460	return formData;
2461}
2462
2463var _Http_bytesToBlob = F2(function(mime, bytes)
2464{
2465	return new Blob([bytes], { type: mime });
2466});
2467
2468
2469// PROGRESS
2470
2471function _Http_track(router, xhr, tracker)
2472{
2473	// TODO check out lengthComputable on loadstart event
2474
2475	xhr.upload.addEventListener('progress', function(event) {
2476		if (xhr.c) { return; }
2477		_Scheduler_rawSpawn(A2($elm$core$Platform$sendToSelf, router, _Utils_Tuple2(tracker, $elm$http$Http$Sending({
2478			sent: event.loaded,
2479			size: event.total
2480		}))));
2481	});
2482	xhr.addEventListener('progress', function(event) {
2483		if (xhr.c) { return; }
2484		_Scheduler_rawSpawn(A2($elm$core$Platform$sendToSelf, router, _Utils_Tuple2(tracker, $elm$http$Http$Receiving({
2485			received: event.loaded,
2486			size: event.lengthComputable ? $elm$core$Maybe$Just(event.total) : $elm$core$Maybe$Nothing
2487		}))));
2488	});
2489}var $elm$core$Basics$EQ = {$: 'EQ'};
2490var $elm$core$Basics$LT = {$: 'LT'};
2491var $elm$core$List$cons = _List_cons;
2492var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
2493var $elm$core$Array$foldr = F3(
2494	function (func, baseCase, _v0) {
2495		var tree = _v0.c;
2496		var tail = _v0.d;
2497		var helper = F2(
2498			function (node, acc) {
2499				if (node.$ === 'SubTree') {
2500					var subTree = node.a;
2501					return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
2502				} else {
2503					var values = node.a;
2504					return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
2505				}
2506			});
2507		return A3(
2508			$elm$core$Elm$JsArray$foldr,
2509			helper,
2510			A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
2511			tree);
2512	});
2513var $elm$core$Array$toList = function (array) {
2514	return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
2515};
2516var $elm$core$Dict$foldr = F3(
2517	function (func, acc, t) {
2518		foldr:
2519		while (true) {
2520			if (t.$ === 'RBEmpty_elm_builtin') {
2521				return acc;
2522			} else {
2523				var key = t.b;
2524				var value = t.c;
2525				var left = t.d;
2526				var right = t.e;
2527				var $temp$func = func,
2528					$temp$acc = A3(
2529					func,
2530					key,
2531					value,
2532					A3($elm$core$Dict$foldr, func, acc, right)),
2533					$temp$t = left;
2534				func = $temp$func;
2535				acc = $temp$acc;
2536				t = $temp$t;
2537				continue foldr;
2538			}
2539		}
2540	});
2541var $elm$core$Dict$toList = function (dict) {
2542	return A3(
2543		$elm$core$Dict$foldr,
2544		F3(
2545			function (key, value, list) {
2546				return A2(
2547					$elm$core$List$cons,
2548					_Utils_Tuple2(key, value),
2549					list);
2550			}),
2551		_List_Nil,
2552		dict);
2553};
2554var $elm$core$Dict$keys = function (dict) {
2555	return A3(
2556		$elm$core$Dict$foldr,
2557		F3(
2558			function (key, value, keyList) {
2559				return A2($elm$core$List$cons, key, keyList);
2560			}),
2561		_List_Nil,
2562		dict);
2563};
2564var $elm$core$Set$toList = function (_v0) {
2565	var dict = _v0.a;
2566	return $elm$core$Dict$keys(dict);
2567};
2568var $elm$core$Basics$GT = {$: 'GT'};
2569var $elm$core$Basics$identity = function (x) {
2570	return x;
2571};
2572var $author$project$Main$GotIp = function (a) {
2573	return {$: 'GotIp', a: a};
2574};
2575var $elm$core$Result$Ok = function (a) {
2576	return {$: 'Ok', a: a};
2577};
2578var $elm$http$Http$BadStatus_ = F2(
2579	function (a, b) {
2580		return {$: 'BadStatus_', a: a, b: b};
2581	});
2582var $elm$http$Http$BadUrl_ = function (a) {
2583	return {$: 'BadUrl_', a: a};
2584};
2585var $elm$http$Http$GoodStatus_ = F2(
2586	function (a, b) {
2587		return {$: 'GoodStatus_', a: a, b: b};
2588	});
2589var $elm$core$Maybe$Just = function (a) {
2590	return {$: 'Just', a: a};
2591};
2592var $elm$http$Http$NetworkError_ = {$: 'NetworkError_'};
2593var $elm$core$Maybe$Nothing = {$: 'Nothing'};
2594var $elm$http$Http$Receiving = function (a) {
2595	return {$: 'Receiving', a: a};
2596};
2597var $elm$http$Http$Sending = function (a) {
2598	return {$: 'Sending', a: a};
2599};
2600var $elm$http$Http$Timeout_ = {$: 'Timeout_'};
2601var $elm$core$Dict$RBEmpty_elm_builtin = {$: 'RBEmpty_elm_builtin'};
2602var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin;
2603var $elm$core$Basics$False = {$: 'False'};
2604var $elm$core$Basics$True = {$: 'True'};
2605var $elm$core$Maybe$isJust = function (maybe) {
2606	if (maybe.$ === 'Just') {
2607		return true;
2608	} else {
2609		return false;
2610	}
2611};
2612var $elm$core$Result$Err = function (a) {
2613	return {$: 'Err', a: a};
2614};
2615var $elm$json$Json$Decode$Failure = F2(
2616	function (a, b) {
2617		return {$: 'Failure', a: a, b: b};
2618	});
2619var $elm$json$Json$Decode$Field = F2(
2620	function (a, b) {
2621		return {$: 'Field', a: a, b: b};
2622	});
2623var $elm$json$Json$Decode$Index = F2(
2624	function (a, b) {
2625		return {$: 'Index', a: a, b: b};
2626	});
2627var $elm$json$Json$Decode$OneOf = function (a) {
2628	return {$: 'OneOf', a: a};
2629};
2630var $elm$core$Basics$add = _Basics_add;
2631var $elm$core$String$all = _String_all;
2632var $elm$core$Basics$and = _Basics_and;
2633var $elm$core$Basics$append = _Utils_append;
2634var $elm$json$Json$Encode$encode = _Json_encode;
2635var $elm$core$String$fromInt = _String_fromNumber;
2636var $elm$core$String$join = F2(
2637	function (sep, chunks) {
2638		return A2(
2639			_String_join,
2640			sep,
2641			_List_toArray(chunks));
2642	});
2643var $elm$core$String$split = F2(
2644	function (sep, string) {
2645		return _List_fromArray(
2646			A2(_String_split, sep, string));
2647	});
2648var $elm$json$Json$Decode$indent = function (str) {
2649	return A2(
2650		$elm$core$String$join,
2651		'\n    ',
2652		A2($elm$core$String$split, '\n', str));
2653};
2654var $elm$core$List$foldl = F3(
2655	function (func, acc, list) {
2656		foldl:
2657		while (true) {
2658			if (!list.b) {
2659				return acc;
2660			} else {
2661				var x = list.a;
2662				var xs = list.b;
2663				var $temp$func = func,
2664					$temp$acc = A2(func, x, acc),
2665					$temp$list = xs;
2666				func = $temp$func;
2667				acc = $temp$acc;
2668				list = $temp$list;
2669				continue foldl;
2670			}
2671		}
2672	});
2673var $elm$core$List$length = function (xs) {
2674	return A3(
2675		$elm$core$List$foldl,
2676		F2(
2677			function (_v0, i) {
2678				return i + 1;
2679			}),
2680		0,
2681		xs);
2682};
2683var $elm$core$List$map2 = _List_map2;
2684var $elm$core$Basics$le = _Utils_le;
2685var $elm$core$Basics$sub = _Basics_sub;
2686var $elm$core$List$rangeHelp = F3(
2687	function (lo, hi, list) {
2688		rangeHelp:
2689		while (true) {
2690			if (_Utils_cmp(lo, hi) < 1) {
2691				var $temp$lo = lo,
2692					$temp$hi = hi - 1,
2693					$temp$list = A2($elm$core$List$cons, hi, list);
2694				lo = $temp$lo;
2695				hi = $temp$hi;
2696				list = $temp$list;
2697				continue rangeHelp;
2698			} else {
2699				return list;
2700			}
2701		}
2702	});
2703var $elm$core$List$range = F2(
2704	function (lo, hi) {
2705		return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
2706	});
2707var $elm$core$List$indexedMap = F2(
2708	function (f, xs) {
2709		return A3(
2710			$elm$core$List$map2,
2711			f,
2712			A2(
2713				$elm$core$List$range,
2714				0,
2715				$elm$core$List$length(xs) - 1),
2716			xs);
2717	});
2718var $elm$core$Char$toCode = _Char_toCode;
2719var $elm$core$Char$isLower = function (_char) {
2720	var code = $elm$core$Char$toCode(_char);
2721	return (97 <= code) && (code <= 122);
2722};
2723var $elm$core$Char$isUpper = function (_char) {
2724	var code = $elm$core$Char$toCode(_char);
2725	return (code <= 90) && (65 <= code);
2726};
2727var $elm$core$Basics$or = _Basics_or;
2728var $elm$core$Char$isAlpha = function (_char) {
2729	return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
2730};
2731var $elm$core$Char$isDigit = function (_char) {
2732	var code = $elm$core$Char$toCode(_char);
2733	return (code <= 57) && (48 <= code);
2734};
2735var $elm$core$Char$isAlphaNum = function (_char) {
2736	return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
2737};
2738var $elm$core$List$reverse = function (list) {
2739	return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
2740};
2741var $elm$core$String$uncons = _String_uncons;
2742var $elm$json$Json$Decode$errorOneOf = F2(
2743	function (i, error) {
2744		return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
2745			$elm$json$Json$Decode$errorToString(error))));
2746	});
2747var $elm$json$Json$Decode$errorToString = function (error) {
2748	return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
2749};
2750var $elm$json$Json$Decode$errorToStringHelp = F2(
2751	function (error, context) {
2752		errorToStringHelp:
2753		while (true) {
2754			switch (error.$) {
2755				case 'Field':
2756					var f = error.a;
2757					var err = error.b;
2758					var isSimple = function () {
2759						var _v1 = $elm$core$String$uncons(f);
2760						if (_v1.$ === 'Nothing') {
2761							return false;
2762						} else {
2763							var _v2 = _v1.a;
2764							var _char = _v2.a;
2765							var rest = _v2.b;
2766							return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
2767						}
2768					}();
2769					var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
2770					var $temp$error = err,
2771						$temp$context = A2($elm$core$List$cons, fieldName, context);
2772					error = $temp$error;
2773					context = $temp$context;
2774					continue errorToStringHelp;
2775				case 'Index':
2776					var i = error.a;
2777					var err = error.b;
2778					var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
2779					var $temp$error = err,
2780						$temp$context = A2($elm$core$List$cons, indexName, context);
2781					error = $temp$error;
2782					context = $temp$context;
2783					continue errorToStringHelp;
2784				case 'OneOf':
2785					var errors = error.a;
2786					if (!errors.b) {
2787						return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
2788							if (!context.b) {
2789								return '!';
2790							} else {
2791								return ' at json' + A2(
2792									$elm$core$String$join,
2793									'',
2794									$elm$core$List$reverse(context));
2795							}
2796						}();
2797					} else {
2798						if (!errors.b.b) {
2799							var err = errors.a;
2800							var $temp$error = err,
2801								$temp$context = context;
2802							error = $temp$error;
2803							context = $temp$context;
2804							continue errorToStringHelp;
2805						} else {
2806							var starter = function () {
2807								if (!context.b) {
2808									return 'Json.Decode.oneOf';
2809								} else {
2810									return 'The Json.Decode.oneOf at json' + A2(
2811										$elm$core$String$join,
2812										'',
2813										$elm$core$List$reverse(context));
2814								}
2815							}();
2816							var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
2817								$elm$core$List$length(errors)) + ' ways:'));
2818							return A2(
2819								$elm$core$String$join,
2820								'\n\n',
2821								A2(
2822									$elm$core$List$cons,
2823									introduction,
2824									A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
2825						}
2826					}
2827				default:
2828					var msg = error.a;
2829					var json = error.b;
2830					var introduction = function () {
2831						if (!context.b) {
2832							return 'Problem with the given value:\n\n';
2833						} else {
2834							return 'Problem with the value at json' + (A2(
2835								$elm$core$String$join,
2836								'',
2837								$elm$core$List$reverse(context)) + ':\n\n    ');
2838						}
2839					}();
2840					return introduction + ($elm$json$Json$Decode$indent(
2841						A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
2842			}
2843		}
2844	});
2845var $elm$core$Array$branchFactor = 32;
2846var $elm$core$Array$Array_elm_builtin = F4(
2847	function (a, b, c, d) {
2848		return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};
2849	});
2850var $elm$core$Elm$JsArray$empty = _JsArray_empty;
2851var $elm$core$Basics$ceiling = _Basics_ceiling;
2852var $elm$core$Basics$fdiv = _Basics_fdiv;
2853var $elm$core$Basics$logBase = F2(
2854	function (base, number) {
2855		return _Basics_log(number) / _Basics_log(base);
2856	});
2857var $elm$core$Basics$toFloat = _Basics_toFloat;
2858var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
2859	A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
2860var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty);
2861var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
2862var $elm$core$Array$Leaf = function (a) {
2863	return {$: 'Leaf', a: a};
2864};
2865var $elm$core$Basics$apL = F2(
2866	function (f, x) {
2867		return f(x);
2868	});
2869var $elm$core$Basics$apR = F2(
2870	function (x, f) {
2871		return f(x);
2872	});
2873var $elm$core$Basics$eq = _Utils_equal;
2874var $elm$core$Basics$floor = _Basics_floor;
2875var $elm$core$Elm$JsArray$length = _JsArray_length;
2876var $elm$core$Basics$gt = _Utils_gt;
2877var $elm$core$Basics$max = F2(
2878	function (x, y) {
2879		return (_Utils_cmp(x, y) > 0) ? x : y;
2880	});
2881var $elm$core$Basics$mul = _Basics_mul;
2882var $elm$core$Array$SubTree = function (a) {
2883	return {$: 'SubTree', a: a};
2884};
2885var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
2886var $elm$core$Array$compressNodes = F2(
2887	function (nodes, acc) {
2888		compressNodes:
2889		while (true) {
2890			var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
2891			var node = _v0.a;
2892			var remainingNodes = _v0.b;
2893			var newAcc = A2(
2894				$elm$core$List$cons,
2895				$elm$core$Array$SubTree(node),
2896				acc);
2897			if (!remainingNodes.b) {
2898				return $elm$core$List$reverse(newAcc);
2899			} else {
2900				var $temp$nodes = remainingNodes,
2901					$temp$acc = newAcc;
2902				nodes = $temp$nodes;
2903				acc = $temp$acc;
2904				continue compressNodes;
2905			}
2906		}
2907	});
2908var $elm$core$Tuple$first = function (_v0) {
2909	var x = _v0.a;
2910	return x;
2911};
2912var $elm$core$Array$treeFromBuilder = F2(
2913	function (nodeList, nodeListSize) {
2914		treeFromBuilder:
2915		while (true) {
2916			var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
2917			if (newNodeSize === 1) {
2918				return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
2919			} else {
2920				var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
2921					$temp$nodeListSize = newNodeSize;
2922				nodeList = $temp$nodeList;
2923				nodeListSize = $temp$nodeListSize;
2924				continue treeFromBuilder;
2925			}
2926		}
2927	});
2928var $elm$core$Array$builderToArray = F2(
2929	function (reverseNodeList, builder) {
2930		if (!builder.nodeListSize) {
2931			return A4(
2932				$elm$core$Array$Array_elm_builtin,
2933				$elm$core$Elm$JsArray$length(builder.tail),
2934				$elm$core$Array$shiftStep,
2935				$elm$core$Elm$JsArray$empty,
2936				builder.tail);
2937		} else {
2938			var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;
2939			var depth = $elm$core$Basics$floor(
2940				A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
2941			var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;
2942			var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);
2943			return A4(
2944				$elm$core$Array$Array_elm_builtin,
2945				$elm$core$Elm$JsArray$length(builder.tail) + treeLen,
2946				A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
2947				tree,
2948				builder.tail);
2949		}
2950	});
2951var $elm$core$Basics$idiv = _Basics_idiv;
2952var $elm$core$Basics$lt = _Utils_lt;
2953var $elm$core$Array$initializeHelp = F5(
2954	function (fn, fromIndex, len, nodeList, tail) {
2955		initializeHelp:
2956		while (true) {
2957			if (fromIndex < 0) {
2958				return A2(
2959					$elm$core$Array$builderToArray,
2960					false,
2961					{nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});
2962			} else {
2963				var leaf = $elm$core$Array$Leaf(
2964					A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
2965				var $temp$fn = fn,
2966					$temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
2967					$temp$len = len,
2968					$temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
2969					$temp$tail = tail;
2970				fn = $temp$fn;
2971				fromIndex = $temp$fromIndex;
2972				len = $temp$len;
2973				nodeList = $temp$nodeList;
2974				tail = $temp$tail;
2975				continue initializeHelp;
2976			}
2977		}
2978	});
2979var $elm$core$Basics$remainderBy = _Basics_remainderBy;
2980var $elm$core$Array$initialize = F2(
2981	function (len, fn) {
2982		if (len <= 0) {
2983			return $elm$core$Array$empty;
2984		} else {
2985			var tailLen = len % $elm$core$Array$branchFactor;
2986			var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);
2987			var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
2988			return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
2989		}
2990	});
2991var $elm$core$Result$isOk = function (result) {
2992	if (result.$ === 'Ok') {
2993		return true;
2994	} else {
2995		return false;
2996	}
2997};
2998var $elm$core$Platform$sendToSelf = _Platform_sendToSelf;
2999var $elm$core$Basics$compare = _Utils_compare;
3000var $elm$core$Dict$get = F2(
3001	function (targetKey, dict) {
3002		get:
3003		while (true) {
3004			if (dict.$ === 'RBEmpty_elm_builtin') {
3005				return $elm$core$Maybe$Nothing;
3006			} else {
3007				var key = dict.b;
3008				var value = dict.c;
3009				var left = dict.d;
3010				var right = dict.e;
3011				var _v1 = A2($elm$core$Basics$compare, targetKey, key);
3012				switch (_v1.$) {
3013					case 'LT':
3014						var $temp$targetKey = targetKey,
3015							$temp$dict = left;
3016						targetKey = $temp$targetKey;
3017						dict = $temp$dict;
3018						continue get;
3019					case 'EQ':
3020						return $elm$core$Maybe$Just(value);
3021					default:
3022						var $temp$targetKey = targetKey,
3023							$temp$dict = right;
3024						targetKey = $temp$targetKey;
3025						dict = $temp$dict;
3026						continue get;
3027				}
3028			}
3029		}
3030	});
3031var $elm$core$Dict$Black = {$: 'Black'};
3032var $elm$core$Dict$RBNode_elm_builtin = F5(
3033	function (a, b, c, d, e) {
3034		return {$: 'RBNode_elm_builtin', a: a, b: b, c: c, d: d, e: e};
3035	});
3036var $elm$core$Dict$Red = {$: 'Red'};
3037var $elm$core$Dict$balance = F5(
3038	function (color, key, value, left, right) {
3039		if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Red')) {
3040			var _v1 = right.a;
3041			var rK = right.b;
3042			var rV = right.c;
3043			var rLeft = right.d;
3044			var rRight = right.e;
3045			if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) {
3046				var _v3 = left.a;
3047				var lK = left.b;
3048				var lV = left.c;
3049				var lLeft = left.d;
3050				var lRight = left.e;
3051				return A5(
3052					$elm$core$Dict$RBNode_elm_builtin,
3053					$elm$core$Dict$Red,
3054					key,
3055					value,
3056					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, lK, lV, lLeft, lRight),
3057					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rLeft, rRight));
3058			} else {
3059				return A5(
3060					$elm$core$Dict$RBNode_elm_builtin,
3061					color,
3062					rK,
3063					rV,
3064					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, left, rLeft),
3065					rRight);
3066			}
3067		} else {
3068			if ((((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) && (left.d.$ === 'RBNode_elm_builtin')) && (left.d.a.$ === 'Red')) {
3069				var _v5 = left.a;
3070				var lK = left.b;
3071				var lV = left.c;
3072				var _v6 = left.d;
3073				var _v7 = _v6.a;
3074				var llK = _v6.b;
3075				var llV = _v6.c;
3076				var llLeft = _v6.d;
3077				var llRight = _v6.e;
3078				var lRight = left.e;
3079				return A5(
3080					$elm$core$Dict$RBNode_elm_builtin,
3081					$elm$core$Dict$Red,
3082					lK,
3083					lV,
3084					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight),
3085					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, key, value, lRight, right));
3086			} else {
3087				return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right);
3088			}
3089		}
3090	});
3091var $elm$core$Dict$insertHelp = F3(
3092	function (key, value, dict) {
3093		if (dict.$ === 'RBEmpty_elm_builtin') {
3094			return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, $elm$core$Dict$RBEmpty_elm_builtin, $elm$core$Dict$RBEmpty_elm_builtin);
3095		} else {
3096			var nColor = dict.a;
3097			var nKey = dict.b;
3098			var nValue = dict.c;
3099			var nLeft = dict.d;
3100			var nRight = dict.e;
3101			var _v1 = A2($elm$core$Basics$compare, key, nKey);
3102			switch (_v1.$) {
3103				case 'LT':
3104					return A5(
3105						$elm$core$Dict$balance,
3106						nColor,
3107						nKey,
3108						nValue,
3109						A3($elm$core$Dict$insertHelp, key, value, nLeft),
3110						nRight);
3111				case 'EQ':
3112					return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight);
3113				default:
3114					return A5(
3115						$elm$core$Dict$balance,
3116						nColor,
3117						nKey,
3118						nValue,
3119						nLeft,
3120						A3($elm$core$Dict$insertHelp, key, value, nRight));
3121			}
3122		}
3123	});
3124var $elm$core$Dict$insert = F3(
3125	function (key, value, dict) {
3126		var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict);
3127		if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) {
3128			var _v1 = _v0.a;
3129			var k = _v0.b;
3130			var v = _v0.c;
3131			var l = _v0.d;
3132			var r = _v0.e;
3133			return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r);
3134		} else {
3135			var x = _v0;
3136			return x;
3137		}
3138	});
3139var $elm$core$Dict$getMin = function (dict) {
3140	getMin:
3141	while (true) {
3142		if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) {
3143			var left = dict.d;
3144			var $temp$dict = left;
3145			dict = $temp$dict;
3146			continue getMin;
3147		} else {
3148			return dict;
3149		}
3150	}
3151};
3152var $elm$core$Dict$moveRedLeft = function (dict) {
3153	if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) {
3154		if ((dict.e.d.$ === 'RBNode_elm_builtin') && (dict.e.d.a.$ === 'Red')) {
3155			var clr = dict.a;
3156			var k = dict.b;
3157			var v = dict.c;
3158			var _v1 = dict.d;
3159			var lClr = _v1.a;
3160			var lK = _v1.b;
3161			var lV = _v1.c;
3162			var lLeft = _v1.d;
3163			var lRight = _v1.e;
3164			var _v2 = dict.e;
3165			var rClr = _v2.a;
3166			var rK = _v2.b;
3167			var rV = _v2.c;
3168			var rLeft = _v2.d;
3169			var _v3 = rLeft.a;
3170			var rlK = rLeft.b;
3171			var rlV = rLeft.c;
3172			var rlL = rLeft.d;
3173			var rlR = rLeft.e;
3174			var rRight = _v2.e;
3175			return A5(
3176				$elm$core$Dict$RBNode_elm_builtin,
3177				$elm$core$Dict$Red,
3178				rlK,
3179				rlV,
3180				A5(
3181					$elm$core$Dict$RBNode_elm_builtin,
3182					$elm$core$Dict$Black,
3183					k,
3184					v,
3185					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
3186					rlL),
3187				A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rlR, rRight));
3188		} else {
3189			var clr = dict.a;
3190			var k = dict.b;
3191			var v = dict.c;
3192			var _v4 = dict.d;
3193			var lClr = _v4.a;
3194			var lK = _v4.b;
3195			var lV = _v4.c;
3196			var lLeft = _v4.d;
3197			var lRight = _v4.e;
3198			var _v5 = dict.e;
3199			var rClr = _v5.a;
3200			var rK = _v5.b;
3201			var rV = _v5.c;
3202			var rLeft = _v5.d;
3203			var rRight = _v5.e;
3204			if (clr.$ === 'Black') {
3205				return A5(
3206					$elm$core$Dict$RBNode_elm_builtin,
3207					$elm$core$Dict$Black,
3208					k,
3209					v,
3210					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
3211					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
3212			} else {
3213				return A5(
3214					$elm$core$Dict$RBNode_elm_builtin,
3215					$elm$core$Dict$Black,
3216					k,
3217					v,
3218					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
3219					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
3220			}
3221		}
3222	} else {
3223		return dict;
3224	}
3225};
3226var $elm$core$Dict$moveRedRight = function (dict) {
3227	if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) {
3228		if ((dict.d.d.$ === 'RBNode_elm_builtin') && (dict.d.d.a.$ === 'Red')) {
3229			var clr = dict.a;
3230			var k = dict.b;
3231			var v = dict.c;
3232			var _v1 = dict.d;
3233			var lClr = _v1.a;
3234			var lK = _v1.b;
3235			var lV = _v1.c;
3236			var _v2 = _v1.d;
3237			var _v3 = _v2.a;
3238			var llK = _v2.b;
3239			var llV = _v2.c;
3240			var llLeft = _v2.d;
3241			var llRight = _v2.e;
3242			var lRight = _v1.e;
3243			var _v4 = dict.e;
3244			var rClr = _v4.a;
3245			var rK = _v4.b;
3246			var rV = _v4.c;
3247			var rLeft = _v4.d;
3248			var rRight = _v4.e;
3249			return A5(
3250				$elm$core$Dict$RBNode_elm_builtin,
3251				$elm$core$Dict$Red,
3252				lK,
3253				lV,
3254				A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight),
3255				A5(
3256					$elm$core$Dict$RBNode_elm_builtin,
3257					$elm$core$Dict$Black,
3258					k,
3259					v,
3260					lRight,
3261					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight)));
3262		} else {
3263			var clr = dict.a;
3264			var k = dict.b;
3265			var v = dict.c;
3266			var _v5 = dict.d;
3267			var lClr = _v5.a;
3268			var lK = _v5.b;
3269			var lV = _v5.c;
3270			var lLeft = _v5.d;
3271			var lRight = _v5.e;
3272			var _v6 = dict.e;
3273			var rClr = _v6.a;
3274			var rK = _v6.b;
3275			var rV = _v6.c;
3276			var rLeft = _v6.d;
3277			var rRight = _v6.e;
3278			if (clr.$ === 'Black') {
3279				return A5(
3280					$elm$core$Dict$RBNode_elm_builtin,
3281					$elm$core$Dict$Black,
3282					k,
3283					v,
3284					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
3285					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
3286			} else {
3287				return A5(
3288					$elm$core$Dict$RBNode_elm_builtin,
3289					$elm$core$Dict$Black,
3290					k,
3291					v,
3292					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
3293					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
3294			}
3295		}
3296	} else {
3297		return dict;
3298	}
3299};
3300var $elm$core$Dict$removeHelpPrepEQGT = F7(
3301	function (targetKey, dict, color, key, value, left, right) {
3302		if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) {
3303			var _v1 = left.a;
3304			var lK = left.b;
3305			var lV = left.c;
3306			var lLeft = left.d;
3307			var lRight = left.e;
3308			return A5(
3309				$elm$core$Dict$RBNode_elm_builtin,
3310				color,
3311				lK,
3312				lV,
3313				lLeft,
3314				A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, lRight, right));
3315		} else {
3316			_v2$2:
3317			while (true) {
3318				if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Black')) {
3319					if (right.d.$ === 'RBNode_elm_builtin') {
3320						if (right.d.a.$ === 'Black') {
3321							var _v3 = right.a;
3322							var _v4 = right.d;
3323							var _v5 = _v4.a;
3324							return $elm$core$Dict$moveRedRight(dict);
3325						} else {
3326							break _v2$2;
3327						}
3328					} else {
3329						var _v6 = right.a;
3330						var _v7 = right.d;
3331						return $elm$core$Dict$moveRedRight(dict);
3332					}
3333				} else {
3334					break _v2$2;
3335				}
3336			}
3337			return dict;
3338		}
3339	});
3340var $elm$core$Dict$removeMin = function (dict) {
3341	if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) {
3342		var color = dict.a;
3343		var key = dict.b;
3344		var value = dict.c;
3345		var left = dict.d;
3346		var lColor = left.a;
3347		var lLeft = left.d;
3348		var right = dict.e;
3349		if (lColor.$ === 'Black') {
3350			if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) {
3351				var _v3 = lLeft.a;
3352				return A5(
3353					$elm$core$Dict$RBNode_elm_builtin,
3354					color,
3355					key,
3356					value,
3357					$elm$core$Dict$removeMin(left),
3358					right);
3359			} else {
3360				var _v4 = $elm$core$Dict$moveRedLeft(dict);
3361				if (_v4.$ === 'RBNode_elm_builtin') {
3362					var nColor = _v4.a;
3363					var nKey = _v4.b;
3364					var nValue = _v4.c;
3365					var nLeft = _v4.d;
3366					var nRight = _v4.e;
3367					return A5(
3368						$elm$core$Dict$balance,
3369						nColor,
3370						nKey,
3371						nValue,
3372						$elm$core$Dict$removeMin(nLeft),
3373						nRight);
3374				} else {
3375					return $elm$core$Dict$RBEmpty_elm_builtin;
3376				}
3377			}
3378		} else {
3379			return A5(
3380				$elm$core$Dict$RBNode_elm_builtin,
3381				color,
3382				key,
3383				value,
3384				$elm$core$Dict$removeMin(left),
3385				right);
3386		}
3387	} else {
3388		return $elm$core$Dict$RBEmpty_elm_builtin;
3389	}
3390};
3391var $elm$core$Dict$removeHelp = F2(
3392	function (targetKey, dict) {
3393		if (dict.$ === 'RBEmpty_elm_builtin') {
3394			return $elm$core$Dict$RBEmpty_elm_builtin;
3395		} else {
3396			var color = dict.a;
3397			var key = dict.b;
3398			var value = dict.c;
3399			var left = dict.d;
3400			var right = dict.e;
3401			if (_Utils_cmp(targetKey, key) < 0) {
3402				if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Black')) {
3403					var _v4 = left.a;
3404					var lLeft = left.d;
3405					if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) {
3406						var _v6 = lLeft.a;
3407						return A5(
3408							$elm$core$Dict$RBNode_elm_builtin,
3409							color,
3410							key,
3411							value,
3412							A2($elm$core$Dict$removeHelp, targetKey, left),
3413							right);
3414					} else {
3415						var _v7 = $elm$core$Dict$moveRedLeft(dict);
3416						if (_v7.$ === 'RBNode_elm_builtin') {
3417							var nColor = _v7.a;
3418							var nKey = _v7.b;
3419							var nValue = _v7.c;
3420							var nLeft = _v7.d;
3421							var nRight = _v7.e;
3422							return A5(
3423								$elm$core$Dict$balance,
3424								nColor,
3425								nKey,
3426								nValue,
3427								A2($elm$core$Dict$removeHelp, targetKey, nLeft),
3428								nRight);
3429						} else {
3430							return $elm$core$Dict$RBEmpty_elm_builtin;
3431						}
3432					}
3433				} else {
3434					return A5(
3435						$elm$core$Dict$RBNode_elm_builtin,
3436						color,
3437						key,
3438						value,
3439						A2($elm$core$Dict$removeHelp, targetKey, left),
3440						right);
3441				}
3442			} else {
3443				return A2(
3444					$elm$core$Dict$removeHelpEQGT,
3445					targetKey,
3446					A7($elm$core$Dict$removeHelpPrepEQGT, targetKey, dict, color, key, value, left, right));
3447			}
3448		}
3449	});
3450var $elm$core$Dict$removeHelpEQGT = F2(
3451	function (targetKey, dict) {
3452		if (dict.$ === 'RBNode_elm_builtin') {
3453			var color = dict.a;
3454			var key = dict.b;
3455			var value = dict.c;
3456			var left = dict.d;
3457			var right = dict.e;
3458			if (_Utils_eq(targetKey, key)) {
3459				var _v1 = $elm$core$Dict$getMin(right);
3460				if (_v1.$ === 'RBNode_elm_builtin') {
3461					var minKey = _v1.b;
3462					var minValue = _v1.c;
3463					return A5(
3464						$elm$core$Dict$balance,
3465						color,
3466						minKey,
3467						minValue,
3468						left,
3469						$elm$core$Dict$removeMin(right));
3470				} else {
3471					return $elm$core$Dict$RBEmpty_elm_builtin;
3472				}
3473			} else {
3474				return A5(
3475					$elm$core$Dict$balance,
3476					color,
3477					key,
3478					value,
3479					left,
3480					A2($elm$core$Dict$removeHelp, targetKey, right));
3481			}
3482		} else {
3483			return $elm$core$Dict$RBEmpty_elm_builtin;
3484		}
3485	});
3486var $elm$core$Dict$remove = F2(
3487	function (key, dict) {
3488		var _v0 = A2($elm$core$Dict$removeHelp, key, dict);
3489		if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) {
3490			var _v1 = _v0.a;
3491			var k = _v0.b;
3492			var v = _v0.c;
3493			var l = _v0.d;
3494			var r = _v0.e;
3495			return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r);
3496		} else {
3497			var x = _v0;
3498			return x;
3499		}
3500	});
3501var $elm$core$Dict$update = F3(
3502	function (targetKey, alter, dictionary) {
3503		var _v0 = alter(
3504			A2($elm$core$Dict$get, targetKey, dictionary));
3505		if (_v0.$ === 'Just') {
3506			var value = _v0.a;
3507			return A3($elm$core$Dict$insert, targetKey, value, dictionary);
3508		} else {
3509			return A2($elm$core$Dict$remove, targetKey, dictionary);
3510		}
3511	});
3512var $elm$core$Basics$composeR = F3(
3513	function (f, g, x) {
3514		return g(
3515			f(x));
3516	});
3517var $elm$http$Http$expectStringResponse = F2(
3518	function (toMsg, toResult) {
3519		return A3(
3520			_Http_expect,
3521			'',
3522			$elm$core$Basics$identity,
3523			A2($elm$core$Basics$composeR, toResult, toMsg));
3524	});
3525var $elm$http$Http$BadBody = function (a) {
3526	return {$: 'BadBody', a: a};
3527};
3528var $elm$http$Http$BadStatus = function (a) {
3529	return {$: 'BadStatus', a: a};
3530};
3531var $elm$http$Http$BadUrl = function (a) {
3532	return {$: 'BadUrl', a: a};
3533};
3534var $elm$http$Http$NetworkError = {$: 'NetworkError'};
3535var $elm$http$Http$Timeout = {$: 'Timeout'};
3536var $elm$core$Result$mapError = F2(
3537	function (f, result) {
3538		if (result.$ === 'Ok') {
3539			var v = result.a;
3540			return $elm$core$Result$Ok(v);
3541		} else {
3542			var e = result.a;
3543			return $elm$core$Result$Err(
3544				f(e));
3545		}
3546	});
3547var $elm$http$Http$resolve = F2(
3548	function (toResult, response) {
3549		switch (response.$) {
3550			case 'BadUrl_':
3551				var url = response.a;
3552				return $elm$core$Result$Err(
3553					$elm$http$Http$BadUrl(url));
3554			case 'Timeout_':
3555				return $elm$core$Result$Err($elm$http$Http$Timeout);
3556			case 'NetworkError_':
3557				return $elm$core$Result$Err($elm$http$Http$NetworkError);
3558			case 'BadStatus_':
3559				var metadata = response.a;
3560				return $elm$core$Result$Err(
3561					$elm$http$Http$BadStatus(metadata.statusCode));
3562			default:
3563				var body = response.b;
3564				return A2(
3565					$elm$core$Result$mapError,
3566					$elm$http$Http$BadBody,
3567					toResult(body));
3568		}
3569	});
3570var $elm$http$Http$expectString = function (toMsg) {
3571	return A2(
3572		$elm$http$Http$expectStringResponse,
3573		toMsg,
3574		$elm$http$Http$resolve($elm$core$Result$Ok));
3575};
3576var $elm$http$Http$emptyBody = _Http_emptyBody;
3577var $elm$http$Http$Request = function (a) {
3578	return {$: 'Request', a: a};
3579};
3580var $elm$http$Http$State = F2(
3581	function (reqs, subs) {
3582		return {reqs: reqs, subs: subs};
3583	});
3584var $elm$core$Task$succeed = _Scheduler_succeed;
3585var $elm$http$Http$init = $elm$core$Task$succeed(
3586	A2($elm$http$Http$State, $elm$core$Dict$empty, _List_Nil));
3587var $elm$core$Task$andThen = _Scheduler_andThen;
3588var $elm$core$Process$kill = _Scheduler_kill;
3589var $elm$core$Platform$sendToApp = _Platform_sendToApp;
3590var $elm$core$Process$spawn = _Scheduler_spawn;
3591var $elm$http$Http$updateReqs = F3(
3592	function (router, cmds, reqs) {
3593		updateReqs:
3594		while (true) {
3595			if (!cmds.b) {
3596				return $elm$core$Task$succeed(reqs);
3597			} else {
3598				var cmd = cmds.a;
3599				var otherCmds = cmds.b;
3600				if (cmd.$ === 'Cancel') {
3601					var tracker = cmd.a;
3602					var _v2 = A2($elm$core$Dict$get, tracker, reqs);
3603					if (_v2.$ === 'Nothing') {
3604						var $temp$router = router,
3605							$temp$cmds = otherCmds,
3606							$temp$reqs = reqs;
3607						router = $temp$router;
3608						cmds = $temp$cmds;
3609						reqs = $temp$reqs;
3610						continue updateReqs;
3611					} else {
3612						var pid = _v2.a;
3613						return A2(
3614							$elm$core$Task$andThen,
3615							function (_v3) {
3616								return A3(
3617									$elm$http$Http$updateReqs,
3618									router,
3619									otherCmds,
3620									A2($elm$core$Dict$remove, tracker, reqs));
3621							},
3622							$elm$core$Process$kill(pid));
3623					}
3624				} else {
3625					var req = cmd.a;
3626					return A2(
3627						$elm$core$Task$andThen,
3628						function (pid) {
3629							var _v4 = req.tracker;
3630							if (_v4.$ === 'Nothing') {
3631								return A3($elm$http$Http$updateReqs, router, otherCmds, reqs);
3632							} else {
3633								var tracker = _v4.a;
3634								return A3(
3635									$elm$http$Http$updateReqs,
3636									router,
3637									otherCmds,
3638									A3($elm$core$Dict$insert, tracker, pid, reqs));
3639							}
3640						},
3641						$elm$core$Process$spawn(
3642							A3(
3643								_Http_toTask,
3644								router,
3645								$elm$core$Platform$sendToApp(router),
3646								req)));
3647				}
3648			}
3649		}
3650	});
3651var $elm$http$Http$onEffects = F4(
3652	function (router, cmds, subs, state) {
3653		return A2(
3654			$elm$core$Task$andThen,
3655			function (reqs) {
3656				return $elm$core$Task$succeed(
3657					A2($elm$http$Http$State, reqs, subs));
3658			},
3659			A3($elm$http$Http$updateReqs, router, cmds, state.reqs));
3660	});
3661var $elm$core$List$foldrHelper = F4(
3662	function (fn, acc, ctr, ls) {
3663		if (!ls.b) {
3664			return acc;
3665		} else {
3666			var a = ls.a;
3667			var r1 = ls.b;
3668			if (!r1.b) {
3669				return A2(fn, a, acc);
3670			} else {
3671				var b = r1.a;
3672				var r2 = r1.b;
3673				if (!r2.b) {
3674					return A2(
3675						fn,
3676						a,
3677						A2(fn, b, acc));
3678				} else {
3679					var c = r2.a;
3680					var r3 = r2.b;
3681					if (!r3.b) {
3682						return A2(
3683							fn,
3684							a,
3685							A2(
3686								fn,
3687								b,
3688								A2(fn, c, acc)));
3689					} else {
3690						var d = r3.a;
3691						var r4 = r3.b;
3692						var res = (ctr > 500) ? A3(
3693							$elm$core$List$foldl,
3694							fn,
3695							acc,
3696							$elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
3697						return A2(
3698							fn,
3699							a,
3700							A2(
3701								fn,
3702								b,
3703								A2(
3704									fn,
3705									c,
3706									A2(fn, d, res))));
3707					}
3708				}
3709			}
3710		}
3711	});
3712var $elm$core$List$foldr = F3(
3713	function (fn, acc, ls) {
3714		return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
3715	});
3716var $elm$core$List$maybeCons = F3(
3717	function (f, mx, xs) {
3718		var _v0 = f(mx);
3719		if (_v0.$ === 'Just') {
3720			var x = _v0.a;
3721			return A2($elm$core$List$cons, x, xs);
3722		} else {
3723			return xs;
3724		}
3725	});
3726var $elm$core$List$filterMap = F2(
3727	function (f, xs) {
3728		return A3(
3729			$elm$core$List$foldr,
3730			$elm$core$List$maybeCons(f),
3731			_List_Nil,
3732			xs);
3733	});
3734var $elm$http$Http$maybeSend = F4(
3735	function (router, desiredTracker, progress, _v0) {
3736		var actualTracker = _v0.a;
3737		var toMsg = _v0.b;
3738		return _Utils_eq(desiredTracker, actualTracker) ? $elm$core$Maybe$Just(
3739			A2(
3740				$elm$core$Platform$sendToApp,
3741				router,
3742				toMsg(progress))) : $elm$core$Maybe$Nothing;
3743	});
3744var $elm$core$Task$map2 = F3(
3745	function (func, taskA, taskB) {
3746		return A2(
3747			$elm$core$Task$andThen,
3748			function (a) {
3749				return A2(
3750					$elm$core$Task$andThen,
3751					function (b) {
3752						return $elm$core$Task$succeed(
3753							A2(func, a, b));
3754					},
3755					taskB);
3756			},
3757			taskA);
3758	});
3759var $elm$core$Task$sequence = function (tasks) {
3760	return A3(
3761		$elm$core$List$foldr,
3762		$elm$core$Task$map2($elm$core$List$cons),
3763		$elm$core$Task$succeed(_List_Nil),
3764		tasks);
3765};
3766var $elm$http$Http$onSelfMsg = F3(
3767	function (router, _v0, state) {
3768		var tracker = _v0.a;
3769		var progress = _v0.b;
3770		return A2(
3771			$elm$core$Task$andThen,
3772			function (_v1) {
3773				return $elm$core$Task$succeed(state);
3774			},
3775			$elm$core$Task$sequence(
3776				A2(
3777					$elm$core$List$filterMap,
3778					A3($elm$http$Http$maybeSend, router, tracker, progress),
3779					state.subs)));
3780	});
3781var $elm$http$Http$Cancel = function (a) {
3782	return {$: 'Cancel', a: a};
3783};
3784var $elm$http$Http$cmdMap = F2(
3785	function (func, cmd) {
3786		if (cmd.$ === 'Cancel') {
3787			var tracker = cmd.a;
3788			return $elm$http$Http$Cancel(tracker);
3789		} else {
3790			var r = cmd.a;
3791			return $elm$http$Http$Request(
3792				{
3793					allowCookiesFromOtherDomains: r.allowCookiesFromOtherDomains,
3794					body: r.body,
3795					expect: A2(_Http_mapExpect, func, r.expect),
3796					headers: r.headers,
3797					method: r.method,
3798					timeout: r.timeout,
3799					tracker: r.tracker,
3800					url: r.url
3801				});
3802		}
3803	});
3804var $elm$http$Http$MySub = F2(
3805	function (a, b) {
3806		return {$: 'MySub', a: a, b: b};
3807	});
3808var $elm$http$Http$subMap = F2(
3809	function (func, _v0) {
3810		var tracker = _v0.a;
3811		var toMsg = _v0.b;
3812		return A2(
3813			$elm$http$Http$MySub,
3814			tracker,
3815			A2($elm$core$Basics$composeR, toMsg, func));
3816	});
3817_Platform_effectManagers['Http'] = _Platform_createManager($elm$http$Http$init, $elm$http$Http$onEffects, $elm$http$Http$onSelfMsg, $elm$http$Http$cmdMap, $elm$http$Http$subMap);
3818var $elm$http$Http$command = _Platform_leaf('Http');
3819var $elm$http$Http$subscription = _Platform_leaf('Http');
3820var $elm$http$Http$request = function (r) {
3821	return $elm$http$Http$command(
3822		$elm$http$Http$Request(
3823			{allowCookiesFromOtherDomains: false, body: r.body, expect: r.expect, headers: r.headers, method: r.method, timeout: r.timeout, tracker: r.tracker, url: r.url}));
3824};
3825var $elm$http$Http$get = function (r) {
3826	return $elm$http$Http$request(
3827		{body: $elm$http$Http$emptyBody, expect: r.expect, headers: _List_Nil, method: 'GET', timeout: $elm$core$Maybe$Nothing, tracker: $elm$core$Maybe$Nothing, url: r.url});
3828};
3829var $author$project$Main$init = function (_v0) {
3830	return _Utils_Tuple2(
3831		_Utils_Tuple0,
3832		$elm$http$Http$get(
3833			{
3834				expect: $elm$http$Http$expectString($author$project$Main$GotIp),
3835				url: 'https://api.ipify.org'
3836			}));
3837};
3838var $elm$core$Platform$Sub$batch = _Platform_batch;
3839var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
3840var $author$project$Main$subscriptions = function (_v0) {
3841	return $elm$core$Platform$Sub$none;
3842};
3843var $elm$json$Json$Decode$succeed = _Json_succeed;
3844var $elm$core$Debug$log = _Debug_log;
3845var $elm$core$Platform$Cmd$batch = _Platform_batch;
3846var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
3847var $elm$core$Debug$toString = _Debug_toString;
3848var $author$project$Main$update = F2(
3849	function (msg, _v0) {
3850		var result = msg.a;
3851		if (result.$ === 'Ok') {
3852			var text = result.a;
3853			return _Utils_Tuple2(
3854				A2($elm$core$Debug$log, text, _Utils_Tuple0),
3855				$elm$core$Platform$Cmd$none);
3856		} else {
3857			var error = result.a;
3858			return _Utils_Tuple2(
3859				A2(
3860					$elm$core$Debug$log,
3861					$elm$core$Debug$toString(error),
3862					_Utils_Tuple0),
3863				$elm$core$Platform$Cmd$none);
3864		}
3865	});
3866var $elm$core$Platform$worker = _Platform_worker;
3867var $author$project$Main$main = $elm$core$Platform$worker(
3868	{init: $author$project$Main$init, subscriptions: $author$project$Main$subscriptions, update: $author$project$Main$update});
3869_Platform_export({'Main':{'init':$author$project$Main$main(
3870	$elm$json$Json$Decode$succeed(_Utils_Tuple0))(0)}});}(this));