https://www.sptl.fi/sptl_uudet/wp-content/plugins/sptl-plugin/js/main_cup_1.0.3.js?1.8.2.01.06

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
83// EQUALITY
84
85function _Utils_eq(x, y)
86{
87	for (
88		var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
89		isEqual && (pair = stack.pop());
90		isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
91		)
92	{}
93
94	return isEqual;
95}
96
97function _Utils_eqHelp(x, y, depth, stack)
98{
99	if (x === y)
100	{
101		return true;
102	}
103
104	if (typeof x !== 'object' || x === null || y === null)
105	{
106		typeof x === 'function' && _Debug_crash(5);
107		return false;
108	}
109
110	if (depth > 100)
111	{
112		stack.push(_Utils_Tuple2(x,y));
113		return true;
114	}
115
116	/**/
117	if (x.$ === 'Set_elm_builtin')
118	{
119		x = $elm$core$Set$toList(x);
120		y = $elm$core$Set$toList(y);
121	}
122	if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
123	{
124		x = $elm$core$Dict$toList(x);
125		y = $elm$core$Dict$toList(y);
126	}
127	//*/
128
129	/**_UNUSED/
130	if (x.$ < 0)
131	{
132		x = $elm$core$Dict$toList(x);
133		y = $elm$core$Dict$toList(y);
134	}
135	//*/
136
137	for (var key in x)
138	{
139		if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
140		{
141			return false;
142		}
143	}
144	return true;
145}
146
147var _Utils_equal = F2(_Utils_eq);
148var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
149
150
151
152// COMPARISONS
153
154// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
155// the particular integer values assigned to LT, EQ, and GT.
156
157function _Utils_cmp(x, y, ord)
158{
159	if (typeof x !== 'object')
160	{
161		return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
162	}
163
164	/**/
165	if (x instanceof String)
166	{
167		var a = x.valueOf();
168		var b = y.valueOf();
169		return a === b ? 0 : a < b ? -1 : 1;
170	}
171	//*/
172
173	/**_UNUSED/
174	if (typeof x.$ === 'undefined')
175	//*/
176	/**/
177	if (x.$[0] === '#')
178	//*/
179	{
180		return (ord = _Utils_cmp(x.a, y.a))
181			? ord
182			: (ord = _Utils_cmp(x.b, y.b))
183				? ord
184				: _Utils_cmp(x.c, y.c);
185	}
186
187	// traverse conses until end of a list or a mismatch
188	for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
189	return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
190}
191
192var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
193var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
194var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
195var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
196
197var _Utils_compare = F2(function(x, y)
198{
199	var n = _Utils_cmp(x, y);
200	return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
201});
202
203
204// COMMON VALUES
205

206var _Utils_Tuple0_UNUSED = 0;
207var _Utils_Tuple0 = { $: '#0' };
208
209function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }
210function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }
211
212function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }
213function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
214
215function _Utils_chr_UNUSED(c) { return c; }
216function _Utils_chr(c) { return new String(c); }
217
218
219// RECORDS
220
221function _Utils_update(oldRecord, updatedFields)
222{
223	var newRecord = {};
224
225	for (var key in oldRecord)
226	{
227		newRecord[key] = oldRecord[key];
228	}
229
230	for (var key in updatedFields)
231	{
232		newRecord[key] = updatedFields[key];
233	}
234
235	return newRecord;
236}
237
238
239// APPEND
240
241var _Utils_append = F2(_Utils_ap);
242
243function _Utils_ap(xs, ys)
244{
245	// append Strings
246	if (typeof xs === 'string')
247	{
248		return xs + ys;
249	}
250
251	// append Lists
252	if (!xs.b)
253	{
254		return ys;
255	}
256	var root = _List_Cons(xs.a, ys);
257	xs = xs.b
258	for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
259	{
260		curr = curr.b = _List_Cons(xs.a, ys);
261	}
262	return root;
263}
264
265
266
267var _List_Nil_UNUSED = { $: 0 };
268var _List_Nil = { $: '[]' };
269
270function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }
271function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }
272
273
274var _List_cons = F2(_List_Cons);
275
276function _List_fromArray(arr)
277{
278	var out = _List_Nil;
279	for (var i = arr.length; i--; )
280	{
281		out = _List_Cons(arr[i], out);
282	}
283	return out;
284}
285
286function _List_toArray(xs)
287{
288	for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
289	{
290		out.push(xs.a);
291	}
292	return out;
293}
294
295var _List_map2 = F3(function(f, xs, ys)
296{
297	for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
298	{
299		arr.push(A2(f, xs.a, ys.a));
300	}
301	return _List_fromArray(arr);
302});
303
304var _List_map3 = F4(function(f, xs, ys, zs)
305{
306	for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
307	{
308		arr.push(A3(f, xs.a, ys.a, zs.a));
309	}
310	return _List_fromArray(arr);
311});
312
313var _List_map4 = F5(function(f, ws, xs, ys, zs)
314{
315	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
316	{
317		arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
318	}
319	return _List_fromArray(arr);
320});
321
322var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
323{
324	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
325	{
326		arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
327	}
328	return _List_fromArray(arr);
329});
330
331var _List_sortBy = F2(function(f, xs)
332{
333	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
334		return _Utils_cmp(f(a), f(b));
335	}));
336});
337
338var _List_sortWith = F2(function(f, xs)
339{
340	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
341		var ord = A2(f, a, b);
342		return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
343	}));
344});
345
346
347
348var _JsArray_empty = [];
349
350function _JsArray_singleton(value)
351{
352    return [value];
353}
354
355function _JsArray_length(array)
356{
357    return array.length;
358}
359
360var _JsArray_initialize = F3(function(size, offset, func)
361{
362    var result = new Array(size);
363
364    for (var i = 0; i < size; i++)
365    {
366        result[i] = func(offset + i);
367    }
368
369    return result;
370});
371
372var _JsArray_initializeFromList = F2(function (max, ls)
373{
374    var result = new Array(max);
375
376    for (var i = 0; i < max && ls.b; i++)
377    {
378        result[i] = ls.a;
379        ls = ls.b;
380    }
381
382    result.length = i;
383    return _Utils_Tuple2(result, ls);
384});
385
386var _JsArray_unsafeGet = F2(function(index, array)
387{
388    return array[index];
389});
390
391var _JsArray_unsafeSet = F3(function(index, value, array)
392{
393    var length = array.length;
394    var result = new Array(length);
395
396    for (var i = 0; i < length; i++)
397    {
398        result[i] = array[i];
399    }
400
401    result[index] = value;
402    return result;
403});
404
405var _JsArray_push = F2(function(value, array)
406{
407    var length = array.length;
408    var result = new Array(length + 1);
409
410    for (var i = 0; i < length; i++)
411    {
412        result[i] = array[i];
413    }
414
415    result[length] = value;
416    return result;
417});
418
419var _JsArray_foldl = F3(function(func, acc, array)
420{
421    var length = array.length;
422
423    for (var i = 0; i < length; i++)
424    {
425        acc = A2(func, array[i], acc);
426    }
427
428    return acc;
429});
430
431var _JsArray_foldr = F3(function(func, acc, array)
432{
433    for (var i = array.length - 1; i >= 0; i--)
434    {
435        acc = A2(func, array[i], acc);
436    }
437
438    return acc;
439});
440
441var _JsArray_map = F2(function(func, array)
442{
443    var length = array.length;
444    var result = new Array(length);
445
446    for (var i = 0; i < length; i++)
447    {
448        result[i] = func(array[i]);
449    }
450
451    return result;
452});
453
454var _JsArray_indexedMap = F3(function(func, offset, array)
455{
456    var length = array.length;
457    var result = new Array(length);
458
459    for (var i = 0; i < length; i++)
460    {
461        result[i] = A2(func, offset + i, array[i]);
462    }
463
464    return result;
465});
466
467var _JsArray_slice = F3(function(from, to, array)
468{
469    return array.slice(from, to);
470});
471
472var _JsArray_appendN = F3(function(n, dest, source)
473{
474    var destLen = dest.length;
475    var itemsToCopy = n - destLen;
476
477    if (itemsToCopy > source.length)
478    {
479        itemsToCopy = source.length;
480    }
481
482    var size = destLen + itemsToCopy;
483    var result = new Array(size);
484
485    for (var i = 0; i < destLen; i++)
486    {
487        result[i] = dest[i];
488    }
489
490    for (var i = 0; i < itemsToCopy; i++)
491    {
492        result[i + destLen] = source[i];
493    }
494
495    return result;
496});
497
498
499
500// LOG
501
502var _Debug_log_UNUSED = F2(function(tag, value)
503{
504	return value;
505});
506
507var _Debug_log = F2(function(tag, value)
508{
509	console.log(tag + ': ' + _Debug_toString(value));
510	return value;
511});
512
513
514// TODOS
515
516function _Debug_todo(moduleName, region)
517{
518	return function(message) {
519		_Debug_crash(8, moduleName, region, message);
520	};
521}
522
523function _Debug_todoCase(moduleName, region, value)
524{
525	return function(message) {
526		_Debug_crash(9, moduleName, region, value, message);
527	};
528}
529
530
531// TO STRING
532
533function _Debug_toString_UNUSED(value)
534{
535	return '<internals>';
536}
537
538function _Debug_toString(value)
539{
540	return _Debug_toAnsiString(false, value);
541}
542
543function _Debug_toAnsiString(ansi, value)
544{
545	if (typeof value === 'function')
546	{
547		return _Debug_internalColor(ansi, '<function>');
548	}
549
550	if (typeof value === 'boolean')
551	{
552		return _Debug_ctorColor(ansi, value ? 'True' : 'False');
553	}
554
555	if (typeof value === 'number')
556	{
557		return _Debug_numberColor(ansi, value + '');
558	}
559
560	if (value instanceof String)
561	{
562		return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
563	}
564
565	if (typeof value === 'string')
566	{
567		return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
568	}
569
570	if (typeof value === 'object' && '$' in value)
571	{
572		var tag = value.$;
573
574		if (typeof tag === 'number')
575		{
576			return _Debug_internalColor(ansi, '<internals>');
577		}
578
579		if (tag[0] === '#')
580		{
581			var output = [];
582			for (var k in value)
583			{
584				if (k === '$') continue;
585				output.push(_Debug_toAnsiString(ansi, value[k]));
586			}
587			return '(' + output.join(',') + ')';
588		}
589
590		if (tag === 'Set_elm_builtin')
591		{
592			return _Debug_ctorColor(ansi, 'Set')
593				+ _Debug_fadeColor(ansi, '.fromList') + ' '
594				+ _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
595		}
596
597		if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
598		{
599			return _Debug_ctorColor(ansi, 'Dict')
600				+ _Debug_fadeColor(ansi, '.fromList') + ' '
601				+ _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
602		}
603
604		if (tag === 'Array_elm_builtin')
605		{
606			return _Debug_ctorColor(ansi, 'Array')
607				+ _Debug_fadeColor(ansi, '.fromList') + ' '
608				+ _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
609		}
610
611		if (tag === '::' || tag === '[]')
612		{
613			var output = '[';
614
615			value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
616
617			for (; value.b; value = value.b) // WHILE_CONS
618			{
619				output += ',' + _Debug_toAnsiString(ansi, value.a);
620			}
621			return output + ']';
622		}
623
624		var output = '';
625		for (var i in value)
626		{
627			if (i === '$') continue;
628			var str = _Debug_toAnsiString(ansi, value[i]);
629			var c0 = str[0];
630			var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
631			output += ' ' + (parenless ? str : '(' + str + ')');
632		}
633		return _Debug_ctorColor(ansi, tag) + output;
634	}
635
636	if (typeof DataView === 'function' && value instanceof DataView)
637	{
638		return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
639	}
640
641	if (typeof File !== 'undefined' && value instanceof File)
642	{
643		return _Debug_internalColor(ansi, '<' + value.name + '>');
644	}
645
646	if (typeof value === 'object')
647	{
648		var output = [];
649		for (var key in value)
650		{
651			var field = key[0] === '_' ? key.slice(1) : key;
652			output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
653		}
654		if (output.length === 0)
655		{
656			return '{}';
657		}
658		return '{ ' + output.join(', ') + ' }';
659	}
660
661	return _Debug_internalColor(ansi, '<internals>');
662}
663
664function _Debug_addSlashes(str, isChar)
665{
666	var s = str
667		.replace(/\\/g, '\\\\')
668		.replace(/\n/g, '\\n')
669		.replace(/\t/g, '\\t')
670		.replace(/\r/g, '\\r')
671		.replace(/\v/g, '\\v')
672		.replace(/\0/g, '\\0');
673
674	if (isChar)
675	{
676		return s.replace(/\'/g, '\\\'');
677	}
678	else
679	{
680		return s.replace(/\"/g, '\\"');
681	}
682}
683
684function _Debug_ctorColor(ansi, string)
685{
686	return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
687}
688
689function _Debug_numberColor(ansi, string)
690{
691	return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
692}
693
694function _Debug_stringColor(ansi, string)
695{
696	return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
697}
698
699function _Debug_charColor(ansi, string)
700{
701	return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
702}
703
704function _Debug_fadeColor(ansi, string)
705{
706	return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
707}
708
709function _Debug_internalColor(ansi, string)
710{
711	return ansi ? '\x1b[36m' + string + '\x1b[0m' : string;
712}
713
714function _Debug_toHexDigit(n)
715{
716	return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
717}
718
719
720// CRASH
721
722
723function _Debug_crash_UNUSED(identifier)
724{
725	throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
726}
727
728
729function _Debug_crash(identifier, fact1, fact2, fact3, fact4)
730{
731	switch(identifier)
732	{
733		case 0:
734			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.');
735
736		case 1:
737			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.');
738
739		case 2:
740			var jsonErrorString = fact1;
741			throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
742
743		case 3:
744			var portName = fact1;
745			throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
746
747		case 4:
748			var portName = fact1;
749			var problem = fact2;
750			throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
751
752		case 5:
753			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.');
754
755		case 6:
756			var moduleName = fact1;
757			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!');
758
759		case 8:
760			var moduleName = fact1;
761			var region = fact2;
762			var message = fact3;
763			throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
764
765		case 9:
766			var moduleName = fact1;
767			var region = fact2;
768			var value = fact3;
769			var message = fact4;
770			throw new Error(
771				'TODO in module `' + moduleName + '` from the `case` expression '
772				+ _Debug_regionToString(region) + '\n\nIt received the following value:\n\n    '
773				+ _Debug_toString(value).replace('\n', '\n    ')
774				+ '\n\nBut the branch that handles it says:\n\n    ' + message.replace('\n', '\n    ')
775			);
776
777		case 10:
778			throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
779
780		case 11:
781			throw new Error('Cannot perform mod 0. Division by zero error.');
782	}
783}
784
785function _Debug_regionToString(region)
786{
787	if (region.start.line === region.end.line)
788	{
789		return 'on line ' + region.start.line;
790	}
791	return 'on lines ' + region.start.line + ' through ' + region.end.line;
792}
793
794
795
796// MATH
797
798var _Basics_add = F2(function(a, b) { return a + b; });
799var _Basics_sub = F2(function(a, b) { return a - b; });
800var _Basics_mul = F2(function(a, b) { return a * b; });
801var _Basics_fdiv = F2(function(a, b) { return a / b; });
802var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
803var _Basics_pow = F2(Math.pow);
804
805var _Basics_remainderBy = F2(function(b, a) { return a % b; });
806

807// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
808var _Basics_modBy = F2(function(modulus, x)
809{
810	var answer = x % modulus;
811	return modulus === 0
812		? _Debug_crash(11)
813		:
814	((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
815		? answer + modulus
816		: answer;
817});
818
819
820// TRIGONOMETRY
821
822var _Basics_pi = Math.PI;
823var _Basics_e = Math.E;
824var _Basics_cos = Math.cos;
825var _Basics_sin = Math.sin;
826var _Basics_tan = Math.tan;
827var _Basics_acos = Math.acos;
828var _Basics_asin = Math.asin;
829var _Basics_atan = Math.atan;
830var _Basics_atan2 = F2(Math.atan2);
831
832
833// MORE MATH
834
835function _Basics_toFloat(x) { return x; }
836function _Basics_truncate(n) { return n | 0; }
837function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
838
839var _Basics_ceiling = Math.ceil;
840var _Basics_floor = Math.floor;
841var _Basics_round = Math.round;
842var _Basics_sqrt = Math.sqrt;
843var _Basics_log = Math.log;
844var _Basics_isNaN = isNaN;
845
846
847// BOOLEANS
848
849function _Basics_not(bool) { return !bool; }
850var _Basics_and = F2(function(a, b) { return a && b; });
851var _Basics_or  = F2(function(a, b) { return a || b; });
852var _Basics_xor = F2(function(a, b) { return a !== b; });
853
854
855
856var _String_cons = F2(function(chr, str)
857{
858	return chr + str;
859});
860
861function _String_uncons(string)
862{
863	var word = string.charCodeAt(0);
864	return !isNaN(word)
865		? $elm$core$Maybe$Just(
866			0xD800 <= word && word <= 0xDBFF
867				? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
868				: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
869		)
870		: $elm$core$Maybe$Nothing;
871}
872
873var _String_append = F2(function(a, b)
874{
875	return a + b;
876});
877
878function _String_length(str)
879{
880	return str.length;
881}
882
883var _String_map = F2(function(func, string)
884{
885	var len = string.length;
886	var array = new Array(len);
887	var i = 0;
888	while (i < len)
889	{
890		var word = string.charCodeAt(i);
891		if (0xD800 <= word && word <= 0xDBFF)
892		{
893			array[i] = func(_Utils_chr(string[i] + string[i+1]));
894			i += 2;
895			continue;
896		}
897		array[i] = func(_Utils_chr(string[i]));
898		i++;
899	}
900	return array.join('');
901});
902
903var _String_filter = F2(function(isGood, str)
904{
905	var arr = [];
906	var len = str.length;
907	var i = 0;
908	while (i < len)
909	{
910		var char = str[i];
911		var word = str.charCodeAt(i);
912		i++;
913		if (0xD800 <= word && word <= 0xDBFF)
914		{
915			char += str[i];
916			i++;
917		}
918
919		if (isGood(_Utils_chr(char)))
920		{
921			arr.push(char);
922		}
923	}
924	return arr.join('');
925});
926
927function _String_reverse(str)
928{
929	var len = str.length;
930	var arr = new Array(len);
931	var i = 0;
932	while (i < len)
933	{
934		var word = str.charCodeAt(i);
935		if (0xD800 <= word && word <= 0xDBFF)
936		{
937			arr[len - i] = str[i + 1];
938			i++;
939			arr[len - i] = str[i - 1];
940			i++;
941		}
942		else
943		{
944			arr[len - i] = str[i];
945			i++;
946		}
947	}
948	return arr.join('');
949}
950
951var _String_foldl = F3(function(func, state, string)
952{
953	var len = string.length;
954	var i = 0;
955	while (i < len)
956	{
957		var char = string[i];
958		var word = string.charCodeAt(i);
959		i++;
960		if (0xD800 <= word && word <= 0xDBFF)
961		{
962			char += string[i];
963			i++;
964		}
965		state = A2(func, _Utils_chr(char), state);
966	}
967	return state;
968});
969
970var _String_foldr = F3(function(func, state, string)
971{
972	var i = string.length;
973	while (i--)
974	{
975		var char = string[i];
976		var word = string.charCodeAt(i);
977		if (0xDC00 <= word && word <= 0xDFFF)
978		{
979			i--;
980			char = string[i] + char;
981		}
982		state = A2(func, _Utils_chr(char), state);
983	}
984	return state;
985});
986
987var _String_split = F2(function(sep, str)
988{
989	return str.split(sep);
990});
991
992var _String_join = F2(function(sep, strs)
993{
994	return strs.join(sep);
995});
996
997var _String_slice = F3(function(start, end, str) {
998	return str.slice(start, end);
999});
1000
1001function _String_trim(str)
1002{
1003	return str.trim();
1004}
1005
1006function _String_trimLeft(str)
1007{
1008	return str.replace(/^\s+/, '');
1009}
1010
1011function _String_trimRight(str)
1012{
1013	return str.replace(/\s+$/, '');
1014}
1015
1016function _String_words(str)
1017{
1018	return _List_fromArray(str.trim().split(/\s+/g));
1019}
1020
1021function _String_lines(str)
1022{
1023	return _List_fromArray(str.split(/\r\n|\r|\n/g));
1024}
1025
1026function _String_toUpper(str)
1027{
1028	return str.toUpperCase();
1029}
1030
1031function _String_toLower(str)
1032{
1033	return str.toLowerCase();
1034}
1035
1036var _String_any = F2(function(isGood, string)
1037{
1038	var i = string.length;
1039	while (i--)
1040	{
1041		var char = string[i];
1042		var word = string.charCodeAt(i);

1043		if (0xDC00 <= word && word <= 0xDFFF)
1044		{
1045			i--;
1046			char = string[i] + char;
1047		}
1048		if (isGood(_Utils_chr(char)))
1049		{
1050			return true;
1051		}
1052	}
1053	return false;
1054});
1055
1056var _String_all = F2(function(isGood, string)
1057{
1058	var i = string.length;
1059	while (i--)
1060	{
1061		var char = string[i];
1062		var word = string.charCodeAt(i);
1063		if (0xDC00 <= word && word <= 0xDFFF)
1064		{
1065			i--;
1066			char = string[i] + char;
1067		}
1068		if (!isGood(_Utils_chr(char)))
1069		{
1070			return false;
1071		}
1072	}
1073	return true;
1074});
1075
1076var _String_contains = F2(function(sub, str)
1077{
1078	return str.indexOf(sub) > -1;
1079});
1080
1081var _String_startsWith = F2(function(sub, str)
1082{
1083	return str.indexOf(sub) === 0;
1084});
1085
1086var _String_endsWith = F2(function(sub, str)
1087{
1088	return str.length >= sub.length &&
1089		str.lastIndexOf(sub) === str.length - sub.length;
1090});
1091
1092var _String_indexes = F2(function(sub, str)
1093{
1094	var subLen = sub.length;
1095
1096	if (subLen < 1)
1097	{
1098		return _List_Nil;
1099	}
1100
1101	var i = 0;
1102	var is = [];
1103
1104	while ((i = str.indexOf(sub, i)) > -1)
1105	{
1106		is.push(i);
1107		i = i + subLen;
1108	}
1109
1110	return _List_fromArray(is);
1111});
1112
1113
1114// TO STRING
1115
1116function _String_fromNumber(number)
1117{
1118	return number + '';
1119}
1120
1121
1122// INT CONVERSIONS
1123
1124function _String_toInt(str)
1125{
1126	var total = 0;
1127	var code0 = str.charCodeAt(0);
1128	var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1129
1130	for (var i = start; i < str.length; ++i)
1131	{
1132		var code = str.charCodeAt(i);
1133		if (code < 0x30 || 0x39 < code)
1134		{
1135			return $elm$core$Maybe$Nothing;
1136		}
1137		total = 10 * total + code - 0x30;
1138	}
1139
1140	return i == start
1141		? $elm$core$Maybe$Nothing
1142		: $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1143}
1144
1145
1146// FLOAT CONVERSIONS
1147
1148function _String_toFloat(s)
1149{
1150	// check if it is a hex, octal, or binary number
1151	if (s.length === 0 || /[\sxbo]/.test(s))
1152	{
1153		return $elm$core$Maybe$Nothing;
1154	}
1155	var n = +s;
1156	// faster isNaN check
1157	return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1158}
1159
1160function _String_fromList(chars)
1161{
1162	return _List_toArray(chars).join('');
1163}
1164
1165
1166
1167
1168function _Char_toCode(char)
1169{
1170	var code = char.charCodeAt(0);
1171	if (0xD800 <= code && code <= 0xDBFF)
1172	{
1173		return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1174	}
1175	return code;
1176}
1177
1178function _Char_fromCode(code)
1179{
1180	return _Utils_chr(
1181		(code < 0 || 0x10FFFF < code)
1182			? '\uFFFD'
1183			:
1184		(code <= 0xFFFF)
1185			? String.fromCharCode(code)
1186			:
1187		(code -= 0x10000,
1188			String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1189		)
1190	);
1191}
1192
1193function _Char_toUpper(char)
1194{
1195	return _Utils_chr(char.toUpperCase());
1196}
1197
1198function _Char_toLower(char)
1199{
1200	return _Utils_chr(char.toLowerCase());
1201}
1202
1203function _Char_toLocaleUpper(char)
1204{
1205	return _Utils_chr(char.toLocaleUpperCase());
1206}
1207
1208function _Char_toLocaleLower(char)
1209{
1210	return _Utils_chr(char.toLocaleLowerCase());
1211}
1212
1213
1214
1215/**/
1216function _Json_errorToString(error)
1217{
1218	return $elm$json$Json$Decode$errorToString(error);
1219}
1220//*/
1221
1222
1223// CORE DECODERS
1224
1225function _Json_succeed(msg)
1226{
1227	return {
1228		$: 0,
1229		a: msg
1230	};
1231}
1232
1233function _Json_fail(msg)
1234{
1235	return {
1236		$: 1,
1237		a: msg
1238	};
1239}
1240
1241function _Json_decodePrim(decoder)
1242{
1243	return { $: 2, b: decoder };
1244}
1245
1246var _Json_decodeInt = _Json_decodePrim(function(value) {
1247	return (typeof value !== 'number')
1248		? _Json_expecting('an INT', value)
1249		:
1250	(-2147483647 < value && value < 2147483647 && (value | 0) === value)
1251		? $elm$core$Result$Ok(value)
1252		:
1253	(isFinite(value) && !(value % 1))
1254		? $elm$core$Result$Ok(value)
1255		: _Json_expecting('an INT', value);
1256});
1257
1258var _Json_decodeBool = _Json_decodePrim(function(value) {
1259	return (typeof value === 'boolean')
1260		? $elm$core$Result$Ok(value)
1261		: _Json_expecting('a BOOL', value);
1262});
1263
1264var _Json_decodeFloat = _Json_decodePrim(function(value) {
1265	return (typeof value === 'number')
1266		? $elm$core$Result$Ok(value)
1267		: _Json_expecting('a FLOAT', value);
1268});
1269
1270var _Json_decodeValue = _Json_decodePrim(function(value) {
1271	return $elm$core$Result$Ok(_Json_wrap(value));
1272});
1273
1274var _Json_decodeString = _Json_decodePrim(function(value) {
1275	return (typeof value === 'string')
1276		? $elm$core$Result$Ok(value)
1277		: (value instanceof String)
1278			? $elm$core$Result$Ok(value + '')
1279			: _Json_expecting('a STRING', value);
1280});
1281
1282function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1283function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1284
1285function _Json_decodeNull(value) { return { $: 5, c: value }; }
1286
1287var _Json_decodeField = F2(function(field, decoder)
1288{
1289	return {
1290		$: 6,
1291		d: field,
1292		b: decoder
1293	};
1294});
1295
1296var _Json_decodeIndex = F2(function(index, decoder)
1297{
1298	return {
1299		$: 7,
1300		e: index,
1301		b: decoder
1302	};
1303});
1304
1305function _Json_decodeKeyValuePairs(decoder)
1306{
1307	return {
1308		$: 8,
1309		b: decoder
1310	};
1311}
1312
1313function _Json_mapMany(f, decoders)
1314{
1315	return {
1316		$: 9,
1317		f: f,
1318		g: decoders
1319	};
1320}
1321
1322var _Json_andThen = F2(function(callback, decoder)
1323{
1324	return {
1325		$: 10,
1326		b: decoder,
1327		h: callback
1328	};
1329});
1330
1331function _Json_oneOf(decoders)
1332{
1333	return {
1334		$: 11,
1335		g: decoders
1336	};
1337}
1338
1339
1340// DECODING OBJECTS
1341
1342var _Json_map1 = F2(function(f, d1)
1343{
1344	return _Json_mapMany(f, [d1]);
1345});
1346
1347var _Json_map2 = F3(function(f, d1, d2)
1348{
1349	return _Json_mapMany(f, [d1, d2]);
1350});
1351
1352var _Json_map3 = F4(function(f, d1, d2, d3)
1353{
1354	return _Json_mapMany(f, [d1, d2, d3]);
1355});
1356
1357var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1358{
1359	return _Json_mapMany(f, [d1, d2, d3, d4]);
1360});
1361
1362var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1363{
1364	return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1365});
1366
1367var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1368{
1369	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1370});
1371
1372var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1373{
1374	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1375});
1376
1377var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1378{
1379	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1380});
1381
1382
1383// DECODE
1384
1385var _Json_runOnString = F2(function(decoder, string)
1386{
1387	try
1388	{
1389		var value = JSON.parse(string);
1390		return _Json_runHelp(decoder, value);
1391	}
1392	catch (e)
1393	{
1394		return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not val

1394id JSON! ' + e.message, _Json_wrap(string)));
1395	}
1396});
1397
1398var _Json_run = F2(function(decoder, value)
1399{
1400	return _Json_runHelp(decoder, _Json_unwrap(value));
1401});
1402
1403function _Json_runHelp(decoder, value)
1404{
1405	switch (decoder.$)
1406	{
1407		case 2:
1408			return decoder.b(value);
1409
1410		case 5:
1411			return (value === null)
1412				? $elm$core$Result$Ok(decoder.c)
1413				: _Json_expecting('null', value);
1414
1415		case 3:
1416			if (!_Json_isArray(value))
1417			{
1418				return _Json_expecting('a LIST', value);
1419			}
1420			return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1421
1422		case 4:
1423			if (!_Json_isArray(value))
1424			{
1425				return _Json_expecting('an ARRAY', value);
1426			}
1427			return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1428
1429		case 6:
1430			var field = decoder.d;
1431			if (typeof value !== 'object' || value === null || !(field in value))
1432			{
1433				return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1434			}
1435			var result = _Json_runHelp(decoder.b, value[field]);
1436			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1437
1438		case 7:
1439			var index = decoder.e;
1440			if (!_Json_isArray(value))
1441			{
1442				return _Json_expecting('an ARRAY', value);
1443			}
1444			if (index >= value.length)
1445			{
1446				return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1447			}
1448			var result = _Json_runHelp(decoder.b, value[index]);
1449			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1450
1451		case 8:
1452			if (typeof value !== 'object' || value === null || _Json_isArray(value))
1453			{
1454				return _Json_expecting('an OBJECT', value);
1455			}
1456
1457			var keyValuePairs = _List_Nil;
1458			// TODO test perf of Object.keys and switch when support is good enough
1459			for (var key in value)
1460			{
1461				if (value.hasOwnProperty(key))
1462				{
1463					var result = _Json_runHelp(decoder.b, value[key]);
1464					if (!$elm$core$Result$isOk(result))
1465					{
1466						return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1467					}
1468					keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1469				}
1470			}
1471			return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1472
1473		case 9:
1474			var answer = decoder.f;
1475			var decoders = decoder.g;
1476			for (var i = 0; i < decoders.length; i++)
1477			{
1478				var result = _Json_runHelp(decoders[i], value);
1479				if (!$elm$core$Result$isOk(result))
1480				{
1481					return result;
1482				}
1483				answer = answer(result.a);
1484			}
1485			return $elm$core$Result$Ok(answer);
1486
1487		case 10:
1488			var result = _Json_runHelp(decoder.b, value);
1489			return (!$elm$core$Result$isOk(result))
1490				? result
1491				: _Json_runHelp(decoder.h(result.a), value);
1492
1493		case 11:
1494			var errors = _List_Nil;
1495			for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1496			{
1497				var result = _Json_runHelp(temp.a, value);
1498				if ($elm$core$Result$isOk(result))
1499				{
1500					return result;
1501				}
1502				errors = _List_Cons(result.a, errors);
1503			}
1504			return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1505
1506		case 1:
1507			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1508
1509		case 0:
1510			return $elm$core$Result$Ok(decoder.a);
1511	}
1512}
1513
1514function _Json_runArrayDecoder(decoder, value, toElmValue)
1515{
1516	var len = value.length;
1517	var array = new Array(len);
1518	for (var i = 0; i < len; i++)
1519	{
1520		var result = _Json_runHelp(decoder, value[i]);
1521		if (!$elm$core$Result$isOk(result))
1522		{
1523			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1524		}
1525		array[i] = result.a;
1526	}
1527	return $elm$core$Result$Ok(toElmValue(array));
1528}
1529
1530function _Json_isArray(value)
1531{
1532	return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1533}
1534
1535function _Json_toElmArray(array)
1536{
1537	return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1538}
1539
1540function _Json_expecting(type, value)
1541{
1542	return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1543}
1544
1545
1546// EQUALITY
1547
1548function _Json_equality(x, y)
1549{
1550	if (x === y)
1551	{
1552		return true;
1553	}
1554
1555	if (x.$ !== y.$)
1556	{
1557		return false;

1558	}
1559
1560	switch (x.$)
1561	{
1562		case 0:
1563		case 1:
1564			return x.a === y.a;
1565
1566		case 2:
1567			return x.b === y.b;
1568
1569		case 5:
1570			return x.c === y.c;
1571
1572		case 3:
1573		case 4:
1574		case 8:
1575			return _Json_equality(x.b, y.b);
1576
1577		case 6:
1578			return x.d === y.d && _Json_equality(x.b, y.b);
1579
1580		case 7:
1581			return x.e === y.e && _Json_equality(x.b, y.b);
1582
1583		case 9:
1584			return x.f === y.f && _Json_listEquality(x.g, y.g);
1585
1586		case 10:
1587			return x.h === y.h && _Json_equality(x.b, y.b);
1588
1589		case 11:
1590			return _Json_listEquality(x.g, y.g);
1591	}
1592}
1593
1594function _Json_listEquality(aDecoders, bDecoders)
1595{
1596	var len = aDecoders.length;
1597	if (len !== bDecoders.length)
1598	{
1599		return false;
1600	}
1601	for (var i = 0; i < len; i++)
1602	{
1603		if (!_Json_equality(aDecoders[i], bDecoders[i]))
1604		{
1605			return false;
1606		}
1607	}
1608	return true;
1609}
1610
1611
1612// ENCODE
1613
1614var _Json_encode = F2(function(indentLevel, value)
1615{
1616	return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1617});
1618
1619function _Json_wrap(value) { return { $: 0, a: value }; }
1620function _Json_unwrap(value) { return value.a; }
1621
1622function _Json_wrap_UNUSED(value) { return value; }
1623function _Json_unwrap_UNUSED(value) { return value; }
1624
1625function _Json_emptyArray() { return []; }
1626function _Json_emptyObject() { return {}; }
1627
1628var _Json_addField = F3(function(key, value, object)
1629{
1630	object[key] = _Json_unwrap(value);
1631	return object;
1632});
1633
1634function _Json_addEntry(func)
1635{
1636	return F2(function(entry, array)
1637	{
1638		array.push(_Json_unwrap(func(entry)));
1639		return array;
1640	});
1641}
1642
1643var _Json_encodeNull = _Json_wrap(null);
1644
1645
1646
1647// TASKS
1648
1649function _Scheduler_succeed(value)
1650{
1651	return {
1652		$: 0,
1653		a: value
1654	};
1655}
1656
1657function _Scheduler_fail(error)
1658{
1659	return {
1660		$: 1,
1661		a: error
1662	};
1663}
1664
1665function _Scheduler_binding(callback)
1666{
1667	return {
1668		$: 2,
1669		b: callback,
1670		c: null
1671	};
1672}
1673
1674var _Scheduler_andThen = F2(function(callback, task)
1675{
1676	return {
1677		$: 3,
1678		b: callback,
1679		d: task
1680	};
1681});
1682
1683var _Scheduler_onError = F2(function(callback, task)
1684{
1685	return {
1686		$: 4,
1687		b: callback,
1688		d: task
1689	};
1690});
1691
1692function _Scheduler_receive(callback)
1693{
1694	return {
1695		$: 5,
1696		b: callback
1697	};
1698}
1699
1700
1701// PROCESSES
1702
1703var _Scheduler_guid = 0;
1704
1705function _Scheduler_rawSpawn(task)
1706{
1707	var proc = {
1708		$: 0,
1709		e: _Scheduler_guid++,
1710		f: task,
1711		g: null,
1712		h: []
1713	};
1714
1715	_Scheduler_enqueue(proc);
1716
1717	return proc;
1718}
1719
1720function _Scheduler_spawn(task)
1721{
1722	return _Scheduler_binding(function(callback) {
1723		callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
1724	});
1725}
1726
1727function _Scheduler_rawSend(proc, msg)
1728{
1729	proc.h.push(msg);
1730	_Scheduler_enqueue(proc);
1731}
1732
1733var _Scheduler_send = F2(function(proc, msg)
1734{
1735	return _Scheduler_binding(function(callback) {
1736		_Scheduler_rawSend(proc, msg);
1737		callback(_Scheduler_succeed(_Utils_Tuple0));
1738	});
1739});
1740
1741function _Scheduler_kill(proc)
1742{
1743	return _Scheduler_binding(function(callback) {
1744		var task = proc.f;
1745		if (task.$ === 2 && task.c)
1746		{
1747			task.c();
1748		}
1749
1750		proc.f = null;
1751
1752		callback(_Scheduler_succeed(_Utils_Tuple0));
1753	});
1754}
1755
1756
1757/* STEP PROCESSES
1758
1759type alias Process =
1760  { $ : tag
1761  , id : unique_id
1762  , root : Task
1763  , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
1764  , mailbox : [msg]
1765  }
1766
1767*/
1768
1769
1770var _Scheduler_working = false;
1771var _Scheduler_queue = [];
1772
1773
1774function _Scheduler_enqueue(proc)
1775{
1776	_Scheduler_queue.push(proc);
1777	if (_Scheduler_working)
1778	{
1779		return;
1780	}
1781	_Scheduler_working = true;
1782	while (proc = _Scheduler_queue.shift())
1783	{
1784		_Scheduler_step(proc);
1785	}
1786	_Scheduler_working = false;
1787}
1788
1789
1790function _Scheduler_step(proc)
1791{
1792	while (proc.f)
1793	{
1794		var rootTag = proc.f.$;
1795		if (rootTag === 0 || rootTag === 1)
1796		{
1797			while (proc.g && proc.g.$ !== rootTag)
1798			{
1799				proc.g = proc.g.i;
1800			}
1801			if (!proc.g)
1802			{
1803				return;
1804			}
1805			proc.f = proc.g.b(proc.f.a);
1806			proc.g = proc.g.i;
1807		}
1808		else if (rootTag === 2)
1809		{
1810			proc.f.c = proc.f.b(function(newRoot) {
1811				proc.f = newRoot;
1812				_Scheduler_enqueue(proc);
1813			});
1814			return;
1815		}
1816		else if (rootTag === 5)
1817		{
1818			if (proc.h.length === 0)
1819			{
1820				return;
1821			}
1822			proc.f = proc.f.b(proc.h.shift());
1823		}
1824		else // if (rootTag === 3 || rootTag === 4)
1825		{
1826			proc.g = {
1827				$: rootTag === 3 ? 0 : 1,
1828				b: proc.f.b,
1829				i: proc.g
1830			};
1831			proc.f = proc.f.d;
1832		}
1833	}
1834}
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	var initPair = init(result.a);
1878	var model = initPair.a;
1879	var stepper = stepperBuilder(sendToApp, model);
1880	var ports = _Platform_setupEffects(managers, sendToApp);
1881
1882	function sendToApp(msg, viewMetadata)
1883	{
1884		var pair = A2(update, msg, model);
1885		stepper(model = pair.a, viewMetadata);
1886		_Platform_enqueueEffects(managers, pair.b, subscriptions(model));
1887	}
1888
1889	_Platform_enqueueEffects(managers, initPair.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// Effects must be queued!
2049//
2050// Say your init contains a synchronous command, like Time.now or Time.here
2051//
2052//   - This will produce a batch of effects (FX_1)
2053//   - The synchronous task triggers the subsequent `update` call
2054//   - This will produce a batch of effects (FX_2)
2055//
2056// If we just start dispatching FX_2, subscriptions from FX_2 can be processed
2057// before subscriptions from FX_1. No good! Earlier versions of this code had
2058// this problem, leading to these reports:
2059//
2060//   https://github.com/elm/core/issues/980
2061//   https://github.com/elm/core/pull/981
2062//   https://github.com/elm/compiler/issues/1776
2063//
2064// The queue is necessary to avoid ordering issues for synchronous commands.
2065
2066
2067// Why use true/false here? Why not just check the length of the queue?
2068// The goal is to detect "are we currently dispatching effects?" If we
2069// are, we need to bail and let the ongoing while loop handle things.
2070//
2071// Now say the queue has 1 element. When we dequeue the final element,
2072// the queue will be empty, but we are still actively dispatching effects.
2073// So you could get queue jumping in a really tricky category of cases.
2074//
2075var _Platform_effectsQueue = [];
2076var _Platform_effectsActive = false;

2077
2078
2079function _Platform_enqueueEffects(managers, cmdBag, subBag)
2080{
2081	_Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });
2082
2083	if (_Platform_effectsActive) return;
2084
2085	_Platform_effectsActive = true;
2086	for (var fx; fx = _Platform_effectsQueue.shift(); )
2087	{
2088		_Platform_dispatchEffects(fx.p, fx.q, fx.r);
2089	}
2090	_Platform_effectsActive = false;
2091}
2092
2093
2094function _Platform_dispatchEffects(managers, cmdBag, subBag)
2095{
2096	var effectsDict = {};
2097	_Platform_gatherEffects(true, cmdBag, effectsDict, null);
2098	_Platform_gatherEffects(false, subBag, effectsDict, null);
2099
2100	for (var home in managers)
2101	{
2102		_Scheduler_rawSend(managers[home], {
2103			$: 'fx',
2104			a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2105		});
2106	}
2107}
2108
2109
2110function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2111{
2112	switch (bag.$)
2113	{
2114		case 1:
2115			var home = bag.k;
2116			var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2117			effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2118			return;
2119
2120		case 2:
2121			for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2122			{
2123				_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2124			}
2125			return;
2126
2127		case 3:
2128			_Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2129				s: bag.n,
2130				t: taggers
2131			});
2132			return;
2133	}
2134}
2135
2136
2137function _Platform_toEffect(isCmd, home, taggers, value)
2138{
2139	function applyTaggers(x)
2140	{
2141		for (var temp = taggers; temp; temp = temp.t)
2142		{
2143			x = temp.s(x);
2144		}
2145		return x;
2146	}
2147
2148	var map = isCmd
2149		? _Platform_effectManagers[home].e
2150		: _Platform_effectManagers[home].f;
2151
2152	return A2(map, applyTaggers, value)
2153}
2154
2155
2156function _Platform_insert(isCmd, newEffect, effects)
2157{
2158	effects = effects || { i: _List_Nil, j: _List_Nil };
2159
2160	isCmd
2161		? (effects.i = _List_Cons(newEffect, effects.i))
2162		: (effects.j = _List_Cons(newEffect, effects.j));
2163
2164	return effects;
2165}
2166
2167
2168
2169// PORTS
2170
2171
2172function _Platform_checkPortName(name)
2173{
2174	if (_Platform_effectManagers[name])
2175	{
2176		_Debug_crash(3, name)
2177	}
2178}
2179
2180
2181
2182// OUTGOING PORTS
2183
2184
2185function _Platform_outgoingPort(name, converter)
2186{
2187	_Platform_checkPortName(name);
2188	_Platform_effectManagers[name] = {
2189		e: _Platform_outgoingPortMap,
2190		u: converter,
2191		a: _Platform_setupOutgoingPort
2192	};
2193	return _Platform_leaf(name);
2194}
2195
2196
2197var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2198
2199
2200function _Platform_setupOutgoingPort(name)
2201{
2202	var subs = [];
2203	var converter = _Platform_effectManagers[name].u;
2204
2205	// CREATE MANAGER
2206
2207	var init = _Process_sleep(0);
2208
2209	_Platform_effectManagers[name].b = init;
2210	_Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2211	{
2212		for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2213		{
2214			// grab a separate reference to subs in case unsubscribe is called
2215			var currentSubs = subs;
2216			var value = _Json_unwrap(converter(cmdList.a));
2217			for (var i = 0; i < currentSubs.length; i++)
2218			{
2219				currentSubs[i](value);
2220			}
2221		}
2222		return init;
2223	});
2224
2225	// PUBLIC API
2226
2227	function subscribe(callback)
2228	{
2229		subs.push(callback);
2230	}
2231
2232	function unsubscribe(callback)
2233	{
2234		// copy subs into a new array in case unsubscribe is called within a
2235		// subscribed callback
2236		subs = subs.slice();
2237		var index = subs.indexOf(callback);
2238		if (index >= 0)
2239		{
2240			subs.splice(index, 1);
2241		}
2242	}
2243
2244	return {
2245		subscribe: subscribe,
2246		unsubscribe: unsubscribe
2247	};
2248}
2249
2250
2251
2252// INCOMING PORTS
2253
2254
2255function _Platform_incomingPort(name, converter)
2256{
2257	_Platform_checkPortName(name);
2258	_Platform_effectManagers[name] = {
2259		f: _Platform_incomingPortMap,
2260		u: converter,
2261		a: _Platform_setupIncomingPort
2262	};
2263	return _Platform_leaf(name);
2264}
2265
2266
2267var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2268{
2269	return function(value)
2270	{
2271		return tagger(finalTagger(value));
2272	};
2273});
2274
2275
2276function _Platform_setupIncomingPort(name, sendToApp)
2277{
2278	var subs = _List_Nil;
2279	var converter = _Platform_effectManagers[name].u;
2280
2281	// CREATE MANAGER
2282
2283	var init = _Scheduler_succeed(null);
2284
2285	_Platform_effectManagers[name].b = init;
2286	_Platform_effectManagers[name].c = F3(function(router, subList, state)
2287	{
2288		subs = subList;
2289		return init;
2290	});
2291
2292	// PUBLIC API
2293
2294	function send(incomingValue)
2295	{
2296		var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2297
2298		$elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2299
2300		var value = result.a;
2301		for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2302		{
2303			sendToApp(temp.a(value));
2304		}
2305	}
2306
2307	return { send: send };
2308}
2309
2310
2311
2312// EXPORT ELM MODULES
2313//

2314// Have DEBUG and PROD versions so that we can (1) give nicer errors in
2315// debug mode and (2) not pay for the bits needed for that in prod mode.
2316//
2317
2318
2319function _Platform_export_UNUSED(exports)
2320{
2321	scope['Elm']
2322		? _Platform_mergeExportsProd(scope['Elm'], exports)
2323		: scope['Elm'] = exports;
2324}
2325
2326
2327function _Platform_mergeExportsProd(obj, exports)
2328{
2329	for (var name in exports)
2330	{
2331		(name in obj)
2332			? (name == 'init')
2333				? _Debug_crash(6)
2334				: _Platform_mergeExportsProd(obj[name], exports[name])
2335			: (obj[name] = exports[name]);
2336	}
2337}
2338
2339
2340function _Platform_export(exports)
2341{
2342	scope['Elm']
2343		? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
2344		: scope['Elm'] = exports;
2345}
2346
2347
2348function _Platform_mergeExportsDebug(moduleName, obj, exports)
2349{
2350	for (var name in exports)
2351	{
2352		(name in obj)
2353			? (name == 'init')
2354				? _Debug_crash(6, moduleName)
2355				: _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
2356			: (obj[name] = exports[name]);
2357	}
2358}
2359
2360
2361
2362
2363// HELPERS
2364
2365
2366var _VirtualDom_divertHrefToApp;
2367
2368var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};
2369
2370
2371function _VirtualDom_appendChild(parent, child)
2372{
2373	parent.appendChild(child);
2374}
2375
2376var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
2377{
2378	// NOTE: this function needs _Platform_export available to work
2379
2380	/**_UNUSED/
2381	var node = args['node'];
2382	//*/
2383	/**/
2384	var node = args && args['node'] ? args['node'] : _Debug_crash(0);
2385	//*/
2386
2387	node.parentNode.replaceChild(
2388		_VirtualDom_render(virtualNode, function() {}),
2389		node
2390	);
2391
2392	return {};
2393});
2394
2395
2396
2397// TEXT
2398
2399
2400function _VirtualDom_text(string)
2401{
2402	return {
2403		$: 0,
2404		a: string
2405	};
2406}
2407
2408
2409
2410// NODE
2411
2412
2413var _VirtualDom_nodeNS = F2(function(namespace, tag)
2414{
2415	return F2(function(factList, kidList)
2416	{
2417		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2418		{
2419			var kid = kidList.a;
2420			descendantsCount += (kid.b || 0);
2421			kids.push(kid);
2422		}
2423		descendantsCount += kids.length;
2424
2425		return {
2426			$: 1,
2427			c: tag,
2428			d: _VirtualDom_organizeFacts(factList),
2429			e: kids,
2430			f: namespace,
2431			b: descendantsCount
2432		};
2433	});
2434});
2435
2436
2437var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
2438
2439
2440
2441// KEYED NODE
2442
2443
2444var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)
2445{
2446	return F2(function(factList, kidList)
2447	{
2448		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2449		{
2450			var kid = kidList.a;
2451			descendantsCount += (kid.b.b || 0);
2452			kids.push(kid);
2453		}
2454		descendantsCount += kids.length;
2455
2456		return {
2457			$: 2,
2458			c: tag,
2459			d: _VirtualDom_organizeFacts(factList),
2460			e: kids,
2461			f: namespace,
2462			b: descendantsCount
2463		};
2464	});
2465});
2466
2467
2468var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
2469
2470
2471
2472// CUSTOM
2473
2474
2475function _VirtualDom_custom(factList, model, render, diff)
2476{
2477	return {
2478		$: 3,
2479		d: _VirtualDom_organizeFacts(factList),
2480		g: model,
2481		h: render,
2482		i: diff
2483	};
2484}
2485
2486
2487
2488// MAP
2489
2490
2491var _VirtualDom_map = F2(function(tagger, node)
2492{
2493	return {
2494		$: 4,
2495		j: tagger,
2496		k: node,
2497		b: 1 + (node.b || 0)
2498	};
2499});
2500
2501
2502
2503// LAZY
2504
2505
2506function _VirtualDom_thunk(refs, thunk)
2507{
2508	return {
2509		$: 5,
2510		l: refs,
2511		m: thunk,
2512		k: undefined
2513	};
2514}
2515
2516var _VirtualDom_lazy = F2(function(func, a)
2517{
2518	return _VirtualDom_thunk([func, a], function() {
2519		return func(a);
2520	});
2521});
2522
2523var _VirtualDom_lazy2 = F3(function(func, a, b)
2524{
2525	return _VirtualDom_thunk([func, a, b], function() {
2526		return A2(func, a, b);
2527	});
2528});
2529
2530var _VirtualDom_lazy3 = F4(function(func, a, b, c)
2531{
2532	return _VirtualDom_thunk([func, a, b, c], function() {
2533		return A3(func, a, b, c);
2534	});
2535});
2536
2537var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
2538{
2539	return _VirtualDom_thunk([func, a, b, c, d], function() {
2540		return A4(func, a, b, c, d);
2541	});
2542});
2543
2544var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
2545{
2546	return _VirtualDom_thunk([func, a, b, c, d, e], function() {
2547		return A5(func, a, b, c, d, e);
2548	});
2549});
2550
2551var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
2552{
2553	return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
2554		return A6(func, a, b, c, d, e, f);
2555	});
2556});
2557
2558var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
2559{
2560	return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
2561		return A7(func, a, b, c, d, e, f, g);
2562	});
2563});
2564
2565var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
2566{
2567	return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
2568		return A8(func, a, b, c, d, e, f, g, h);
2569	});
2570});
2571
2572
2573
2574// FACTS
2575
2576
2577var _VirtualDom_on = F2(function(key, handler)
2578{
2579	return {
2580		$: 'a0',
2581		n: key,
2582		o: handler
2583	};
2584});
2585var _VirtualDom_style = F2(function(key, value)
2586{
2587	return {
2588		$: 'a1',
2589		n: key,
2590		o: value
2591	};
2592});
2593var _VirtualDom_property = F2(function(key, value)
2594{
2595	return {
2596		$: 'a2',
2597		n: key,
2598		o: value
2599	};
2600});
2601var _VirtualDom_attribute = F2(function(key, value)
2602{
2603	return {
2604		$: 'a3',
2605		n: key,
2606		o: value
2607	};
2608});
2609var _VirtualDom_attributeNS = F3(function(namespace, key, value)
2610{
2611	return {
2612		$: 'a4',
2613		n: key,
2614		o: { f: namespace, o: value }
2615	};
2616});
2617
2618
2619
2620// XSS ATTACK VECTOR CHECKS
2621
2622
2623function _VirtualDom_noScript(tag)
2624{
2625	return tag == 'script' ? 'p' : tag;
2626}
2627
2628function _VirtualDom_noOnOrFormAction(key)
2629{
2630	return /^(on|formAction$)/i.test(key) ? 'data-' + key : key;
2631}
2632
2633function _VirtualDom_noInnerHtmlOrFormAction(key)
2634{

2635	return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;
2636}
2637
2638function _VirtualDom_noJavaScriptUri_UNUSED(value)
2639{
2640	return /^javascript:/i.test(value.replace(/\s/g,'')) ? '' : value;
2641}
2642
2643function _VirtualDom_noJavaScriptUri(value)
2644{
2645	return /^javascript:/i.test(value.replace(/\s/g,''))
2646		? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2647		: value;
2648}
2649
2650function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value)
2651{
2652	return /^\s*(javascript:|data:text\/html)/i.test(value) ? '' : value;
2653}
2654
2655function _VirtualDom_noJavaScriptOrHtmlUri(value)
2656{
2657	return /^\s*(javascript:|data:text\/html)/i.test(value)
2658		? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2659		: value;
2660}
2661
2662
2663
2664// MAP FACTS
2665
2666
2667var _VirtualDom_mapAttribute = F2(function(func, attr)
2668{
2669	return (attr.$ === 'a0')
2670		? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
2671		: attr;
2672});
2673
2674function _VirtualDom_mapHandler(func, handler)
2675{
2676	var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2677
2678	// 0 = Normal
2679	// 1 = MayStopPropagation
2680	// 2 = MayPreventDefault
2681	// 3 = Custom
2682
2683	return {
2684		$: handler.$,
2685		a:
2686			!tag
2687				? A2($elm$json$Json$Decode$map, func, handler.a)
2688				:
2689			A3($elm$json$Json$Decode$map2,
2690				tag < 3
2691					? _VirtualDom_mapEventTuple
2692					: _VirtualDom_mapEventRecord,
2693				$elm$json$Json$Decode$succeed(func),
2694				handler.a
2695			)
2696	};
2697}
2698
2699var _VirtualDom_mapEventTuple = F2(function(func, tuple)
2700{
2701	return _Utils_Tuple2(func(tuple.a), tuple.b);
2702});
2703
2704var _VirtualDom_mapEventRecord = F2(function(func, record)
2705{
2706	return {
2707		message: func(record.message),
2708		stopPropagation: record.stopPropagation,
2709		preventDefault: record.preventDefault
2710	}
2711});
2712
2713
2714
2715// ORGANIZE FACTS
2716
2717
2718function _VirtualDom_organizeFacts(factList)
2719{
2720	for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
2721	{
2722		var entry = factList.a;
2723
2724		var tag = entry.$;
2725		var key = entry.n;
2726		var value = entry.o;
2727
2728		if (tag === 'a2')
2729		{
2730			(key === 'className')
2731				? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
2732				: facts[key] = _Json_unwrap(value);
2733
2734			continue;
2735		}
2736
2737		var subFacts = facts[tag] || (facts[tag] = {});
2738		(tag === 'a3' && key === 'class')
2739			? _VirtualDom_addClass(subFacts, key, value)
2740			: subFacts[key] = value;
2741	}
2742
2743	return facts;
2744}
2745
2746function _VirtualDom_addClass(object, key, newClass)
2747{
2748	var classes = object[key];
2749	object[key] = classes ? classes + ' ' + newClass : newClass;
2750}
2751
2752
2753
2754// RENDER
2755
2756
2757function _VirtualDom_render(vNode, eventNode)
2758{
2759	var tag = vNode.$;
2760
2761	if (tag === 5)
2762	{
2763		return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
2764	}
2765
2766	if (tag === 0)
2767	{
2768		return _VirtualDom_doc.createTextNode(vNode.a);
2769	}
2770
2771	if (tag === 4)
2772	{
2773		var subNode = vNode.k;
2774		var tagger = vNode.j;
2775
2776		while (subNode.$ === 4)
2777		{
2778			typeof tagger !== 'object'
2779				? tagger = [tagger, subNode.j]
2780				: tagger.push(subNode.j);
2781
2782			subNode = subNode.k;
2783		}
2784
2785		var subEventRoot = { j: tagger, p: eventNode };

2786		var domNode = _VirtualDom_render(subNode, subEventRoot);
2787		domNode.elm_event_node_ref = subEventRoot;
2788		return domNode;
2789	}
2790
2791	if (tag === 3)
2792	{
2793		var domNode = vNode.h(vNode.g);
2794		_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2795		return domNode;
2796	}
2797
2798	// at this point `tag` must be 1 or 2
2799
2800	var domNode = vNode.f
2801		? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)
2802		: _VirtualDom_doc.createElement(vNode.c);
2803
2804	if (_VirtualDom_divertHrefToApp && vNode.c == 'a')
2805	{
2806		domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));
2807	}
2808
2809	_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2810
2811	for (var kids = vNode.e, i = 0; i < kids.length; i++)
2812	{
2813		_VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));
2814	}
2815
2816	return domNode;
2817}
2818
2819
2820
2821// APPLY FACTS
2822
2823
2824function _VirtualDom_applyFacts(domNode, eventNode, facts)
2825{
2826	for (var key in facts)
2827	{
2828		var value = facts[key];
2829
2830		key === 'a1'
2831			? _VirtualDom_applyStyles(domNode, value)
2832			:
2833		key === 'a0'
2834			? _VirtualDom_applyEvents(domNode, eventNode, value)
2835			:
2836		key === 'a3'
2837			? _VirtualDom_applyAttrs(domNode, value)
2838			:
2839		key === 'a4'
2840			? _VirtualDom_applyAttrsNS(domNode, value)
2841			:
2842		((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);
2843	}
2844}
2845
2846
2847
2848// APPLY STYLES
2849
2850
2851function _VirtualDom_applyStyles(domNode, styles)
2852{
2853	var domNodeStyle = domNode.style;
2854
2855	for (var key in styles)
2856	{
2857		domNodeStyle[key] = styles[key];
2858	}
2859}
2860
2861
2862
2863// APPLY ATTRS
2864
2865
2866function _VirtualDom_applyAttrs(domNode, attrs)
2867{
2868	for (var key in attrs)
2869	{
2870		var value = attrs[key];
2871		typeof value !== 'undefined'
2872			? domNode.setAttribute(key, value)
2873			: domNode.removeAttribute(key);
2874	}
2875}
2876
2877
2878
2879// APPLY NAMESPACED ATTRS
2880
2881
2882function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
2883{
2884	for (var key in nsAttrs)
2885	{
2886		var pair = nsAttrs[key];
2887		var namespace = pair.f;
2888		var value = pair.o;
2889
2890		typeof value !== 'undefined'
2891			? domNode.setAttributeNS(namespace, key, value)
2892			: domNode.removeAttributeNS(namespace, key);
2893	}
2894}
2895
2896
2897
2898// APPLY EVENTS
2899
2900
2901function _VirtualDom_applyEvents(domNode, eventNode, events)
2902{
2903	var allCallbacks = domNode.elmFs || (domNode.elmFs = {});
2904
2905	for (var key in events)
2906	{
2907		var newHandler = events[key];
2908		var oldCallback = allCallbacks[key];
2909
2910		if (!newHandler)
2911		{
2912			domNode.removeEventListener(key, oldCallback);
2913			allCallbacks[key] = undefined;
2914			continue;
2915		}
2916
2917		if (oldCallback)
2918		{
2919			var oldHandler = oldCallback.q;
2920			if (oldHandler.$ === newHandler.$)
2921			{
2922				oldCallback.q = newHandler;
2923				continue;
2924			}
2925			domNode.removeEventListener(key, oldCallback);
2926		}
2927
2928		oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
2929		domNode.addEventListener(key, oldCallback,
2930			_VirtualDom_passiveSupported
2931			&& { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }
2932		);
2933		allCallbacks[key] = oldCallback;
2934	}
2935}
2936
2937
2938
2939// PASSIVE EVENTS
2940
2941
2942var _VirtualDom_passiveSupported;
2943
2944try
2945{
2946	window.addEventListener('t', null, Object.defineProperty({}, 'passive', {
2947		get: function() { _VirtualDom_passiveSupported = true; }
2948	}));
2949}
2950catch(e) {}
2951
2952
2953
2954// EVENT HANDLERS
2955
2956
2957function _VirtualDom_makeCallback(eventNode, initialHandler)
2958{
2959	function callback(event)
2960	{
2961		var handler = callback.q;
2962		var result = _Json_runHelp(handler.a, event);
2963
2964		if (!$elm$core$Result$isOk(result))
2965		{
2966			return;
2967		}
2968
2969		var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2970
2971		// 0 = Normal
2972		// 1 = MayStopPropagation
2973		// 2 = MayPreventDefault
2974		// 3 = Custom
2975
2976		var value = result.a;
2977		var message = !tag ? value : tag < 3 ? value.a : value.message;
2978		var stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation;
2979		var currentEventNode = (
2980			stopPropagation && event.stopPropagation(),
2981			(tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(),
2982			eventNode
2983		);
2984		var tagger;
2985		var i;
2986		while (tagger = currentEventNode.j)
2987		{
2988			if (typeof tagger == 'function')
2989			{
2990				message = tagger(message);
2991			}
2992			else
2993			{
2994				for (var i = tagger.length; i--; )
2995				{
2996					message = tagger[i](message);
2997				}
2998			}
2999			currentEventNode = currentEventNode.p;
3000		}
3001		currentEventNode(message, stopPropagation); // stopPropagation implies isSync
3002	}
3003
3004	callback.q = initialHandler;
3005
3006	return callback;
3007}
3008
3009function _VirtualDom_equalEvents(x, y)
3010{
3011	return x.$ == y.$ && _Json_equality(x.a, y.a);
3012}
3013
3014
3015
3016// DIFF
3017
3018
3019// TODO: Should we do patches like in iOS?
3020//
3021// type Patch
3022//   = At Int Patch
3023//   | Batch (List Patch)
3024//   | Change ...
3025//
3026// How could it not be better?
3027//
3028function _VirtualDom_diff(x, y)
3029{
3030	var patches = [];
3031	_VirtualDom_diffHelp(x, y, patches, 0);
3032	return patches;
3033}
3034
3035

3036function _VirtualDom_pushPatch(patches, type, index, data)
3037{
3038	var patch = {
3039		$: type,
3040		r: index,
3041		s: data,
3042		t: undefined,
3043		u: undefined
3044	};
3045	patches.push(patch);
3046	return patch;
3047}
3048
3049
3050function _VirtualDom_diffHelp(x, y, patches, index)
3051{
3052	if (x === y)
3053	{
3054		return;
3055	}
3056
3057	var xType = x.$;
3058	var yType = y.$;
3059
3060	// Bail if you run into different types of nodes. Implies that the
3061	// structure has changed significantly and it's not worth a diff.
3062	if (xType !== yType)
3063	{
3064		if (xType === 1 && yType === 2)
3065		{
3066			y = _VirtualDom_dekey(y);
3067			yType = 1;
3068		}
3069		else
3070		{
3071			_VirtualDom_pushPatch(patches, 0, index, y);
3072			return;
3073		}
3074	}
3075
3076	// Now we know that both nodes are the same $.
3077	switch (yType)
3078	{
3079		case 5:
3080			var xRefs = x.l;
3081			var yRefs = y.l;
3082			var i = xRefs.length;
3083			var same = i === yRefs.length;
3084			while (same && i--)
3085			{
3086				same = xRefs[i] === yRefs[i];
3087			}
3088			if (same)
3089			{
3090				y.k = x.k;
3091				return;
3092			}
3093			y.k = y.m();
3094			var subPatches = [];
3095			_VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
3096			subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
3097			return;
3098
3099		case 4:
3100			// gather nested taggers
3101			var xTaggers = x.j;
3102			var yTaggers = y.j;
3103			var nesting = false;
3104
3105			var xSubNode = x.k;
3106			while (xSubNode.$ === 4)
3107			{
3108				nesting = true;
3109
3110				typeof xTaggers !== 'object'
3111					? xTaggers = [xTaggers, xSubNode.j]
3112					: xTaggers.push(xSubNode.j);
3113
3114				xSubNode = xSubNode.k;
3115			}
3116
3117			var ySubNode = y.k;
3118			while (ySubNode.$ === 4)
3119			{
3120				nesting = true;
3121
3122				typeof yTaggers !== 'object'
3123					? yTaggers = [yTaggers, ySubNode.j]
3124					: yTaggers.push(ySubNode.j);
3125
3126				ySubNode = ySubNode.k;
3127			}
3128
3129			// Just bail if different numbers of taggers. This implies the
3130			// structure of the virtual DOM has changed.
3131			if (nesting && xTaggers.length !== yTaggers.length)
3132			{
3133				_VirtualDom_pushPatch(patches, 0, index, y);
3134				return;
3135			}
3136
3137			// check if taggers are "the same"
3138			if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
3139			{
3140				_VirtualDom_pushPatch(patches, 2, index, yTaggers);
3141			}
3142
3143			// diff everything below the taggers
3144			_VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
3145			return;
3146
3147		case 0:
3148			if (x.a !== y.a)
3149			{
3150				_VirtualDom_pushPatch(patches, 3, index, y.a);
3151			}
3152			return;
3153
3154		case 1:
3155			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
3156			return;
3157
3158		case 2:
3159			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
3160			return;
3161
3162		case 3:
3163			if (x.h !== y.h)
3164			{
3165				_VirtualDom_pushPatch(patches, 0, index, y);
3166				return;
3167			}
3168
3169			var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3170			factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3171
3172			var patch = y.i(x.g, y.g);
3173			patch && _VirtualDom_pushPatch(patches, 5, index, patch);
3174
3175			return;
3176	}
3177}
3178
3179// assumes the incoming arrays are the same length
3180function _VirtualDom_pairwiseRefEqual(as, bs)
3181{
3182	for (var i = 0; i < as.length; i++)
3183	{
3184		if (as[i] !== bs[i])
3185		{
3186			return false;
3187		}
3188	}
3189
3190	return true;
3191}
3192
3193function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
3194{
3195	// Bail if obvious indicators have changed. Implies more serious
3196	// structural changes such that it's not worth it to diff.
3197	if (x.c !== y.c || x.f !== y.f)
3198	{
3199		_VirtualDom_pushPatch(patches, 0, index, y);
3200		return;
3201	}
3202
3203	var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3204	factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3205
3206	diffKids(x, y, patches, index);
3207}
3208
3209
3210
3211// DIFF FACTS
3212
3213
3214// TODO Instead of creating a new diff object, it's possible to just test if
3215// there *is* a diff. During the actual patch, do the diff again and make the
3216// modifications directly. This way, there's no new allocations. Worth it?
3217function _VirtualDom_diffFacts(x, y, category)
3218{
3219	var diff;
3220
3221	// look for changes and removals
3222	for (var xKey in x)
3223	{
3224		if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
3225		{
3226			var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
3227			if (subDiff)
3228			{
3229				diff = diff || {};
3230				diff[xKey] = subDiff;
3231			}
3232			continue;
3233		}
3234
3235		// remove if not in the new facts
3236		if (!(xKey in y))
3237		{
3238			diff = diff || {};
3239			diff[xKey] =
3240				!category
3241					? (typeof x[xKey] === 'string' ? '' : null)
3242					:
3243				(category === 'a1')
3244					? ''
3245					:
3246				(category === 'a0' || category === 'a3')
3247					? undefined
3248					:
3249				{ f: x[xKey].f, o: undefined };
3250
3251			continue;
3252		}
3253
3254		var xValue = x[xKey];
3255		var yValue = y[xKey];
3256
3257		// reference equal, so don't worry about it
3258		if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
3259			|| category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
3260		{

3261			continue;
3262		}
3263
3264		diff = diff || {};
3265		diff[xKey] = yValue;
3266	}
3267
3268	// add new stuff
3269	for (var yKey in y)
3270	{
3271		if (!(yKey in x))
3272		{
3273			diff = diff || {};
3274			diff[yKey] = y[yKey];
3275		}
3276	}
3277
3278	return diff;
3279}
3280
3281
3282
3283// DIFF KIDS
3284
3285
3286function _VirtualDom_diffKids(xParent, yParent, patches, index)
3287{
3288	var xKids = xParent.e;
3289	var yKids = yParent.e;
3290
3291	var xLen = xKids.length;
3292	var yLen = yKids.length;
3293
3294	// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
3295
3296	if (xLen > yLen)
3297	{
3298		_VirtualDom_pushPatch(patches, 6, index, {
3299			v: yLen,
3300			i: xLen - yLen
3301		});
3302	}
3303	else if (xLen < yLen)
3304	{
3305		_VirtualDom_pushPatch(patches, 7, index, {
3306			v: xLen,
3307			e: yKids
3308		});
3309	}
3310
3311	// PAIRWISE DIFF EVERYTHING ELSE
3312
3313	for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
3314	{
3315		var xKid = xKids[i];
3316		_VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
3317		index += xKid.b || 0;
3318	}
3319}
3320
3321
3322
3323// KEYED DIFF
3324
3325
3326function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)
3327{
3328	var localPatches = [];
3329
3330	var changes = {}; // Dict String Entry
3331	var inserts = []; // Array { index : Int, entry : Entry }
3332	// type Entry = { tag : String, vnode : VNode, index : Int, data : _ }
3333
3334	var xKids = xParent.e;
3335	var yKids = yParent.e;
3336	var xLen = xKids.length;
3337	var yLen = yKids.length;
3338	var xIndex = 0;
3339	var yIndex = 0;
3340
3341	var index = rootIndex;
3342
3343	while (xIndex < xLen && yIndex < yLen)
3344	{
3345		var x = xKids[xIndex];
3346		var y = yKids[yIndex];
3347
3348		var xKey = x.a;
3349		var yKey = y.a;
3350		var xNode = x.b;
3351		var yNode = y.b;
3352
3353		var newMatch = undefined;
3354		var oldMatch = undefined;
3355
3356		// check if keys match
3357
3358		if (xKey === yKey)
3359		{
3360			index++;
3361			_VirtualDom_diffHelp(xNode, yNode, localPatches, index);
3362			index += xNode.b || 0;
3363
3364			xIndex++;
3365			yIndex++;
3366			continue;
3367		}
3368
3369		// look ahead 1 to detect insertions and removals.
3370
3371		var xNext = xKids[xIndex + 1];
3372		var yNext = yKids[yIndex + 1];
3373
3374		if (xNext)
3375		{
3376			var xNextKey = xNext.a;
3377			var xNextNode = xNext.b;
3378			oldMatch = yKey === xNextKey;
3379		}
3380
3381		if (yNext)
3382		{
3383			var yNextKey = yNext.a;
3384			var yNextNode = yNext.b;
3385			newMatch = xKey === yNextKey;
3386		}
3387
3388
3389		// swap x and y
3390		if (newMatch && oldMatch)
3391		{
3392			index++;
3393			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3394			_VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
3395			index += xNode.b || 0;
3396
3397			index++;
3398			_VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
3399			index += xNextNode.b || 0;
3400
3401			xIndex += 2;
3402			yIndex += 2;
3403			continue;
3404		}
3405
3406		// insert y
3407		if (newMatch)
3408		{
3409			index++;
3410			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3411			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3412			index += xNode.b || 0;
3413
3414			xIndex += 1;
3415			yIndex += 2;
3416			continue;
3417		}
3418
3419		// remove x
3420		if (oldMatch)
3421		{
3422			index++;
3423			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3424			index += xNode.b || 0;
3425
3426			index++;
3427			_VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
3428			index += xNextNode.b || 0;
3429
3430			xIndex += 2;
3431			yIndex += 1;
3432			continue;
3433		}
3434
3435		// remove x, insert y
3436		if (xNext && xNextKey === yNextKey)
3437		{
3438			index++;
3439			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3440			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3441			index += xNode.b || 0;
3442
3443			index++;
3444			_VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
3445			index += xNextNode.b || 0;
3446
3447			xIndex += 2;
3448			yIndex += 2;
3449			continue;
3450		}
3451
3452		break;
3453	}
3454
3455	// eat up any remaining nodes with removeNode and insertNode
3456
3457	while (xIndex < xLen)
3458	{
3459		index++;
3460		var x = xKids[xIndex];
3461		var xNode = x.b;
3462		_VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
3463		index += xNode.b || 0;
3464		xIndex++;
3465	}
3466
3467	while (yIndex < yLen)
3468	{
3469		var endInserts = endInserts || [];
3470		var y = yKids[yIndex];
3471		_VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
3472		yIndex++;
3473	}
3474
3475	if (localPatches.length > 0 || inserts.length > 0 || endInserts)
3476	{
3477		_VirtualDom_pushPatch(patches, 8, rootIndex, {
3478			w: localPatches,
3479			x: inserts,
3480			y: endInserts
3481		});
3482	}
3483}
3484
3485
3486
3487// CHANGES FROM KEYED DIFF
3488
3489
3490var _VirtualDom_POSTFIX = '_elmW6BL';
3491
3492
3493function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
3494{
3495	var entry = changes[key];
3496
3497	// never seen this key before

3498	if (!entry)
3499	{
3500		entry = {
3501			c: 0,
3502			z: vnode,
3503			r: yIndex,
3504			s: undefined
3505		};
3506
3507		inserts.push({ r: yIndex, A: entry });
3508		changes[key] = entry;
3509
3510		return;
3511	}
3512
3513	// this key was removed earlier, a match!
3514	if (entry.c === 1)
3515	{
3516		inserts.push({ r: yIndex, A: entry });
3517
3518		entry.c = 2;
3519		var subPatches = [];
3520		_VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
3521		entry.r = yIndex;
3522		entry.s.s = {
3523			w: subPatches,
3524			A: entry
3525		};
3526
3527		return;
3528	}
3529
3530	// this key has already been inserted or moved, a duplicate!
3531	_VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
3532}
3533
3534
3535function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
3536{
3537	var entry = changes[key];
3538
3539	// never seen this key before
3540	if (!entry)
3541	{
3542		var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
3543
3544		changes[key] = {
3545			c: 1,
3546			z: vnode,
3547			r: index,
3548			s: patch
3549		};
3550
3551		return;
3552	}
3553
3554	// this key was inserted earlier, a match!
3555	if (entry.c === 0)
3556	{
3557		entry.c = 2;
3558		var subPatches = [];
3559		_VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
3560
3561		_VirtualDom_pushPatch(localPatches, 9, index, {
3562			w: subPatches,
3563			A: entry
3564		});
3565
3566		return;
3567	}
3568
3569	// this key has already been removed or moved, a duplicate!
3570	_VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);
3571}
3572
3573
3574
3575// ADD DOM NODES
3576//
3577// Each DOM node has an "index" assigned in order of traversal. It is important
3578// to minimize our crawl over the actual DOM, so these indexes (along with the
3579// descendantsCount of virtual nodes) let us skip touching entire subtrees of
3580// the DOM if we know there are no patches there.
3581
3582
3583function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
3584{
3585	_VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
3586}
3587
3588
3589// assumes `patches` is non-empty and indexes increase monotonically.
3590function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
3591{
3592	var patch = patches[i];
3593	var index = patch.r;
3594
3595	while (index === low)
3596	{
3597		var patchType = patch.$;
3598
3599		if (patchType === 1)
3600		{
3601			_VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
3602		}
3603		else if (patchType === 8)
3604		{
3605			patch.t = domNode;
3606			patch.u = eventNode;
3607
3608			var subPatches = patch.s.w;
3609			if (subPatches.length > 0)
3610			{
3611				_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3612			}
3613		}
3614		else if (patchType === 9)
3615		{
3616			patch.t = domNode;
3617			patch.u = eventNode;
3618
3619			var data = patch.s;
3620			if (data)
3621			{
3622				data.A.s = domNode;
3623				var subPatches = data.w;
3624				if (subPatches.length > 0)
3625				{
3626					_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3627				}
3628			}
3629		}
3630		else
3631		{
3632			patch.t = domNode;
3633			patch.u = eventNode;
3634		}
3635
3636		i++;
3637
3638		if (!(patch = patches[i]) || (index = patch.r) > high)
3639		{
3640			return i;
3641		}
3642	}
3643
3644	var tag = vNode.$;
3645
3646	if (tag === 4)
3647	{
3648		var subNode = vNode.k;
3649
3650		while (subNode.$ === 4)
3651		{
3652			subNode = subNode.k;
3653		}
3654
3655		return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);
3656	}
3657
3658	// tag must be 1 or 2 at this point
3659
3660	var vKids = vNode.e;
3661	var childNodes = domNode.childNodes;
3662	for (var j = 0; j < vKids.length; j++)
3663	{
3664		low++;
3665		var vKid = tag === 1 ? vKids[j] : vKids[j].b;
3666		var nextLow = low + (vKid.b || 0);
3667		if (low <= index && index <= nextLow)
3668		{
3669			i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
3670			if (!(patch = patches[i]) || (index = patch.r) > high)
3671			{
3672				return i;
3673			}
3674		}
3675		low = nextLow;
3676	}
3677	return i;
3678}
3679
3680
3681
3682// APPLY PATCHES
3683
3684
3685function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
3686{
3687	if (patches.length === 0)
3688	{
3689		return rootDomNode;
3690	}
3691
3692	_VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
3693	return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
3694}
3695
3696function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
3697{
3698	for (var i = 0; i < patches.length; i++)
3699	{
3700		var patch = patches[i];
3701		var localDomNode = patch.t
3702		var newNode = _VirtualDom_applyPatch(localDomNode, patch);
3703		if (localDomNode === rootDomNode)
3704		{
3705			rootDomNode = newNode;
3706		}
3707	}
3708	return rootDomNode;
3709}
3710
3711function _VirtualDom_applyPatch(domNode, patch)
3712{
3713	switch (patch.$)
3714	{
3715		case 0:
3716			return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
3717
3718		case 4:
3719			_VirtualDom_applyFacts(domNode, patch.u, patch.s);
3720			return domNode;
3721
3722		case 3:

3723			domNode.replaceData(0, domNode.length, patch.s);
3724			return domNode;
3725
3726		case 1:
3727			return _VirtualDom_applyPatchesHelp(domNode, patch.s);
3728
3729		case 2:
3730			if (domNode.elm_event_node_ref)
3731			{
3732				domNode.elm_event_node_ref.j = patch.s;
3733			}
3734			else
3735			{
3736				domNode.elm_event_node_ref = { j: patch.s, p: patch.u };
3737			}
3738			return domNode;
3739
3740		case 6:
3741			var data = patch.s;
3742			for (var i = 0; i < data.i; i++)
3743			{
3744				domNode.removeChild(domNode.childNodes[data.v]);
3745			}
3746			return domNode;
3747
3748		case 7:
3749			var data = patch.s;
3750			var kids = data.e;
3751			var i = data.v;
3752			var theEnd = domNode.childNodes[i];
3753			for (; i < kids.length; i++)
3754			{
3755				domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);
3756			}
3757			return domNode;
3758
3759		case 9:
3760			var data = patch.s;
3761			if (!data)
3762			{
3763				domNode.parentNode.removeChild(domNode);
3764				return domNode;
3765			}
3766			var entry = data.A;
3767			if (typeof entry.r !== 'undefined')
3768			{
3769				domNode.parentNode.removeChild(domNode);
3770			}
3771			entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
3772			return domNode;
3773
3774		case 8:
3775			return _VirtualDom_applyPatchReorder(domNode, patch);
3776
3777		case 5:
3778			return patch.s(domNode);
3779
3780		default:
3781			_Debug_crash(10); // 'Ran into an unknown patch!'
3782	}
3783}
3784
3785
3786function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
3787{
3788	var parentNode = domNode.parentNode;
3789	var newNode = _VirtualDom_render(vNode, eventNode);
3790
3791	if (!newNode.elm_event_node_ref)
3792	{
3793		newNode.elm_event_node_ref = domNode.elm_event_node_ref;
3794	}
3795
3796	if (parentNode && newNode !== domNode)
3797	{
3798		parentNode.replaceChild(newNode, domNode);
3799	}
3800	return newNode;
3801}
3802
3803
3804function _VirtualDom_applyPatchReorder(domNode, patch)
3805{
3806	var data = patch.s;
3807
3808	// remove end inserts
3809	var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
3810
3811	// removals
3812	domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
3813
3814	// inserts
3815	var inserts = data.x;
3816	for (var i = 0; i < inserts.length; i++)
3817	{
3818		var insert = inserts[i];
3819		var entry = insert.A;
3820		var node = entry.c === 2
3821			? entry.s
3822			: _VirtualDom_render(entry.z, patch.u);
3823		domNode.insertBefore(node, domNode.childNodes[insert.r]);
3824	}
3825
3826	// add end inserts
3827	if (frag)
3828	{
3829		_VirtualDom_appendChild(domNode, frag);
3830	}
3831
3832	return domNode;
3833}
3834
3835
3836function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
3837{
3838	if (!endInserts)
3839	{
3840		return;
3841	}
3842
3843	var frag = _VirtualDom_doc.createDocumentFragment();
3844	for (var i = 0; i < endInserts.length; i++)
3845	{
3846		var insert = endInserts[i];
3847		var entry = insert.A;
3848		_VirtualDom_appendChild(frag, entry.c === 2
3849			? entry.s
3850			: _VirtualDom_render(entry.z, patch.u)
3851		);
3852	}
3853	return frag;
3854}
3855
3856
3857function _VirtualDom_virtualize(node)
3858{
3859	// TEXT NODES
3860
3861	if (node.nodeType === 3)
3862	{
3863		return _VirtualDom_text(node.textContent);
3864	}
3865
3866
3867	// WEIRD NODES
3868
3869	if (node.nodeType !== 1)
3870	{
3871		return _VirtualDom_text('');
3872	}
3873
3874
3875	// ELEMENT NODES
3876
3877	var attrList = _List_Nil;
3878	var attrs = node.attributes;
3879	for (var i = attrs.length; i--; )
3880	{
3881		var attr = attrs[i];
3882		var name = attr.name;
3883		var value = attr.value;
3884		attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );
3885	}
3886
3887	var tag = node.tagName.toLowerCase();
3888	var kidList = _List_Nil;
3889	var kids = node.childNodes;
3890
3891	for (var i = kids.length; i--; )
3892	{
3893		kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);
3894	}
3895	return A3(_VirtualDom_node, tag, attrList, kidList);
3896}
3897
3898function _VirtualDom_dekey(keyedNode)
3899{
3900	var keyedKids = keyedNode.e;
3901	var len = keyedKids.length;
3902	var kids = new Array(len);
3903	for (var i = 0; i < len; i++)
3904	{
3905		kids[i] = keyedKids[i].b;
3906	}
3907
3908	return {
3909		$: 1,
3910		c: keyedNode.c,
3911		d: keyedNode.d,
3912		e: kids,
3913		f: keyedNode.f,
3914		b: keyedNode.b
3915	};
3916}
3917
3918
3919
3920
3921// ELEMENT
3922
3923
3924var _Debugger_element;
3925
3926var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args)
3927{
3928	return _Platform_initialize(
3929		flagDecoder,
3930		args,
3931		impl.init,
3932		impl.update,
3933		impl.subscriptions,
3934		function(sendToApp, initialModel) {
3935			var view = impl.view;
3936			/**_UNUSED/
3937			var domNode = args['node'];
3938			//*/
3939			/**/
3940			var domNode = args && args['node'] ? args['node'] : _Debug_crash(0);
3941			//*/
3942			var currNode = _VirtualDom_virtualize(domNode);
3943
3944			return _Browser_makeAnimator(initialModel, function(model)
3945			{
3946				var nextNode = view(model);
3947				var patches = _VirtualDom_diff(currNode, nextNode);
3948				domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp);
3949				currNode = nextNode;
3950			});
3951		}
3952	);
3953});
3954
3955
3956
3957// DOCUMENT
3958
3959
3960var _Debugger_document;
3961
3962var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args)
3963{
3964	return _Platform_initialize(
3965		flagDecoder,
3966		args,
3967		impl.init,
3968		impl.update,
3969		impl.subscriptions,
3970		function(sendToApp, initialModel) {
3971			var divertHrefToApp = impl.setup && impl.setup(sendToApp)
3972			var view = impl.view;
3973			var title = _VirtualDom_doc.title;
3974			var bodyNode = _VirtualDom_doc.body;
3975			var currNode = _VirtualDom_virtualize(bodyNode);
3976			return _Browser_makeAnimator(initialModel, function(model)
3977			{
3978				_VirtualDom_divertHrefToApp = divertHrefToApp;
3979				var doc = view(model);
3980				var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.body);
3981				var patches = _VirtualDom_diff(currNode, nextNode);
3982				bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp);
3983				currNode = nextNode;
3984				_VirtualDom_divertHrefToApp = 0;
3985				(title !== doc.title) && (_VirtualDom_doc.title = title = doc.title);
3986			});
3987		}
3988	);
3989});
3990
3991
3992
3993// ANIMATION
3994
3995
3996var _Browser_cancelAnimationFrame =
3997	typeof cancelAnimationFrame !== 'undefined'
3998		? cancelAnimationFrame
3999		: function(id) { clearTimeout(id); };
4000
4001var _Browser_requestAnimationFrame =
4002	typeof requestAnimationFrame !== 'undefined'
4003		? requestAnimationFrame
4004		: function(callback) { return setTimeout(callback, 1000 / 60); };
4005
4006
4007function _Browser_makeAnimator(model, draw)
4008{
4009	draw(model);
4010
4011	var state = 0;
4012
4013	function updateIfNeeded()
4014	{
4015		state = state === 1
4016			? 0
4017			: ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 );
4018	}
4019
4020	return function(nextModel, isSync)
4021	{
4022		model = nextModel;
4023
4024		isSync
4025			? ( draw(model),
4026				state === 2 && (state = 1)
4027				)
4028			: ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded),
4029				state = 2
4030				);
4031	};
4032}
4033
4034
4035
4036// APPLICATION
4037
4038
4039function _Browser_application(impl)
4040{
4041	var onUrlChange = impl.onUrlChange;
4042	var onUrlRequest = impl.onUrlRequest;
4043	var key = function() { key.a(onUrlChange(_Browser_getUrl())); };
4044
4045	return _Browser_document({
4046		setup: function(sendToApp)
4047		{
4048			key.a = sendToApp;
4049			_Browser_window.addEventListener('popstate', key);
4050			_Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key);
4051
4052			return F2(function(domNode, event)
4053			{
4054				if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download'))
4055				{
4056					event.preventDefault();
4057					var href = domNode.href;
4058					var curr = _Browser_getUrl();
4059					var next = $elm$url$Url$fromString(href).a;
4060					sendToApp(onUrlRequest(
4061						(next
4062							&& curr.protocol === next.protocol
4063							&& curr.host === next.host
4064							&& curr.port_.a === next.port_.a
4065						)
4066							? $elm$browser$Browser$Internal(next)
4067							: $elm$browser$Browser$External(href)
4068					));
4069				}
4070			});
4071		},
4072		init: function(flags)
4073		{
4074			return A3(impl.init, flags, _Browser_getUrl(), key);
4075		},
4076		view: impl.view,
4077		update: impl.update,
4078		subscriptions: impl.subscriptions
4079	});
4080}
4081
4082function _Browser_getUrl()
4083{
4084	return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1);
4085}
4086
4087var _Browser_go = F2(function(key, n)
4088{
4089	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4090		n && history.go(n);
4091		key();
4092	}));
4093});
4094
4095var _Browser_pushUrl = F2(function(key, url)
4096{
4097	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4098		history.pushState({}, '', url);
4099		key();
4100	}));
4101});
4102
4103var _Browser_replaceUrl = F2(function(key, url)
4104{
4105	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4106		history.replaceState({}, '', url);
4107		key();
4108	}));
4109});
4110
4111
4112
4113// GLOBAL EVENTS
4114
4115
4116var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} };
4117var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode;
4118var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode;
4119
4120var _Browser_on = F3(function(node, eventName, sendToSelf)
4121{
4122	return _Scheduler_spawn(_Scheduler_binding(function(callback)
4123	{
4124		function handler(event)	{ _Scheduler_rawSpawn(sendToSelf(event)); }
4125		node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true });
4126		return function() { node.removeEventListener(eventName, handler); };
4127	}));
4128});
4129
4130var _Browser_decodeEvent = F2(function(decoder, event)
4131{
4132	var result = _Json_runHelp(decoder, event);
4133	return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing;
4134});
4135
4136
4137
4138// PAGE VISIBILITY
4139
4140
4141function _Browser_visibilityInfo()
4142{
4143	return (typeof _VirtualDom_doc.hidden !== 'undefined')
4144		? { hidden: 'hidden', change: 'visibilitychange' }
4145		:
4146	(typeof _VirtualDom_doc.mozHidden !== 'undefined')
4147		? { hidden: 'mozHidden', change: 'mozvisibilitychange' }
4148		:
4149	(typeof _VirtualDom_doc.msHidden !== 'undefined')
4150		? { hidden: 'msHidden', change: 'msvisibilitychange' }
4151		:
4152	(typeof _VirtualDom_doc.webkitHidden !== 'undefined')
4153		? { hidden: 'webkitHidden', change: 'webkitvisibilitychange' }
4154		: { hidden: 'hidden', change: 'visibilitychange' };
4155}
4156
4157
4158
4159// ANIMATION FRAMES
4160
4161
4162function _Browser_rAF()
4163{
4164	return _Scheduler_binding(function(callback)
4165	{
4166		var id = _Browser_requestAnimationFrame(function() {

4167			callback(_Scheduler_succeed(Date.now()));
4168		});
4169
4170		return function() {
4171			_Browser_cancelAnimationFrame(id);
4172		};
4173	});
4174}
4175
4176
4177function _Browser_now()
4178{
4179	return _Scheduler_binding(function(callback)
4180	{
4181		callback(_Scheduler_succeed(Date.now()));
4182	});
4183}
4184
4185
4186
4187// DOM STUFF
4188
4189
4190function _Browser_withNode(id, doStuff)
4191{
4192	return _Scheduler_binding(function(callback)
4193	{
4194		_Browser_requestAnimationFrame(function() {
4195			var node = document.getElementById(id);
4196			callback(node
4197				? _Scheduler_succeed(doStuff(node))
4198				: _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id))
4199			);
4200		});
4201	});
4202}
4203
4204
4205function _Browser_withWindow(doStuff)
4206{
4207	return _Scheduler_binding(function(callback)
4208	{
4209		_Browser_requestAnimationFrame(function() {
4210			callback(_Scheduler_succeed(doStuff()));
4211		});
4212	});
4213}
4214
4215
4216// FOCUS and BLUR
4217
4218
4219var _Browser_call = F2(function(functionName, id)
4220{
4221	return _Browser_withNode(id, function(node) {
4222		node[functionName]();
4223		return _Utils_Tuple0;
4224	});
4225});
4226
4227
4228
4229// WINDOW VIEWPORT
4230
4231
4232function _Browser_getViewport()
4233{
4234	return {
4235		scene: _Browser_getScene(),
4236		viewport: {
4237			x: _Browser_window.pageXOffset,
4238			y: _Browser_window.pageYOffset,
4239			width: _Browser_doc.documentElement.clientWidth,
4240			height: _Browser_doc.documentElement.clientHeight
4241		}
4242	};
4243}
4244
4245function _Browser_getScene()
4246{
4247	var body = _Browser_doc.body;
4248	var elem = _Browser_doc.documentElement;
4249	return {
4250		width: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
4251		height: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
4252	};
4253}
4254
4255var _Browser_setViewport = F2(function(x, y)
4256{
4257	return _Browser_withWindow(function()
4258	{
4259		_Browser_window.scroll(x, y);
4260		return _Utils_Tuple0;
4261	});
4262});
4263
4264
4265
4266// ELEMENT VIEWPORT
4267
4268
4269function _Browser_getViewportOf(id)
4270{
4271	return _Browser_withNode(id, function(node)
4272	{
4273		return {
4274			scene: {
4275				width: node.scrollWidth,
4276				height: node.scrollHeight
4277			},
4278			viewport: {
4279				x: node.scrollLeft,
4280				y: node.scrollTop,
4281				width: node.clientWidth,
4282				height: node.clientHeight
4283			}
4284		};
4285	});
4286}
4287
4288
4289var _Browser_setViewportOf = F3(function(id, x, y)
4290{
4291	return _Browser_withNode(id, function(node)
4292	{
4293		node.scrollLeft = x;
4294		node.scrollTop = y;
4295		return _Utils_Tuple0;
4296	});
4297});
4298
4299
4300
4301// ELEMENT
4302
4303
4304function _Browser_getElement(id)
4305{
4306	return _Browser_withNode(id, function(node)
4307	{
4308		var rect = node.getBoundingClientRect();
4309		var x = _Browser_window.pageXOffset;
4310		var y = _Browser_window.pageYOffset;
4311		return {
4312			scene: _Browser_getScene(),
4313			viewport: {
4314				x: x,
4315				y: y,
4316				width: _Browser_doc.documentElement.clientWidth,
4317				height: _Browser_doc.documentElement.clientHeight
4318			},
4319			element: {
4320				x: x + rect.left,
4321				y: y + rect.top,
4322				width: rect.width,
4323				height: rect.height
4324			}
4325		};
4326	});
4327}
4328
4329
4330
4331// LOAD and RELOAD
4332
4333
4334function _Browser_reload(skipCache)
4335{
4336	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4337	{
4338		_VirtualDom_doc.location.reload(skipCache);
4339	}));
4340}
4341
4342function _Browser_load(url)
4343{
4344	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4345	{
4346		try
4347		{
4348			_Browser_window.location = url;
4349		}
4350		catch(err)
4351		{
4352			// Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
4353			// Other browsers reload the page, so let's be consistent about that.
4354			_VirtualDom_doc.location.reload(false);
4355		}
4356	}));
4357}
4358
4359
4360
4361
4362// STRINGS
4363
4364
4365var _Parser_isSubString = F5(function(smallString, offset, row, col, bigString)
4366{
4367	var smallLength = smallString.length;
4368	var isGood = offset + smallLength <= bigString.length;
4369
4370	for (var i = 0; isGood && i < smallLength; )
4371	{
4372		var code = bigString.charCodeAt(offset);
4373		isGood =
4374			smallString[i++] === bigString[offset++]
4375			&& (
4376				code === 0x000A /* \n */
4377					? ( row++, col=1 )
4378					: ( col++, (code & 0xF800) === 0xD800 ? smallString[i++] === bigString[offset++] : 1 )
4379			)
4380	}
4381

4382	return _Utils_Tuple3(isGood ? offset : -1, row, col);
4383});
4384
4385
4386
4387// CHARS
4388
4389
4390var _Parser_isSubChar = F3(function(predicate, offset, string)
4391{
4392	return (
4393		string.length <= offset
4394			? -1
4395			:
4396		(string.charCodeAt(offset) & 0xF800) === 0xD800
4397			? (predicate(_Utils_chr(string.substr(offset, 2))) ? offset + 2 : -1)
4398			:
4399		(predicate(_Utils_chr(string[offset]))
4400			? ((string[offset] === '\n') ? -2 : (offset + 1))
4401			: -1
4402		)
4403	);
4404});
4405
4406
4407var _Parser_isAsciiCode = F3(function(code, offset, string)
4408{
4409	return string.charCodeAt(offset) === code;
4410});
4411
4412
4413
4414// NUMBERS
4415
4416
4417var _Parser_chompBase10 = F2(function(offset, string)
4418{
4419	for (; offset < string.length; offset++)
4420	{
4421		var code = string.charCodeAt(offset);
4422		if (code < 0x30 || 0x39 < code)
4423		{
4424			return offset;
4425		}
4426	}
4427	return offset;
4428});
4429
4430
4431var _Parser_consumeBase = F3(function(base, offset, string)
4432{
4433	for (var total = 0; offset < string.length; offset++)
4434	{
4435		var digit = string.charCodeAt(offset) - 0x30;
4436		if (digit < 0 || base <= digit) break;
4437		total = base * total + digit;
4438	}
4439	return _Utils_Tuple2(offset, total);
4440});
4441
4442
4443var _Parser_consumeBase16 = F2(function(offset, string)
4444{
4445	for (var total = 0; offset < string.length; offset++)
4446	{
4447		var code = string.charCodeAt(offset);
4448		if (0x30 <= code && code <= 0x39)
4449		{
4450			total = 16 * total + code - 0x30;
4451		}
4452		else if (0x41 <= code && code <= 0x46)
4453		{
4454			total = 16 * total + code - 55;
4455		}
4456		else if (0x61 <= code && code <= 0x66)
4457		{
4458			total = 16 * total + code - 87;
4459		}
4460		else
4461		{
4462			break;
4463		}
4464	}
4465	return _Utils_Tuple2(offset, total);
4466});
4467
4468
4469
4470// FIND STRING
4471
4472
4473var _Parser_findSubString = F5(function(smallString, offset, row, col, bigString)
4474{
4475	var newOffset = bigString.indexOf(smallString, offset);
4476	var target = newOffset < 0 ? bigString.length : newOffset + smallString.length;
4477
4478	while (offset < target)
4479	{
4480		var code = bigString.charCodeAt(offset++);
4481		code === 0x000A /* \n */
4482			? ( col=1, row++ )
4483			: ( col++, (code & 0xF800) === 0xD800 && offset++ )
4484	}
4485
4486	return _Utils_Tuple3(newOffset, row, col);
4487});
4488var $elm$core$Basics$EQ = {$: 'EQ'};
4489var $elm$core$Basics$GT = {$: 'GT'};
4490var $elm$core$Basics$LT = {$: 'LT'};
4491var $elm$core$List$cons = _List_cons;
4492var $elm$core$Dict$foldr = F3(
4493	function (func, acc, t) {
4494		foldr:
4495		while (true) {
4496			if (t.$ === 'RBEmpty_elm_builtin') {
4497				return acc;
4498			} else {
4499				var key = t.b;
4500				var value = t.c;
4501				var left = t.d;
4502				var right = t.e;
4503				var $temp$func = func,
4504					$temp$acc = A3(
4505					func,
4506					key,
4507					value,
4508					A3($elm$core$Dict$foldr, func, acc, right)),
4509					$temp$t = left;
4510				func = $temp$func;
4511				acc = $temp$acc;
4512				t = $temp$t;
4513				continue foldr;
4514			}
4515		}
4516	});
4517var $elm$core$Dict$toList = function (dict) {
4518	return A3(
4519		$elm$core$Dict$foldr,
4520		F3(
4521			function (key, value, list) {
4522				return A2(
4523					$elm$core$List$cons,
4524					_Utils_Tuple2(key, value),
4525					list);
4526			}),
4527		_List_Nil,
4528		dict);
4529};
4530var $elm$core$Dict$keys = function (dict) {
4531	return A3(
4532		$elm$core$Dict$foldr,
4533		F3(
4534			function (key, value, keyList) {
4535				return A2($elm$core$List$cons, key, keyList);
4536			}),
4537		_List_Nil,
4538		dict);
4539};
4540var $elm$core$Set$toList = function (_v0) {
4541	var dict = _v0.a;
4542	return $elm$core$Dict$keys(dict);
4543};
4544var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
4545var $elm$core$Array$foldr = F3(
4546	function (func, baseCase, _v0) {
4547		var tree = _v0.c;
4548		var tail = _v0.d;
4549		var helper = F2(
4550			function (node, acc) {
4551				if (node.$ === 'SubTree') {
4552					var subTree = node.a;
4553					return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
4554				} else {
4555					var values = node.a;
4556					return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
4557				}
4558			});
4559		return A3(
4560			$elm$core$Elm$JsArray$foldr,
4561			helper,
4562			A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
4563			tree);
4564	});
4565var $elm$core$Array$toList = function (array) {
4566	return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
4567};
4568var $elm$core$Result$Err = function (a) {
4569	return {$: 'Err', a: a};
4570};
4571var $elm$json$Json$Decode$Failure = F2(
4572	function (a, b) {
4573		return {$: 'Failure', a: a, b: b};
4574	});
4575var $elm$json$Json$Decode$Field = F2(
4576	function (a, b) {
4577		return {$: 'Field', a: a, b: b};
4578	});
4579var $elm$json$Json$Decode$Index = F2(
4580	function (a, b) {
4581		return {$: 'Index', a: a, b: b};
4582	});
4583var $elm$core$Result$Ok = function (a) {
4584	return {$: 'Ok', a: a};
4585};
4586var $elm$json$Json$Decode$OneOf = function (a) {
4587	return {$: 'OneOf', a: a};
4588};
4589var $elm$core$Basics$False = {$: 'False'};
4590var $elm$core$Basics$add = _Basics_add;
4591var $elm$core$Maybe$Just = function (a) {
4592	return {$: 'Just', a: a};
4593};
4594var $elm$core$Maybe$Nothing = {$: 'Nothing'};

4595var $elm$core$String$all = _String_all;
4596var $elm$core$Basics$and = _Basics_and;
4597var $elm$core$Basics$append = _Utils_append;
4598var $elm$json$Json$Encode$encode = _Json_encode;
4599var $elm$core$String$fromInt = _String_fromNumber;
4600var $elm$core$String$join = F2(
4601	function (sep, chunks) {
4602		return A2(
4603			_String_join,
4604			sep,
4605			_List_toArray(chunks));
4606	});
4607var $elm$core$String$split = F2(
4608	function (sep, string) {
4609		return _List_fromArray(
4610			A2(_String_split, sep, string));
4611	});
4612var $elm$json$Json$Decode$indent = function (str) {
4613	return A2(
4614		$elm$core$String$join,
4615		'\n    ',
4616		A2($elm$core$String$split, '\n', str));
4617};
4618var $elm$core$List$foldl = F3(
4619	function (func, acc, list) {
4620		foldl:
4621		while (true) {
4622			if (!list.b) {
4623				return acc;
4624			} else {
4625				var x = list.a;
4626				var xs = list.b;
4627				var $temp$func = func,
4628					$temp$acc = A2(func, x, acc),
4629					$temp$list = xs;
4630				func = $temp$func;
4631				acc = $temp$acc;
4632				list = $temp$list;
4633				continue foldl;
4634			}
4635		}
4636	});
4637var $elm$core$List$length = function (xs) {
4638	return A3(
4639		$elm$core$List$foldl,
4640		F2(
4641			function (_v0, i) {
4642				return i + 1;
4643			}),
4644		0,
4645		xs);
4646};
4647var $elm$core$List$map2 = _List_map2;
4648var $elm$core$Basics$le = _Utils_le;
4649var $elm$core$Basics$sub = _Basics_sub;
4650var $elm$core$List$rangeHelp = F3(
4651	function (lo, hi, list) {
4652		rangeHelp:
4653		while (true) {
4654			if (_Utils_cmp(lo, hi) < 1) {
4655				var $temp$lo = lo,
4656					$temp$hi = hi - 1,
4657					$temp$list = A2($elm$core$List$cons, hi, list);
4658				lo = $temp$lo;
4659				hi = $temp$hi;
4660				list = $temp$list;
4661				continue rangeHelp;
4662			} else {
4663				return list;
4664			}
4665		}
4666	});
4667var $elm$core$List$range = F2(
4668	function (lo, hi) {
4669		return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
4670	});
4671var $elm$core$List$indexedMap = F2(
4672	function (f, xs) {
4673		return A3(
4674			$elm$core$List$map2,
4675			f,
4676			A2(
4677				$elm$core$List$range,
4678				0,
4679				$elm$core$List$length(xs) - 1),
4680			xs);
4681	});
4682var $elm$core$Char$toCode = _Char_toCode;
4683var $elm$core$Char$isLower = function (_char) {
4684	var code = $elm$core$Char$toCode(_char);
4685	return (97 <= code) && (code <= 122);
4686};
4687var $elm$core$Char$isUpper = function (_char) {
4688	var code = $elm$core$Char$toCode(_char);
4689	return (code <= 90) && (65 <= code);
4690};
4691var $elm$core$Basics$or = _Basics_or;
4692var $elm$core$Char$isAlpha = function (_char) {
4693	return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
4694};
4695var $elm$core$Char$isDigit = function (_char) {
4696	var code = $elm$core$Char$toCode(_char);
4697	return (code <= 57) && (48 <= code);
4698};
4699var $elm$core$Char$isAlphaNum = function (_char) {
4700	return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
4701};
4702var $elm$core$List$reverse = function (list) {
4703	return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
4704};
4705var $elm$core$String$uncons = _String_uncons;
4706var $elm$json$Json$Decode$errorOneOf = F2(
4707	function (i, error) {
4708		return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
4709			$elm$json$Json$Decode$errorToString(error))));
4710	});
4711var $elm$json$Json$Decode$errorToString = function (error) {
4712	return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
4713};
4714var $elm$json$Json$Decode$errorToStringHelp = F2(
4715	function (error, context) {
4716		errorToStringHelp:
4717		while (true) {
4718			switch (error.$) {
4719				case 'Field':
4720					var f = error.a;
4721					var err = error.b;
4722					var isSimple = function () {
4723						var _v1 = $elm$core$String$uncons(f);
4724						if (_v1.$ === 'Nothing') {
4725							return false;
4726						} else {
4727							var _v2 = _v1.a;
4728							var _char = _v2.a;
4729							var rest = _v2.b;
4730							return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
4731						}
4732					}();
4733					var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
4734					var $temp$error = err,
4735						$temp$context = A2($elm$core$List$cons, fieldName, context);
4736					error = $temp$error;
4737					context = $temp$context;
4738					continue errorToStringHelp;
4739				case 'Index':
4740					var i = error.a;
4741					var err = error.b;
4742					var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
4743					var $temp$error = err,
4744						$temp$context = A2($elm$core$List$cons, indexName, context);
4745					error = $temp$error;
4746					context = $temp$context;
4747					continue errorToStringHelp;
4748				case 'OneOf':
4749					var errors = error.a;
4750					if (!errors.b) {
4751						return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
4752							if (!context.b) {
4753								return '!';
4754							} else {
4755								return ' at json' + A2(
4756									$elm$core$String$join,
4757									'',
4758									$elm$core$List$reverse(context));
4759							}
4760						}();
4761					} else {
4762						if (!errors.b.b) {
4763							var err = errors.a;
4764							var $temp$error = err,
4765								$temp$context = context;
4766							error = $temp$error;
4767							context = $temp$context;
4768							continue errorToStringHelp;
4769						} else {
4770							var starter = function () {
4771								if (!context.b) {
4772									return 'Json.Decode.oneOf';
4773								} else {
4774									return 'The Json.Decode.oneOf at json' + A2(
4775										$elm$core$String$join,
4776										'',
4777										$elm$core$List$reverse(context));
4778								}
4779							}();
4780							var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
4781								$elm$core$List$length(errors)) + ' ways:'));
4782							return A2(
4783								$elm$core$String$join,
4784								'\n\n',
4785								A2(
4786									$elm$core$List$cons,
4787									introduction,
4788									A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
4789						}
4790					}
4791				default:
4792					var msg = error.a;
4793					var json = error.b;
4794					var introduction = function () {
4795						if (!context.b) {
4796							return 'Problem with the given value:\n\n';
4797						} else {
4798							return 'Problem with the value at json' + (A2(
4799								$elm$core$String$join,
4800								'',
4801								$elm$core$List$reverse(context)) + ':\n\n    ');
4802						}
4803					}();
4804					return introduction + ($elm$json$Json$Decode$indent(
4805						A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
4806			}
4807		}
4808	});
4809var $elm$core$Array$branchFactor = 32;
4810var $elm$core$Array$Array_elm_builtin = F4(
4811	function (a, b, c, d) {

4812		return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};
4813	});
4814var $elm$core$Elm$JsArray$empty = _JsArray_empty;
4815var $elm$core$Basics$ceiling = _Basics_ceiling;
4816var $elm$core$Basics$fdiv = _Basics_fdiv;
4817var $elm$core$Basics$logBase = F2(
4818	function (base, number) {
4819		return _Basics_log(number) / _Basics_log(base);
4820	});
4821var $elm$core$Basics$toFloat = _Basics_toFloat;
4822var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
4823	A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
4824var $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);
4825var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
4826var $elm$core$Array$Leaf = function (a) {
4827	return {$: 'Leaf', a: a};
4828};
4829var $elm$core$Basics$apL = F2(
4830	function (f, x) {
4831		return f(x);
4832	});
4833var $elm$core$Basics$apR = F2(
4834	function (x, f) {
4835		return f(x);
4836	});
4837var $elm$core$Basics$eq = _Utils_equal;
4838var $elm$core$Basics$floor = _Basics_floor;
4839var $elm$core$Elm$JsArray$length = _JsArray_length;
4840var $elm$core$Basics$gt = _Utils_gt;
4841var $elm$core$Basics$max = F2(
4842	function (x, y) {
4843		return (_Utils_cmp(x, y) > 0) ? x : y;
4844	});
4845var $elm$core$Basics$mul = _Basics_mul;
4846var $elm$core$Array$SubTree = function (a) {
4847	return {$: 'SubTree', a: a};
4848};
4849var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
4850var $elm$core$Array$compressNodes = F2(
4851	function (nodes, acc) {
4852		compressNodes:
4853		while (true) {
4854			var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
4855			var node = _v0.a;
4856			var remainingNodes = _v0.b;
4857			var newAcc = A2(
4858				$elm$core$List$cons,
4859				$elm$core$Array$SubTree(node),
4860				acc);
4861			if (!remainingNodes.b) {
4862				return $elm$core$List$reverse(newAcc);
4863			} else {
4864				var $temp$nodes = remainingNodes,
4865					$temp$acc = newAcc;
4866				nodes = $temp$nodes;
4867				acc = $temp$acc;
4868				continue compressNodes;
4869			}
4870		}
4871	});
4872var $elm$core$Tuple$first = function (_v0) {
4873	var x = _v0.a;
4874	return x;
4875};
4876var $elm$core$Array$treeFromBuilder = F2(
4877	function (nodeList, nodeListSize) {
4878		treeFromBuilder:
4879		while (true) {
4880			var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
4881			if (newNodeSize === 1) {
4882				return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
4883			} else {
4884				var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
4885					$temp$nodeListSize = newNodeSize;
4886				nodeList = $temp$nodeList;
4887				nodeListSize = $temp$nodeListSize;
4888				continue treeFromBuilder;
4889			}
4890		}
4891	});
4892var $elm$core$Array$builderToArray = F2(
4893	function (reverseNodeList, builder) {
4894		if (!builder.nodeListSize) {
4895			return A4(
4896				$elm$core$Array$Array_elm_builtin,
4897				$elm$core$Elm$JsArray$length(builder.tail),
4898				$elm$core$Array$shiftStep,
4899				$elm$core$Elm$JsArray$empty,
4900				builder.tail);
4901		} else {
4902			var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;
4903			var depth = $elm$core$Basics$floor(
4904				A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
4905			var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;
4906			var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);
4907			return A4(
4908				$elm$core$Array$Array_elm_builtin,
4909				$elm$core$Elm$JsArray$length(builder.tail) + treeLen,
4910				A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
4911				tree,
4912				builder.tail);
4913		}
4914	});
4915var $elm$core$Basics$idiv = _Basics_idiv;
4916var $elm$core$Basics$lt = _Utils_lt;
4917var $elm$core$Array$initializeHelp = F5(
4918	function (fn, fromIndex, len, nodeList, tail) {
4919		initializeHelp:
4920		while (true) {
4921			if (fromIndex < 0) {
4922				return A2(
4923					$elm$core$Array$builderToArray,
4924					false,
4925					{nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});
4926			} else {
4927				var leaf = $elm$core$Array$Leaf(
4928					A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
4929				var $temp$fn = fn,
4930					$temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
4931					$temp$len = len,
4932					$temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
4933					$temp$tail = tail;
4934				fn = $temp$fn;
4935				fromIndex = $temp$fromIndex;
4936				len = $temp$len;
4937				nodeList = $temp$nodeList;
4938				tail = $temp$tail;
4939				continue initializeHelp;
4940			}
4941		}
4942	});
4943var $elm$core$Basics$remainderBy = _Basics_remainderBy;
4944var $elm$core$Array$initialize = F2(
4945	function (len, fn) {
4946		if (len <= 0) {
4947			return $elm$core$Array$empty;
4948		} else {
4949			var tailLen = len % $elm$core$Array$branchFactor;
4950			var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tail

4950Len, fn);
4951			var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
4952			return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
4953		}
4954	});
4955var $elm$core$Basics$True = {$: 'True'};
4956var $elm$core$Result$isOk = function (result) {
4957	if (result.$ === 'Ok') {
4958		return true;
4959	} else {
4960		return false;
4961	}
4962};
4963var $elm$json$Json$Decode$map = _Json_map1;
4964var $elm$json$Json$Decode$map2 = _Json_map2;
4965var $elm$json$Json$Decode$succeed = _Json_succeed;
4966var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
4967	switch (handler.$) {
4968		case 'Normal':
4969			return 0;
4970		case 'MayStopPropagation':
4971			return 1;
4972		case 'MayPreventDefault':
4973			return 2;
4974		default:
4975			return 3;
4976	}
4977};
4978var $elm$browser$Browser$External = function (a) {
4979	return {$: 'External', a: a};
4980};
4981var $elm$browser$Browser$Internal = function (a) {
4982	return {$: 'Internal', a: a};
4983};
4984var $elm$core$Basics$identity = function (x) {
4985	return x;
4986};
4987var $elm$browser$Browser$Dom$NotFound = function (a) {
4988	return {$: 'NotFound', a: a};
4989};
4990var $elm$url$Url$Http = {$: 'Http'};
4991var $elm$url$Url$Https = {$: 'Https'};
4992var $elm$url$Url$Url = F6(
4993	function (protocol, host, port_, path, query, fragment) {
4994		return {fragment: fragment, host: host, path: path, port_: port_, protocol: protocol, query: query};
4995	});
4996var $elm$core$String$contains = _String_contains;
4997var $elm$core$String$length = _String_length;
4998var $elm$core$String$slice = _String_slice;
4999var $elm$core$String$dropLeft = F2(
5000	function (n, string) {
5001		return (n < 1) ? string : A3(
5002			$elm$core$String$slice,
5003			n,
5004			$elm$core$String$length(string),
5005			string);
5006	});
5007var $elm$core$String$indexes = _String_indexes;
5008var $elm$core$String$isEmpty = function (string) {
5009	return string === '';
5010};
5011var $elm$core$String$left = F2(
5012	function (n, string) {
5013		return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string);
5014	});
5015var $elm$core$String$toInt = _String_toInt;
5016var $elm$url$Url$chompBeforePath = F5(
5017	function (protocol, path, params, frag, str) {
5018		if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) {
5019			return $elm$core$Maybe$Nothing;
5020		} else {
5021			var _v0 = A2($elm$core$String$indexes, ':', str);
5022			if (!_v0.b) {
5023				return $elm$core$Maybe$Just(
5024					A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag));
5025			} else {
5026				if (!_v0.b.b) {
5027					var i = _v0.a;
5028					var _v1 = $elm$core$String$toInt(
5029						A2($elm$core$String$dropLeft, i + 1, str));
5030					if (_v1.$ === 'Nothing') {
5031						return $elm$core$Maybe$Nothing;
5032					} else {
5033						var port_ = _v1;
5034						return $elm$core$Maybe$Just(
5035							A6(
5036								$elm$url$Url$Url,
5037								protocol,
5038								A2($elm$core$String$left, i, str),
5039								port_,
5040								path,
5041								params,
5042								frag));
5043					}
5044				} else {
5045					return $elm$core$Maybe$Nothing;
5046				}
5047			}
5048		}
5049	});
5050var $elm$url$Url$chompBeforeQuery = F4(
5051	function (protocol, params, frag, str) {
5052		if ($elm$core$String$isEmpty(str)) {
5053			return $elm$core$Maybe$Nothing;
5054		} else {
5055			var _v0 = A2($elm$core$String$indexes, '/', str);
5056			if (!_v0.b) {
5057				return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
5058			} else {
5059				var i = _v0.a;
5060				return A5(
5061					$elm$url$Url$chompBeforePath,
5062					protocol,
5063					A2($elm$core$String$dropLeft, i, str),
5064					params,
5065					frag,
5066					A2($elm$core$String$left, i, str));
5067			}
5068		}
5069	});
5070var $elm$url$Url$chompBeforeFragment = F3(
5071	function (protocol, frag, str) {
5072		if ($elm$core$String$isEmpty(str)) {
5073			return $elm$core$Maybe$Nothing;
5074		} else {
5075			var _v0 = A2($elm$core$String$indexes, '?', str);
5076			if (!_v0.b) {
5077				return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str);
5078			} else {
5079				var i = _v0.a;
5080				return A4(
5081					$elm$url$Url$chompBeforeQuery,
5082					protocol,
5083					$elm$core$Maybe$Just(
5084						A2($elm$core$String$dropLeft, i + 1, str)),
5085					frag,
5086					A2($elm$core$String$left, i, str));
5087			}
5088		}
5089	});
5090var $elm$url$Url$chompAfterProtocol = F2(
5091	function (protocol, str) {
5092		if ($elm$core$String$isEmpty(str)) {
5093			return $elm$core$Maybe$Nothing;
5094		} else {
5095			var _v0 = A2($elm$core$String$indexes, '#', str);
5096			if (!_v0.b) {
5097				return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str);
5098			} else {
5099				var i = _v0.a;
5100				return A3(
5101					$elm$url$Url$chompBeforeFragment,
5102					protocol,
5103					$elm$core$Maybe$Just(
5104						A2($elm$core$String$dropLeft, i + 1, str)),
5105					A2($elm$core$String$left, i, str));
5106			}
5107		}
5108	});
5109var $elm$core$String$startsWith = _String_startsWith;
5110var $elm$url$Url$fromString = function (str) {
5111	return A2($elm$core$String$startsWith, 'http://', str) ? A2(
5112		$elm$url$Url$chompAfterProtocol,
5113		$elm$url$Url$Http,
5114		A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2(
5115		$elm$url$Url$chompAfterProtocol,
5116		$elm$url$Url$Https,
5117		A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing);
5118};
5119var $elm$core$Basics$never = function (_v0) {
5120	never:
5121	while (true) {
5122		var nvr = _v0.a;
5123		var $temp$_v0 = nvr;
5124		_v0 = $temp$_v0;
5125		continue never;
5126	}
5127};
5128var $elm$core$Task$Perform = function (a) {
5129	return {$: 'Perform', a: a};
5130};
5131var $elm$core$Task$succeed = _Scheduler_succeed;
5132var $elm$core$Task$init = $elm$core$Task$succeed(_Utils_Tuple0);
5133var $elm$core$List$foldrHelper = F4(
5134	function (fn, acc, ctr, ls) {
5135		if (!ls.b) {
5136			return acc;
5137		} else {
5138			var a = ls.a;
5139			var r1 = ls.b;
5140			if (!r1.b) {
5141				return A2(fn, a, acc);
5142			} else {
5143				var b = r1.a;
5144				var r2 = r1.b;
5145				if (!r2.b) {
5146					return A2(
5147						fn,
5148						a,
5149						A2(fn, b, acc));
5150				} else {
5151					var c = r2.a;
5152					var r3 = r2.b;
5153					if (!r3.b) {
5154						return A2(
5155							fn,
5156							a,
5157							A2(
5158								fn,
5159								b,
5160								A2(fn, c, acc)));
5161					} else {
5162						var d = r3.a;
5163						var r4 = r3.b;
5164						var res = (ctr > 500) ? A3(
5165							$elm$core$List$foldl,
5166							fn,
5167							acc,
5168							$elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
5169						return A2(
5170							fn,
5171							a,
5172							A2(
5173								fn,
5174								b,
5175								A2(
5176									fn,
5177									c,
5178									A2(fn, d, res))));
5179					}
5180				}
5181			}
5182		}
5183	});
5184var $elm$core$List$foldr = F3(
5185	function (fn, acc, ls) {
5186		return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
5187	});
5188var $elm$core$List$map = F2(
5189	function (f, xs) {
5190		return A3(
5191			$elm$core$List$foldr,
5192			F2(
5193				function (x, acc) {
5194					return A2(
5195						$elm$core$List$cons,
5196						f(x),
5197						acc);
5198				}),
5199			_List_Nil,
5200			xs);
5201	});
5202var $elm$core$Task$andThen = _Scheduler_andThen;
5203var $elm$core$Task$map = F2(
5204	function (func, taskA) {
5205		return A2(
5206			$elm$core$Task$andThen,
5207			function (a) {
5208				return $elm$core$Task$succeed(
5209					func(a));
5210			},
5211			taskA);
5212	});
5213var $elm$core$Task$map2 = F3(
5214	function (func, taskA, taskB) {
5215		return A2(
5216			$elm$core$Task$andThen,
5217			function (a) {
5218				return A2(
5219					$elm$core$Task$andThen,
5220					function (b) {
5221						return $elm$core$Task$succeed(
5222							A2(func, a, b));
5223					},
5224					taskB);
5225			},
5226			taskA);
5227	});
5228var $elm$core$Task$sequence = function (tasks) {
5229	return A3(
5230		$elm$core$List$foldr,
5231		$elm$core$Task$map2($elm$core$List$cons),
5232		$elm$core$Task$succeed(_List_Nil),
5233		tasks);
5234};
5235var $elm$core$Platform$sendToApp = _Platform_sendToApp;
5236var $elm$core$Task$spawnCmd = F2(

5237	function (router, _v0) {
5238		var task = _v0.a;
5239		return _Scheduler_spawn(
5240			A2(
5241				$elm$core$Task$andThen,
5242				$elm$core$Platform$sendToApp(router),
5243				task));
5244	});
5245var $elm$core$Task$onEffects = F3(
5246	function (router, commands, state) {
5247		return A2(
5248			$elm$core$Task$map,
5249			function (_v0) {
5250				return _Utils_Tuple0;
5251			},
5252			$elm$core$Task$sequence(
5253				A2(
5254					$elm$core$List$map,
5255					$elm$core$Task$spawnCmd(router),
5256					commands)));
5257	});
5258var $elm$core$Task$onSelfMsg = F3(
5259	function (_v0, _v1, _v2) {
5260		return $elm$core$Task$succeed(_Utils_Tuple0);
5261	});
5262var $elm$core$Task$cmdMap = F2(
5263	function (tagger, _v0) {
5264		var task = _v0.a;
5265		return $elm$core$Task$Perform(
5266			A2($elm$core$Task$map, tagger, task));
5267	});
5268_Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap);
5269var $elm$core$Task$command = _Platform_leaf('Task');
5270var $elm$core$Task$perform = F2(
5271	function (toMessage, task) {
5272		return $elm$core$Task$command(
5273			$elm$core$Task$Perform(
5274				A2($elm$core$Task$map, toMessage, task)));
5275	});
5276var $elm$browser$Browser$element = _Browser_element;
5277var $elm$core$Platform$Cmd$batch = _Platform_batch;
5278var $author$project$MainCupnakyma$CupMatchData = F2(
5279	function (admin, cup_match_data) {
5280		return {admin: admin, cup_match_data: cup_match_data};
5281	});
5282var $elm$json$Json$Decode$bool = _Json_decodeBool;
5283var $author$project$MainCupnakyma$CupMatchItem = function (kilpailu_id) {
5284	return function (luokka) {
5285		return function (ottelu_id) {
5286			return function (koti_id) {
5287				return function (koti_nimi) {
5288					return function (koti_seura) {
5289						return function (koti_rating) {
5290							return function (koti2_id) {
5291								return function (koti2_nimi) {
5292									return function (koti2_seura) {
5293										return function (koti2_rating) {
5294											return function (vieras_id) {
5295												return function (vieras_nimi) {
5296													return function (vieras_seura) {
5297														return function (vieras_rating) {
5298															return function (vieras2_id) {
5299																return function (vieras2_nimi) {
5300																	return function (vieras2_seura) {
5301																		return function (vieras2_rating) {
5302																			return function (kotijoukkue) {
5303																				return function (vierasjoukkue) {
5304																					return function (era1) {
5305																						return function (era2) {
5306																							return function (era3) {
5307																								return function (era4) {
5308																									return function (era5) {
5309																										return function (era6) {
5310																											return function (era7) {
5311																												return function (era8) {
5312																													return function (era9) {
5313																														return function (koti_erat) {
5314																															return function (vieras_erat) {
5315																																return function (voittaja) {
5316																																	return function (voittotyyppi) {
5317																																		return function (voittajan_jatko_id) {
5318																																			return function (voittajan_jatko_cup) {
5319																																				return function (voittajan_jatko_koti) {
5320																																					return function (haviajan_jatko_id) {
5321																																						return function (haviajan_jatko_cup) {
5322																																							return function (haviajan_jatko_koti) {
5323																																								return function (poolista_koti) {
5324																																									return function (poolisijalta_koti) {
5325																																										return function (poolista_vieras) {
5326																																											return function (poolisijalta_vieras) {
5327																																												return function (ottelu_id_cupissa) {
5328																																													return function (cup_id) {
5329																																														return {cup_id: cup_id, era1: era1, era2: era2, era3: era3, era4: era4, era5: era5, era6: era6, era7: era7, era8: era8, era9: era9, haviajan_jatko_cup: haviajan_jatko_cup, haviajan_jatko_id: haviajan_jatko_id, haviajan_jatko_koti: havi

5329ajan_jatko_koti, kilpailu_id: kilpailu_id, koti2_id: koti2_id, koti2_nimi: koti2_nimi, koti2_rating: koti2_rating, koti2_seura: koti2_seura, koti_erat: koti_erat, koti_id: koti_id, koti_nimi: koti_nimi, koti_rating: koti_rating, koti_seura: koti_seura, kotijoukkue: kotijoukkue, luokka: luokka, ottelu_id: ottelu_id, ottelu_id_cupissa: ottelu_id_cupissa, poolisijalta_koti: poolisijalta_koti, poolisijalta_vieras: poolisijalta_vieras, poolista_koti: poolista_koti, poolista_vieras: poolista_vieras, vieras2_id: vieras2_id, vieras2_nimi: vieras2_nimi, vieras2_rating: vieras2_rating, vieras2_seura: vieras2_seura, vieras_erat: vieras_erat, vieras_id: vieras_id, vieras_nimi: vieras_nimi, vieras_rating: vieras_rating, vieras_seura: vieras_seura, vierasjoukkue: vierasjoukkue, voittaja: voittaja, voittajan_jatko_cup: voittajan_jatko_cup, voittajan_jatko_id: voittajan_jatko_id, voittajan_jatko_koti: voittajan_jatko_koti, voittotyyppi: voittotyyppi};
5330																																													};
5331																																												};
5332																																											};
5333																																										};
5334																																									};
5335																																								};
5336																																							};
5337																																						};
5338																																					};
5339																																				};
5340																																			};
5341																																		};
5342																																	};
5343																																};
5344																															};
5345																														};
5346																													};
5347																												};
5348																											};
5349																										};
5350																									};
5351																								};
5352																							};
5353																						};
5354																					};
5355																				};
5356																			};
5357																		};
5358																	};
5359																};
5360															};
5361														};
5362													};
5363												};
5364											};
5365										};
5366									};
5367								};
5368							};
5369						};
5370					};
5371				};
5372			};
5373		};
5374	};
5375};
5376var $elm$json$Json$Decode$int = _Json_decodeInt;
5377var $NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$custom = $elm$json$Json$Decode$map2($elm$core$Basics$apR);
5378var $elm$json$Json$Decode$andThen = _Json_andThen;
5379var $elm$json$Json$Decode$field = _Json_decodeField;
5380var $elm$json$Json$Decode$at = F2(
5381	function (fields, decoder) {
5382		return A3($elm$core$List$foldr, $elm$json$Json$Decode$field, decoder, fields);
5383	});
5384var $elm$json$Json$Decode$decodeValue = _Json_run;
5385var $elm$json$Json$Decode$null = _Json_decodeNull;
5386var $elm$json$Json$Decode$oneOf = _Json_oneOf;
5387var $elm$json$Json$Decode$value = _Json_decodeValue;
5388var $NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optionalDecoder = F3(
5389	function (path, valDecoder, fallback) {
5390		var nullOr = function (decoder) {
5391			return $elm$json$Json$Decode$oneOf(
5392				_List_fromArray(
5393					[
5394						decoder,
5395						$elm$json$Json$Decode$null(fallback)
5396					]));
5397		};
5398		var handleResult = function (input) {
5399			var _v0 = A2(
5400				$elm$json$Json$Decode$decodeValue,
5401				A2($elm$json$Json$Decode$at, path, $elm$json$Json$Decode$value),
5402				input);
5403			if (_v0.$ === 'Ok') {
5404				var rawValue = _v0.a;
5405				var _v1 = A2(
5406					$elm$json$Json$Decode$decodeValue,
5407					nullOr(valDecoder),
5408					rawValue);
5409				if (_v1.$ === 'Ok') {
5410					var finalResult = _v1.a;
5411					return $elm$json$Json$Decode$succeed(finalResult);
5412				} else {
5413					return A2(
5414						$elm$json$Json$Decode$at,
5415						path,
5416						nullOr(valDecoder));
5417				}
5418			} else {
5419				return $elm$json$Json$Decode$succeed(fallback);
5420			}
5421		};
5422		return A2($elm$json$Json$Decode$andThen, handleResult, $elm$json$Json$Decode$value);
5423	});
5424var $NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optional = F4(
5425	function (key, valDecoder, fallback, decoder) {
5426		return A2(
5427			$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$custom,
5428			A3(
5429				$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optionalDecoder,
5430				_List_fromArray(
5431					[key]),
5432				valDecoder,
5433				fallback),
5434			decoder);
5435	});
5436var $NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required = F3(
5437	function (key, valDecoder, decoder) {
5438		return A2(

5439			$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$custom,
5440			A2($elm$json$Json$Decode$field, key, valDecoder),
5441			decoder);
5442	});
5443var $elm$json$Json$Decode$string = _Json_decodeString;
5444var $author$project$MainCupnakyma$cupMatchItemDecoder = A3(
5445	$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5446	'cup_id',
5447	$elm$json$Json$Decode$string,
5448	A3(
5449		$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5450		'ottelu_id_cupissa',
5451		$elm$json$Json$Decode$int,
5452		A3(
5453			$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5454			'poolisijalta_vieras',
5455			$elm$json$Json$Decode$int,
5456			A3(
5457				$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5458				'poolista_vieras',
5459				$elm$json$Json$Decode$string,
5460				A3(
5461					$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5462					'poolisijalta_koti',
5463					$elm$json$Json$Decode$int,
5464					A3(
5465						$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5466						'poolista_koti',
5467						$elm$json$Json$Decode$string,
5468						A3(
5469							$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5470							'haviajan_jatko_koti',
5471							$elm$json$Json$Decode$string,
5472							A3(
5473								$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5474								'haviajan_jatko_cup',
5475								$elm$json$Json$Decode$string,
5476								A3(
5477									$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5478									'haviajan_jatko_id',
5479									$elm$json$Json$Decode$int,
5480									A3(
5481										$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5482										'voittajan_jatko_koti',
5483										$elm$json$Json$Decode$string,
5484										A3(
5485											$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5486											'voittajan_jatko_cup',
5487											$elm$json$Json$Decode$string,
5488											A3(
5489												$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5490												'voittajan_jatko_id',
5491												$elm$json$Json$Decode$int,
5492												A3(
5493													$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5494													'voittotyyppi',
5495													$elm$json$Json$Decode$string,
5496													A3(
5497														$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5498														'voittaja',
5499														$elm$json$Json$Decode$string,
5500														A3(
5501															$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5502															'vieras_erat',
5503															$elm$json$Json$Decode$int,
5504															A3(
5505																$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5506																'koti_erat',
5507																$elm$json$Json$Decode$int,
5508																A3(
5509																	$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5510																	'era9',
5511																	$elm$json$Json$Decode$string,
5512																	A3(
5513																		$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5514																		'era8',
5515																		$elm$json$Json$Decode$string,
5516																		A3(
5517																			$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5518																			'era7',
5519																			$elm$json$Json$Decode$string,
5520																			A3(
5521																				$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5522																				'era6',
5523																				$elm$json$Json$Decode$string,
5524																				A3(
5525																					$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5526																					'era5',
5527																					$elm$json$Json$Decode$string,
5528																					A3(
5529																						$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5530																						'era4',
5531																						$elm$json$Json$Decode$string,
5532																						A3(
5533																							$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5534																							'era3',
5535																							$elm$json$Json$Decode$string,
5536																							A3(
5537																								$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5538																								'era2',
5539																								$elm$json$Json$Decode$string,
5540																								A3(
5541																									$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5542																									'era1',
5543																									$elm$json$Json$Decode$string,
5544																									A4(
5545																										$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optional,
5546																										'vierasjoukkue',
5547																										$elm$json$Json$Decode$string,
5548																										'',
5549																										A4(
5550																											$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optional,
5551																											'kotijoukkue',
5552																											$elm$json$Json$Decode$string,
5553																											'',
5554																											A4(
5555																												$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optional,
5556																												'vieras2_rating',
5557																												$elm$json$Json$Decode$int,
5558																												0,
5559																												A3(
5560																													$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5561																													'vieras2_seura',
5562																													$elm$json$Json$Decode$string,
5563																													A3(
5564																														$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5565																														'vieras2_nimi',
5566																														$elm$json$Json$Decode$string,
5567																														A3(
5568																															$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5569																															'vieras2_id',
5570																															$elm$json$Json$Decode$string,
5571																															A4(
5572																																$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optional,
5573																																'vieras_rating',
5574																																$elm$json$Json$Decode$int,
5575																																0,
5576																																A3(
5577																																	$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5578																																	'vieras_seura',
5579																																	$elm$json$Json$Decode$string,
5580																																	A3(
5581																																		$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5582																																		'vieras_nimi',
5583																																		$elm$json$Json$Decode$string,
5584																																		A3(
5585																																			$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5586																																			'vieras_id',
5587																																			$elm$json$Json$Decode$string,
5588																																			A4(
5589																																				$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optional,
5590																																				'koti2_rating',
5591																																				$elm$json$Json$Decode$int,
5592																																				0,
5593																																				A3(
5594																																					$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5595																																					'koti2_seura',
5596																																					$elm$json$Json$Decode$string,
5597																																					A3(
5598																																						$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5599																																						'koti2_nimi',
5600																																						$elm$json$Json$Decode$string,
5601																																						A3(
5602																																							$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5603																																							'koti2_id',
5604																																							$elm$json$Json$Decode$string,
5605																																							A4(
5606																																								$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$optional,
5607																																								'koti_rating',
5608																																								$elm$json$Json$Decode$int,
5609																																								0,
5610																																								A3(
5611																																									$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5612																																									'koti_seura',
5613																																									$elm$json$Json$Decode$string,
5614																																									A3(
5615																																										$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5616																																										'koti_nimi',
5617																																										$elm$json$Json$Decode$string,
5618																																										A3(
5619																																											$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5620																																											'koti_id',
5621																																											$elm$json$Json$Decode$string,
5622																																											A3(
5623																																												$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5624																																												'ottelu_id',
5625																																												$elm$json$Json$Decode$int,
5626																																												A3(
5627																																													$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5628																																													'luokka',
5629																																													$elm$json$Json$Decode$string,
5630																																													A3(
5631																																														$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5632																																														'kilpailu_id',
5633																																														$elm$json$Json$Decode$int,
5634																																														$elm$json$Json$Decode$succeed($author$project$MainCupnakyma$CupMatchItem)))))))))))))))))))))))))))))))))))))))))))))));
5635var $elm$json$Json$Decode$list = _Json_decodeList;
5636var $author$project$MainCupnakyma$cupMatchDataDecoder = A3(
5637	$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5638	'cupin_ottelut',
5639	$elm$json$Json$Decode$list($author$project$MainCupnakyma$cupMatchItemDecoder),
5640	A3(
5641		$NoRedInk$elm_json_decode_pipeline$Json$Decode$Pipeline$required,
5642		'admin',
5643		$elm$json$Json$Decode$bool,
5644		$elm$json$Json$Decode$succeed($author$project$MainCupnakyma$CupMatchData)));
5645var $elm$json$Json$Decode$decodeString = _Json_runOnString;
5646var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
5647var $author$project$MainCupnakyma$init = function (input) {
5648	var _v0 = A2($elm$json$Json$Decode$decodeString, $author$project$MainCupnakyma$cupMatchDataDecoder, input);
5649	if (_v0.$ === 'Ok') {
5650		var cup_data = _v0.a;
5651		return _Utils_Tuple2(
5652			{admin: cup_data.admin, cupMatches: cup_data.cup_match_data, message: input},
5653			$elm$core$Platform$Cmd$batch(
5654				_List_fromArray(
5655					[$elm$core$Platform$Cmd$none])));
5656	} else {
5657		var err = _v0.a;
5658		return _Utils_Tuple2(
5659			{
5660				admin: false,
5661				cupMatches: _List_Nil,
5662				message: 'Parse error:' + $elm$json$Json$Decode$errorToString(err)
5663			},
5664			$elm$core$Platform$Cmd$batch(
5665				_List_fromArray(
5666					[$elm$core$Platform$Cmd$none])));
5667	}
5668};
5669var $elm$core$Platform$Sub$batch = _Platform_batch;
5670var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
5671var $author$project$MainCupnakyma$subscriptions = function (_v0) {
5672	return $elm$core$Platform$Sub$none;
5673};
5674var $author$project$MainCupnakyma$emptyModel = {admin: false, cupMatches: _List_Nil, message: ''};
5675var $author$project$MainCupnakyma$update = F2(
5676	function (msg, model) {
5677		return _Utils_Tuple2($author$project$MainCupnakyma$emptyModel, $elm$core$Platform$Cmd$none);
5678	});
5679var $elm$core$Basics$neq = _Utils_notEqual;
5680var $author$project$MainCupnakyma$allPoolsPlayed = function (cupMatches) {
5681	allPoolsPlayed:
5682	while (true) {
5683		if (!cupMatches.b) {
5684			return true;
5685		} else {
5686			var cmi = cupMatches.a;
5687			var cmis = cupMatches.b;
5688			if (((cmi.koti_id === '') && ((cmi.kotijoukkue === '') && (cmi.poolista_koti !== ''))) || ((cmi.vieras_id === '') && ((cmi.vierasjoukkue === '') && (cmi.poolista_vieras !== '')))) {
5689				return false;

5690			} else {
5691				var $temp$cupMatches = cmis;
5692				cupMatches = $temp$cupMatches;
5693				continue allPoolsPlayed;
5694			}
5695		}
5696	}
5697};
5698var $author$project$MainCupnakyma$getColNext = F2(
5699	function (colNo, s) {
5700		if (colNo === 1) {
5701			return '';
5702		} else {
5703			var _v0 = $elm$core$String$uncons(s);
5704			if (_v0.$ === 'Nothing') {
5705				return ' border-bottom: none;\" >';
5706			} else {
5707				var _v1 = _v0.a;
5708				var x = _v1.a;
5709				var xs = _v1.b;
5710				return _Utils_eq(
5711					x,
5712					_Utils_chr('<')) ? ' border-bottom: 1px solid black;\" >' : ' border-bottom: none;\" >';
5713			}
5714		}
5715	});
5716var $elm$core$Basics$modBy = _Basics_modBy;
5717var $elm$core$Basics$ge = _Utils_ge;
5718var $elm$core$Basics$pow = _Basics_pow;
5719var $author$project$MainCupnakyma$test_vertical_line = F3(
5720	function (row, col, k) {
5721		test_vertical_line:
5722		while (true) {
5723			if (_Utils_cmp(
5724				(A2($elm$core$Basics$pow, 2, col - 1) + 1) + (k * A2($elm$core$Basics$pow, 2, col + 1)),
5725				row) > 0) {
5726				return false;
5727			} else {
5728				if ((_Utils_cmp(
5729					row,
5730					(A2($elm$core$Basics$pow, 2, col - 1) + 1) + (k * A2($elm$core$Basics$pow, 2, col + 1))) > -1) && (_Utils_cmp(
5731					row,
5732					(((A2($elm$core$Basics$pow, 2, col - 1) + 1) + (k * A2($elm$core$Basics$pow, 2, col + 1))) + A2($elm$core$Basics$pow, 2, col)) - 1) < 1)) {
5733					return true;
5734				} else {
5735					var $temp$row = row,
5736						$temp$col = col,
5737						$temp$k = k + 1;
5738					row = $temp$row;
5739					col = $temp$col;
5740					k = $temp$k;
5741					continue test_vertical_line;
5742				}
5743			}
5744		}
5745	});
5746var $author$project$MainCupnakyma$vertical_line = F2(
5747	function (row, col) {
5748		return A3($author$project$MainCupnakyma$test_vertical_line, row, col - 1, 0);
5749	});
5750var $author$project$MainCupnakyma$getColStart = F2(
5751	function (rowNo, colNo) {
5752		return ((colNo === 1) && ((A2($elm$core$Basics$modBy, 4, rowNo) === 1) || (A2($elm$core$Basics$modBy, 4, rowNo) === 2))) ? '<td width = \"300\" style = \"border: 1px solid black; background-color: #C7DBEA; text-align: left;\" >' : (((colNo === 1) && ((A2($elm$core$Basics$modBy, 4, rowNo) === 3) || (!A2($elm$core$Basics$modBy, 4, rowNo)))) ? '<td width = \"300\" style = \"border: 1px solid black; text-align: left;\" >' : ((colNo > 1) ? (A2($author$project$MainCupnakyma$vertical_line, rowNo, colNo) ? '<td width =\"300\" style = \"border-top: none; border-right: 1px solid black; border-left: none;; text-align: left;' : '<td width =\"300\" style = \"border-top: none; border-right: none; border-left: none;; text-align: left;') : ''));
5753	});
5754var $author$project$MainCupnakyma$getCupTableContent = F3(
5755	function (rowNo, colNo, cupStrings) {
5756		getCupTableContent:
5757		while (true) {
5758			if (!cupStrings.b) {
5759				return ' ';
5760			} else {
5761				var _v1 = cupStrings.a;
5762				var r = _v1.a;
5763				var c = _v1.b;
5764				var s = _v1.c;
5765				var cupStrs = cupStrings.b;
5766				if (_Utils_eq(r, rowNo) && _Utils_eq(c, colNo)) {
5767					return s;
5768				} else {
5769					var $temp$rowNo = rowNo,
5770						$temp$colNo = colNo,
5771						$temp$cupStrings = cupStrs;
5772					rowNo = $temp$rowNo;
5773					colNo = $temp$colNo;
5774					cupStrings = $temp$cupStrings;
5775					continue getCupTableContent;
5776				}
5777			}
5778		}
5779	});
5780var $author$project$MainCupnakyma$makeCupHtmlRow = F5(
5781	function (cupStrings, width, height, rowNo, colNo) {
5782		var s = A3($author$project$MainCupnakyma$getCupTableContent, rowNo, colNo, cupStrings);
5783		return (_Utils_cmp(colNo, height) > 0) ? '' : (A2($author$project$MainCupnakyma$getColStart, rowNo, colNo) + (A2($author$project$MainCupnakyma$getColNext, colNo, s) + (s + ('</td>' + A5($author$project$MainCupnakyma$makeCupHtmlRow, cupStrings, width, height, rowNo, colNo + 1)))));
5784	});
5785var $author$project$MainCupnakyma$makeCupHtmlRows = F4(
5786	function (cupStrings, width, height, rowNo) {
5787		return (_Utils_cmp(rowNo, width) > 0) ? '' : _Utils_ap(
5788			'<tr>' + (A5($author$project$MainCupnakyma$makeCupHtmlRow, cupStrings, width, height, rowNo, 1) + '</tr>'),
5789			A4($author$project$MainCupnakyma$makeCupHtmlRows, cupStrings, width, height, rowNo + 1));
5790	});
5791var $author$project$MainCupnakyma$cupString = F3(
5792	function (cupStrings, width, height) {
5793		return '<table>' + (A4($author$project$MainCupnakyma$makeCupHtmlRows, cupStrings, width, height, 1) + '</table>');
5794	});
5795var $author$project$MainCupnakyma$is_joukkuecup = function (ms) {
5796	is_joukkuecup:
5797	while (true) {
5798		if (!ms.b) {
5799			return false;

5800		} else {
5801			var m = ms.a;
5802			var matches = ms.b;
5803			if (m.kotijoukkue !== '') {
5804				return true;
5805			} else {
5806				var $temp$ms = matches;
5807				ms = $temp$ms;
5808				continue is_joukkuecup;
5809			}
5810		}
5811	}
5812};
5813var $author$project$MainCupnakyma$Bye = {$: 'Bye'};
5814var $author$project$MainCupnakyma$CupMatchNode = F3(
5815	function (a, b, c) {
5816		return {$: 'CupMatchNode', a: a, b: b, c: c};
5817	});
5818var $author$project$MainCupnakyma$PoolPos = F3(
5819	function (a, b, c) {
5820		return {$: 'PoolPos', a: a, b: b, c: c};
5821	});
5822var $author$project$MainCupnakyma$PositionedPlayer = function (a) {
5823	return {$: 'PositionedPlayer', a: a};
5824};
5825var $author$project$WelhoCommon$awayPlayer = 'vieras';
5826var $author$project$WelhoCommon$homePlayer = 'koti';
5827var $author$project$MainCupnakyma$findLeftChild = F3(
5828	function (x, inCmis, origCmis) {
5829		findLeftChild:
5830		while (true) {
5831			if (!inCmis.b) {
5832				return (x.poolista_koti !== '') ? A3(
5833					$author$project$MainCupnakyma$PoolPos,
5834					x.poolista_koti,
5835					x.poolisijalta_koti,
5836					_Utils_ap(
5837						x.koti_nimi,
5838						_Utils_ap(
5839							(x.koti2_nimi === '') ? '' : (' ' + x.koti2_nimi),
5840							(x.koti_nimi === '') ? '' : ('/' + (x.koti_seura + (' ' + x.koti2_seura)))))) : (((x.koti_id !== '') || (x.kotijoukkue !== '')) ? $author$project$MainCupnakyma$PositionedPlayer(
5841					{id: x.koti_id, id2: x.koti2_id, joukkue: x.kotijoukkue, nimi: x.koti_nimi, nimi2: x.koti2_nimi, rating: x.koti_rating, rating2: x.koti2_rating, seura: x.koti_seura, seura2: x.koti2_seura}) : $author$project$MainCupnakyma$Bye);
5842			} else {
5843				var cmi = inCmis.a;
5844				var cmis = inCmis.b;
5845				if (_Utils_eq(cmi.voittajan_jatko_id, x.ottelu_id_cupissa) && _Utils_eq(cmi.voittajan_jatko_koti, $author$project$WelhoCommon$homePlayer)) {
5846					return A3(
5847						$author$project$MainCupnakyma$CupMatchNode,
5848						cmi,
5849						A3($author$project$MainCupnakyma$findLeftChild, cmi, origCmis, origCmis),
5850						A3($author$project$MainCupnakyma$findRightChild, cmi, origCmis, origCmis));
5851				} else {
5852					var $temp$x = x,
5853						$temp$inCmis = cmis,
5854						$temp$origCmis = origCmis;
5855					x = $temp$x;
5856					inCmis = $temp$inCmis;
5857					origCmis = $temp$origCmis;
5858					continue findLeftChild;
5859				}
5860			}
5861		}
5862	});
5863var $author$project$MainCupnakyma$findRightChild = F3(
5864	function (x, inCmis, origCmis) {
5865		findRightChild:
5866		while (true) {
5867			if (!inCmis.b) {
5868				return (x.poolista_vieras !== '') ? A3(
5869					$author$project$MainCupnakyma$PoolPos,
5870					x.poolista_vieras,
5871					x.poolisijalta_vieras,
5872					_Utils_ap(
5873						x.vieras_nimi,
5874						_Utils_ap(
5875							(x.vieras2_nimi === '') ? '' : (' ' + x.vieras2_nimi),
5876							(x.vieras_nimi === '') ? '' : ('/' + (x.vieras_seura + (' ' + x.vieras2_seura)))))) : (((x.vieras_id !== '') || (x.vierasjoukkue !== '')) ? $author$project$MainCupnakyma$PositionedPlayer(
5877					{id: x.vieras_id, id2: x.vieras2_id, joukkue: x.vierasjoukkue, nimi: x.vieras_nimi, nimi2: x.vieras2_nimi, rating: x.vieras_rating, rating2: x.vieras2_rating, seura: x.vieras_seura, seura2: x.vieras2_seura}) : $author$project$MainCupnakyma$Bye);
5878			} else {
5879				var cmi = inCmis.a;
5880				var cmis = inCmis.b;
5881				if (_Utils_eq(cmi.voittajan_jatko_id, x.ottelu_id_cupissa) && _Utils_eq(cmi.voittajan_jatko_koti, $author$project$WelhoCommon$awayPlayer)) {
5882					return A3(
5883						$author$project$MainCupnakyma$CupMatchNode,
5884						cmi,
5885						A3($author$project$MainCupnakyma$findLeftChild, cmi, origCmis, origCmis),
5886						A3($author$project$MainCupnakyma$findRightChild, cmi, origCmis, origCmis));
5887				} else {
5888					var $temp$x = x,
5889						$temp$inCmis = cmis,
5890						$temp$origCmis = origCmis;
5891					x = $temp$x;
5892					inCmis = $temp$inCmis;
5893					origCmis = $temp$origCmis;
5894					continue findRightChild;
5895				}
5896			}
5897		}
5898	});
5899var $author$project$MainCupnakyma$findRoot = F2(
5900	function (inCmis, origCmis) {
5901		findRoot:
5902		while (true) {
5903			if (!inCmis.b) {
5904				return $author$project$MainCupnakyma$Bye;
5905			} else {
5906				var cmi = inCmis.a;
5907				var cmis = inCmis.b;
5908				if (cmi.ottelu_id_cupissa === 1) {
5909					return A3(
5910						$author$project$MainCupnakyma$CupMatchNode,
5911						cmi,
5912						A3($author$project$MainCupnakyma$findLeftChild, cmi, origCmis, origCmis),
5913						A3($author$project$MainCupnakyma$findRightChild, cmi, origCmis, origCmis));
5914				} else {
5915					var $temp$inCmis = inCmis,
5916						$temp$origCmis = origCmis;
5917					inCmis = $temp$inCmis;
5918					origCmis = $temp$origCmis;
5919					continue findRoot;
5920				}
5921			}
5922		}
5923	});
5924var $author$project$MainCupnakyma$makeCup = function (inCmis) {
5925	return A2($author$project$MainCupnakyma$findRoot, inCmis, inCmis);
5926};
5927var $author$project$MainCupnakyma$treeDepth = F2(
5928	function (tree, n) {
5929		switch (tree.$) {
5930			case 'Bye':
5931				return n;
5932			case 'PoolPos':
5933				return n;
5934			case 'CupMatchNode':
5935				var a = tree.a;
5936				var left = tree.b;
5937				var right = tree.c;
5938				return A2(
5939					$elm$core$Basics$max,
5940					A2($author$project$MainCupnakyma$treeDepth, left, n + 1),
5941					A2($author$project$MainCupnakyma$treeDepth, right, n + 1));
5942			default:
5943				return n;
5944		}
5945	});
5946var $author$project$MainCupnakyma$treeWidth = function (tree) {
5947	return A2(
5948		$elm$core$Basics$pow,
5949		2,
5950		A2($author$project$MainCupnakyma$treeDepth, tree, 0));
5951};
5952var $author$project$MainCupnakyma$putToRow = F2(
5953	function (startRow, tree) {
5954		return (startRow - 1) + $author$project$MainCupnakyma$treeWidth(tree);
5955	});
5956var $author$project$MainCupnakyma$firstSubRow = F2(
5957	function (startRow, tree) {
5958		if (tree.$ === 'CupMatchNode') {
5959			var left = tree.b;
5960			var right = tree.c;
5961			return A2($author$project$MainCupnakyma$putToRow, startRow, left);
5962		} else {
5963			return startRow;
5964		}
5965	});
5966var $author$project$MainCupnakyma$lastSubRow = F2(
5967	function (startRow, tree) {
5968		if (tree.$ === 'CupMatchNode') {
5969			var left = tree.b;
5970			var right = tree.c;
5971			return A2($author$project$MainCupnakyma$putToRow, startRow, right);
5972		} else {
5973			return startRow + 1;
5974		}
5975	});
5976var $elm$core$Basics$not = _Basics_not;
5977var $author$project$MainCupnakyma$matchToString = F2(
5978	function (public_cup, z) {

5979		var vieras_nimi = ((!public_cup) || ((z.vieras_nimi === '') && (z.vierasjoukkue === ''))) ? '---' : ((z.voittaja === 'Vieras') ? ((z.vierasjoukkue === '') ? ('<b>' + (z.vieras_nimi + (' ' + (z.vieras2_nimi + '</b>')))) : ('<b>' + (z.vierasjoukkue + '</b>'))) : ((z.vierasjoukkue === '') ? (z.vieras_nimi + (' ' + z.vieras2_nimi)) : z.vierasjoukkue));
5980		var koti_nimi = ((!public_cup) || ((z.koti_nimi === '') && (z.kotijoukkue === ''))) ? '---' : ((z.voittaja === 'Koti') ? ((z.kotijoukkue === '') ? ('<b>' + (z.koti_nimi + (' ' + (z.koti2_nimi + '</b>')))) : ('<b>' + (z.kotijoukkue + '</b>'))) : ((z.kotijoukkue === '') ? (z.koti_nimi + (' ' + z.koti2_nimi)) : z.kotijoukkue));
5981		return (!public_cup) ? ('<a href=\"https://www.sptl.fi/sptl_uudet/?page_id=27426&KilpailuID=' + ($elm$core$String$fromInt(z.kilpailu_id) + ('&OtteluID=0' + ('\">' + ('--' + '</a>'))))) : ((z.kotijoukkue === '') ? ('<a href=\"https://www.sptl.fi/sptl_uudet/?page_id=27426&KilpailuID=' + ($elm$core$String$fromInt(z.kilpailu_id) + ('&OtteluID=' + ($elm$core$String$fromInt(z.ottelu_id) + ('\">' + (koti_nimi + ('-' + (vieras_nimi + '</a>')))))))) : ('<a href=\"https://www.sptl.fi/sptl_uudet/?page_id=61225&KilpailuID=' + ($elm$core$String$fromInt(z.kilpailu_id) + ('&Luokka=' + (z.luokka + ('&Cup=' + ('cup' + ('&Kotijoukkue=' + (z.kotijoukkue + ('&Vierasjoukkue=' + (z.vierasjoukkue + ('\"> ' + (koti_nimi + ('-' + (vieras_nimi + '</a>')))))))))))))));
5982	});
5983var $author$project$MainCupnakyma$addSetString = function (s) {
5984	return (s === '') ? '' : (',' + s);
5985};
5986var $author$project$MainCupnakyma$resultToString = F2(
5987	function (public_cup, z) {
5988		return public_cup ? ((z.kotijoukkue === '') ? ((z.voittaja === '') ? '--' : ((z.voittotyyppi !== '') ? ((z.voittaja === 'Vieras') ? ('-' + z.voittotyyppi) : z.voittotyyppi) : ($elm$core$String$fromInt(z.koti_erat) + ('-' + ($elm$core$String$fromInt(z.vieras_erat) + (' (' + (z.era1 + ($author$project$MainCupnakyma$addSetString(z.era2) + ($author$project$MainCupnakyma$addSetString(z.era3) + ($author$project$MainCupnakyma$addSetString(z.era4) + ($author$project$MainCupnakyma$addSetString(z.era5) + ($author$project$MainCupnakyma$addSetString(z.era6) + ($author$project$MainCupnakyma$addSetString(z.era7) + ($author$project$MainCupnakyma$addSetString(z.era8) + ($author$project$MainCupnakyma$addSetString(z.era9) + ')'))))))))))))))) : ((z.era1 === '0-0') ? '--' : z.era1)) : '--';
5989	});
5990var $author$project$MainCupnakyma$treeTableItems = F6(
5991	function (tree, public_cup, startRow, rows, curCol, maxCols) {
5992		switch (tree.$) {
5993			case 'Bye':
5994				return _List_fromArray(
5995					[
5996						_Utils_Tuple3(startRow, 1, 'Bye')
5997					]);
5998			case 'PoolPos':
5999				var x = tree.a;
6000				var y = tree.b;
6001				var s = tree.c;
6002				return public_cup ? _List_fromArray(
6003					[
6004						_Utils_Tuple3(
6005						startRow,
6006						1,
6007						x + ($elm$core$String$fromInt(y) + (' ' + s)))
6008					]) : _List_fromArray(
6009					[
6010						_Utils_Tuple3(startRow, 1, '?')
6011					]);
6012			case 'PositionedPlayer':
6013				var cp = tree.a;
6014				return _List_fromArray(
6015					[
6016						_Utils_Tuple3(
6017						startRow,
6018						1,
6019						$elm$core$String$fromInt(cp.rating + cp.rating2) + (':' + (((cp.nimi === '') ? cp.joukkue : cp.nimi) + (' ' + (cp.nimi2 + (((cp.nimi === '') ? '' : '/') + (cp.seura + (' ' + cp.seura2))))))))
6020					]);
6021			case 'CupMatchNode':
6022				var z = tree.a;
6023				var left = tree.b;
6024				var right = tree.c;
6025				var thisToRow = A2($author$project$MainCupnakyma$putToRow, startRow, left);
6026				var lastSubR = A2(
6027					$author$project$MainCupnakyma$lastSubRow,
6028					startRow + $author$project$MainCupnakyma$treeWidth(left),
6029					right);
6030				var firstSubR = A2($author$project$MainCupnakyma$firstSubRow, startRow, left);
6031				return _Utils_ap(
6032					_List_fromArray(
6033						[
6034							_Utils_Tuple3(
6035							thisToRow,
6036							curCol,
6037							A2($author$project$MainCupnakyma$matchToString, public_cup, z))
6038						]),
6039					_Utils_ap(
6040						_List_fromArray(
6041							[
6042								_Utils_Tuple3(
6043								thisToRow + 1,
6044								curCol,
6045								A2($author$project$MainCupnakyma$resultToString, public_cup, z))
6046							]),
6047						_Utils_ap(
6048							A6(
6049								$author$project$MainCupnakyma$treeTableItems,
6050								left,
6051								public_cup,
6052								startRow,
6053								$author$project$MainCupnakyma$treeWidth(left),
6054								curCol - 1,
6055								maxCols),
6056							A6(
6057								$author$project$MainCupnakyma$treeTableItems,
6058								right,
6059								public_cup,
6060								startRow + $author$project$MainCupnakyma$treeWidth(left),
6061								$author$project$MainCupnakyma$treeWidth(right),
6062								curCol - 1,
6063								maxCols))));
6064			default:
6065				return _List_Nil;
6066		}
6067	});
6068var $author$project$MainCupnakyma$makeTreeTableItems = F2(
6069	function (tree, public_cup) {
6070		return A6(
6071			$author$project$MainCupnakyma$treeTableItems,
6072			tree,
6073			public_cup,
6074			1,
6075			$author$project$MainCupnakyma$treeWidth(tree),
6076			A2($author$project$MainCupnakyma$treeDepth, tree, 0) + 1,
6077			A2($author$project$MainCupnakyma$treeDepth, tree, 0) + 1);
6078	});
6079var $elm$core$List$filter = F2(
6080	function (isGood, list) {
6081		return A3(
6082			$elm$core$List$foldr,
6083			F2(
6084				function (x, xs) {
6085					return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
6086				}),
6087			_List_Nil,
6088			list);
6089	});
6090var $author$project$MainCupnakyma$getCupMatchIds = function (cupMatches) {
6091	if (!cupMatches.b) {
6092		return _List_Nil;
6093	} else {
6094		var cm = cupMatches.a;
6095		var cms = cupMatches.b;
6096		var id = cm.ottelu_id_cupissa;
6097		var others = A2(
6098			$elm$core$List$filter,
6099			function (match) {
6100				return !_Utils_eq(match.ottelu_id_cupissa, id);
6101			},
6102			A2($elm$core$List$cons, cm, cms));
6103		return A2(
6104			$elm$core$List$cons,
6105			id,
6106			$author$project$MainCupnakyma$getCupMatchIds(others));
6107	}
6108};
6109var $author$project$MainCupnakyma$empty_pmi = {cup_id: '', era1: '', era2: '', era3: '', era4: '', era5: '', era6: '', era7: '', era8: '', era9: '', haviajan_jatko_cup: '', haviajan_jatko_id: 0, haviajan_jatko_koti: '', kilpailu_id: 0, koti2_id: '', koti2_nimi: '', koti2_rating: 0, koti2_seura: '', koti_erat: 0, koti_id: '', koti_nimi: '', koti_rating: 0, koti_seura: '', kotijoukkue: '', luokka: '', ottelu_id: 0, ottelu_id_cupissa: 0, poolisijalta_koti: 0, poolisijalta_vieras: 0, poolista_koti: '', poolista_vieras: '', vieras2_id: '', vieras2_nimi: '', vieras2_rating: 0, vieras2_seura: '', vieras_erat: 0, vieras_id: '', vieras_

6109nimi: '', vieras_rating: 0, vieras_seura: '', vierasjoukkue: '', voittaja: '', voittajan_jatko_cup: '', voittajan_jatko_id: 0, voittajan_jatko_koti: '', voittotyyppi: ''};
6110var $author$project$MainCupnakyma$mergeMatches = function (matches) {
6111	if (!matches.b) {
6112		return $author$project$MainCupnakyma$empty_pmi;
6113	} else {
6114		var m = matches.a;
6115		var ms = matches.b;
6116		var vie = m.vierasjoukkue;
6117		var ve = $elm$core$List$length(
6118			A2(
6119				$elm$core$List$filter,
6120				function (match) {
6121					return match.voittaja === 'Vieras';
6122				},
6123				matches));
6124		var kv = $elm$core$List$length(
6125			A2(
6126				$elm$core$List$filter,
6127				function (match) {
6128					return match.voittaja === 'Koti';
6129				},
6130				matches));
6131		var voit = (kv > 2) ? 'Koti' : ((ve > 2) ? 'Vieras' : '');
6132		var kot = m.kotijoukkue;
6133		var er1 = $elm$core$String$fromInt(kv) + ('-' + $elm$core$String$fromInt(ve));
6134		return _Utils_update(
6135			m,
6136			{era1: er1, era2: '', era3: '', era4: '', era5: '', era6: '', era7: '', koti2_nimi: '', koti_nimi: kot, vieras2_nimi: '', vieras_nimi: vie, voittaja: voit});
6137	}
6138};
6139var $author$project$MainCupnakyma$mergeByIds = F2(
6140	function (cupMatchIds, initCupMatches) {
6141		if (!cupMatchIds.b) {
6142			return _List_Nil;
6143		} else {
6144			var id = cupMatchIds.a;
6145			var ids = cupMatchIds.b;
6146			var matches = A2(
6147				$elm$core$List$filter,
6148				function (match) {
6149					return _Utils_eq(match.ottelu_id_cupissa, id);
6150				},
6151				initCupMatches);
6152			return A2(
6153				$elm$core$List$cons,
6154				$author$project$MainCupnakyma$mergeMatches(matches),
6155				A2($author$project$MainCupnakyma$mergeByIds, ids, initCupMatches));
6156		}
6157	});
6158var $author$project$MainCupnakyma$mergeCupMatches = function (initCupMatches) {
6159	var cupMatchIds = $author$project$MainCupnakyma$getCupMatchIds(initCupMatches);
6160	return A2($author$project$MainCupnakyma$mergeByIds, cupMatchIds, initCupMatches);
6161};
6162var $author$project$MainCupnakyma$cupHtmlTable = function (model) {
6163	var cup = $author$project$MainCupnakyma$is_joukkuecup(model.cupMatches) ? $author$project$MainCupnakyma$makeCup(
6164		$author$project$MainCupnakyma$mergeCupMatches(model.cupMatches)) : $author$project$MainCupnakyma$makeCup(model.cupMatches);
6165	return A3(
6166		$author$project$MainCupnakyma$cupString,
6167		A2(
6168			$author$project$MainCupnakyma$makeTreeTableItems,
6169			cup,
6170			$author$project$MainCupnakyma$allPoolsPlayed(model.cupMatches) || model.admin),
6171		$author$project$MainCupnakyma$treeWidth(cup),
6172		A2($author$project$MainCupnakyma$treeDepth, cup, 0) + 1);
6173};
6174var $elm$html$Html$span = _VirtualDom_node('span');
6175var $hecrj$html_parser$Html$Parser$Element = F3(
6176	function (a, b, c) {
6177		return {$: 'Element', a: a, b: b, c: c};
6178	});
6179var $elm$parser$Parser$Advanced$Bad = F2(
6180	function (a, b) {
6181		return {$: 'Bad', a: a, b: b};
6182	});
6183var $elm$parser$Parser$Advanced$Good = F3(
6184	function (a, b, c) {
6185		return {$: 'Good', a: a, b: b, c: c};
6186	});
6187var $elm$parser$Parser$Advanced$Parser = function (a) {
6188	return {$: 'Parser', a: a};
6189};
6190var $elm$parser$Parser$Advanced$andThen = F2(
6191	function (callback, _v0) {
6192		var parseA = _v0.a;
6193		return $elm$parser$Parser$Advanced$Parser(
6194			function (s0) {
6195				var _v1 = parseA(s0);
6196				if (_v1.$ === 'Bad') {
6197					var p = _v1.a;
6198					var x = _v1.b;
6199					return A2($elm$parser$Parser$Advanced$Bad, p, x);
6200				} else {
6201					var p1 = _v1.a;
6202					var a = _v1.b;
6203					var s1 = _v1.c;
6204					var _v2 = callback(a);
6205					var parseB = _v2.a;
6206					var _v3 = parseB(s1);
6207					if (_v3.$ === 'Bad') {
6208						var p2 = _v3.a;
6209						var x = _v3.b;
6210						return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x);
6211					} else {
6212						var p2 = _v3.a;
6213						var b = _v3.b;
6214						var s2 = _v3.c;
6215						return A3($elm$parser$Parser$Advanced$Good, p1 || p2, b, s2);
6216					}
6217				}
6218			});
6219	});
6220var $elm$parser$Parser$andThen = $elm$parser$Parser$Advanced$andThen;
6221var $elm$parser$Parser$Advanced$backtrackable = function (_v0) {
6222	var parse = _v0.a;
6223	return $elm$parser$Parser$Advanced$Parser(
6224		function (s0) {
6225			var _v1 = parse(s0);
6226			if (_v1.$ === 'Bad') {
6227				var x = _v1.b;
6228				return A2($elm$parser$Parser$Advanced$Bad, false, x);
6229			} else {
6230				var a = _v1.b;
6231				var s1 = _v1.c;
6232				return A3($elm$parser$Parser$Advanced$Good, false, a, s1);
6233			}
6234		});
6235};
6236var $elm$parser$Parser$backtrackable = $elm$parser$Parser$Advanced$backtrackable;
6237var $elm$parser$Parser$UnexpectedChar = {$: 'UnexpectedChar'};
6238var $elm$parser$Parser$Advanced$AddRight = F2(
6239	function (a, b) {
6240		return {$: 'AddRight', a: a, b: b};
6241	});
6242var $elm$parser$Parser$Advanced$DeadEnd = F4(
6243	function (row, col, problem, contextStack) {
6244		return {col: col, contextStack: contextStack, problem: problem, row: row};
6245	});
6246var $elm$parser$Parser$Advanced$Empty = {$: 'Empty'};
6247var $elm$parser$Parser$Advanced$fromState = F2(
6248	function (s, x) {
6249		return A2(
6250			$elm$parser$Parser$Advanced$AddRight,
6251			$elm$parser$Parser$Advanced$Empty,
6252			A4($elm$parser$Parser$Advanced$DeadEnd, s.row, s.col, x, s.context));
6253	});
6254var $elm$parser$Parser$Advanced$isSubChar = _Parser_isSubChar;
6255var $elm$core$Basics$negate = function (n) {
6256	return -n;
6257};
6258var $elm$parser$Parser$Advanced$chompIf = F2(
6259	function (isGood, expecting) {
6260		return $elm$parser$Parser$Advanced$Parser(
6261			function (s) {
6262				var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, s.offset, s.src);
6263				return _Utils_eq(newOffset, -1) ? A2(
6264					$elm$parser$Parser$Advanced$Bad,
6265					false,
6266					A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : (_Utils_eq(newOffset, -2) ? A3(
6267					$elm$parser$Parser$Advanced$Good,
6268					true,
6269					_Utils_Tuple0,
6270					{col: 1, context: s.context, indent: s.indent, offset: s.offset + 1, row: s.row + 1, src: s.src}) : A3(
6271					$elm$parser$Parser$Advanced$Good,
6272					true,
6273					_Utils_Tuple0,
6274					{col: s.col + 1, context: s.context, indent: s.indent, offset: newOffset, row: s.row, src: s.src}));
6275			});
6276	});
6277var $elm$parser$Parser$chompIf = function (isGood) {
6278	return A2($elm$parser$Parser$Advanced$chompIf, isGood, $elm$parser$Parser$UnexpectedChar);
6279};
6280var $elm$parser$Parser$Advanced$chompWhileHelp = F5(
6281	function (isGood, offset, row, col, s0) {
6282		chompWhileHelp:
6283		while (true) {
6284			var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, s0.src);
6285			if (_Utils_eq(newOffset, -1)) {
6286				return A3(
6287					$elm$parser$Parser$Advanced$Good,
6288					_Utils_cmp(s0.offset, offset) < 0,
6289					_Utils_Tuple0,
6290					{col: col, context: s0.context, indent: s0.indent, offset: offset, row: row, src: s0.src});
6291			} else {
6292				if (_Utils_eq(newOffset, -2)) {
6293					var $temp$isGood = isGood,
6294						$temp$offset = offset + 1,
6295						$temp$row = row + 1,
6296						$temp$col = 1,
6297						$temp$s0 = s0;
6298					isGood = $temp$isGood;
6299					offset = $temp$offset;

6300					row = $temp$row;
6301					col = $temp$col;
6302					s0 = $temp$s0;
6303					continue chompWhileHelp;
6304				} else {
6305					var $temp$isGood = isGood,
6306						$temp$offset = newOffset,
6307						$temp$row = row,
6308						$temp$col = col + 1,
6309						$temp$s0 = s0;
6310					isGood = $temp$isGood;
6311					offset = $temp$offset;
6312					row = $temp$row;
6313					col = $temp$col;
6314					s0 = $temp$s0;
6315					continue chompWhileHelp;
6316				}
6317			}
6318		}
6319	});
6320var $elm$parser$Parser$Advanced$chompWhile = function (isGood) {
6321	return $elm$parser$Parser$Advanced$Parser(
6322		function (s) {
6323			return A5($elm$parser$Parser$Advanced$chompWhileHelp, isGood, s.offset, s.row, s.col, s);
6324		});
6325};
6326var $elm$parser$Parser$chompWhile = $elm$parser$Parser$Advanced$chompWhile;
6327var $elm$core$Basics$always = F2(
6328	function (a, _v0) {
6329		return a;
6330	});
6331var $elm$parser$Parser$Advanced$map2 = F3(
6332	function (func, _v0, _v1) {
6333		var parseA = _v0.a;
6334		var parseB = _v1.a;
6335		return $elm$parser$Parser$Advanced$Parser(
6336			function (s0) {
6337				var _v2 = parseA(s0);
6338				if (_v2.$ === 'Bad') {
6339					var p = _v2.a;
6340					var x = _v2.b;
6341					return A2($elm$parser$Parser$Advanced$Bad, p, x);
6342				} else {
6343					var p1 = _v2.a;
6344					var a = _v2.b;
6345					var s1 = _v2.c;
6346					var _v3 = parseB(s1);
6347					if (_v3.$ === 'Bad') {
6348						var p2 = _v3.a;
6349						var x = _v3.b;
6350						return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x);
6351					} else {
6352						var p2 = _v3.a;
6353						var b = _v3.b;
6354						var s2 = _v3.c;
6355						return A3(
6356							$elm$parser$Parser$Advanced$Good,
6357							p1 || p2,
6358							A2(func, a, b),
6359							s2);
6360					}
6361				}
6362			});
6363	});
6364var $elm$parser$Parser$Advanced$ignorer = F2(
6365	function (keepParser, ignoreParser) {
6366		return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$always, keepParser, ignoreParser);
6367	});
6368var $elm$parser$Parser$ignorer = $elm$parser$Parser$Advanced$ignorer;
6369var $hecrj$html_parser$Html$Parser$chompOneOrMore = function (fn) {
6370	return A2(
6371		$elm$parser$Parser$ignorer,
6372		$elm$parser$Parser$chompIf(fn),
6373		$elm$parser$Parser$chompWhile(fn));
6374};
6375var $elm$parser$Parser$Advanced$mapChompedString = F2(
6376	function (func, _v0) {
6377		var parse = _v0.a;
6378		return $elm$parser$Parser$Advanced$Parser(
6379			function (s0) {
6380				var _v1 = parse(s0);
6381				if (_v1.$ === 'Bad') {
6382					var p = _v1.a;
6383					var x = _v1.b;
6384					return A2($elm$parser$Parser$Advanced$Bad, p, x);
6385				} else {
6386					var p = _v1.a;
6387					var a = _v1.b;
6388					var s1 = _v1.c;
6389					return A3(
6390						$elm$parser$Parser$Advanced$Good,
6391						p,
6392						A2(
6393							func,
6394							A3($elm$core$String$slice, s0.offset, s1.offset, s0.src),
6395							a),
6396						s1);
6397				}
6398			});
6399	});
6400var $elm$parser$Parser$Advanced$getChompedString = function (parser) {
6401	return A2($elm$parser$Parser$Advanced$mapChompedString, $elm$core$Basics$always, parser);
6402};
6403var $elm$parser$Parser$getChompedString = $elm$parser$Parser$Advanced$getChompedString;
6404var $hecrj$html_parser$Html$Parser$isSpaceCharacter = function (c) {
6405	return _Utils_eq(
6406		c,
6407		_Utils_chr(' ')) || (_Utils_eq(
6408		c,
6409		_Utils_chr('\t')) || (_Utils_eq(
6410		c,
6411		_Utils_chr('\n')) || (_Utils_eq(
6412		c,
6413		_Utils_chr('\u000D')) || (_Utils_eq(
6414		c,
6415		_Utils_chr('\u000C')) || _Utils_eq(
6416		c,
6417		_Utils_chr('\u00A0'))))));
6418};
6419var $elm$parser$Parser$Problem = function (a) {
6420	return {$: 'Problem', a: a};
6421};
6422var $elm$parser$Parser$Advanced$problem = function (x) {
6423	return $elm$parser$Parser$Advanced$Parser(
6424		function (s) {
6425			return A2(
6426				$elm$parser$Parser$Advanced$Bad,
6427				false,
6428				A2($elm$parser$Parser$Advanced$fromState, s, x));
6429		});
6430};
6431var $elm$parser$Parser$problem = function (msg) {
6432	return $elm$parser$Parser$Advanced$problem(
6433		$elm$parser$Parser$Problem(msg));
6434};
6435var $elm$parser$Parser$Advanced$succeed = function (a) {
6436	return $elm$parser$Parser$Advanced$Parser(
6437		function (s) {
6438			return A3($elm$parser$Parser$Advanced$Good, false, a, s);
6439		});
6440};
6441var $elm$parser$Parser$succeed = $elm$parser$Parser$Advanced$succeed;
6442var $elm$core$String$toLower = _String_toLower;
6443var $hecrj$html_parser$Html$Parser$closingTag = function (name) {
6444	var chompName = A2(
6445		$elm$parser$Parser$andThen,
6446		function (closingName) {
6447			return _Utils_eq(
6448				$elm$core$String$toLower(closingName),
6449				name) ? $elm$parser$Parser$succeed(_Utils_Tuple0) : $elm$parser$Parser$problem('closing tag does not match opening tag: ' + name);
6450		},
6451		$elm$parser$Parser$getChompedString(
6452			$hecrj$html_parser$Html$Parser$chompOneOrMore(
6453				function (c) {
6454					return (!$hecrj$html_parser$Html$Parser$isSpaceCharacter(c)) && (!_Utils_eq(
6455						c,
6456						_Utils_chr('>')));
6457				})));
6458	return A2(
6459		$elm$parser$Parser$ignorer,
6460		A2(
6461			$elm$parser$Parser$ignorer,
6462			A2(
6463				$elm$parser$Parser$ignorer,
6464				A2(
6465					$elm$parser$Parser$ignorer,
6466					$elm$parser$Parser$chompIf(
6467						$elm$core$Basics$eq(
6468							_Utils_chr('<'))),
6469					$elm$parser$Parser$chompIf(
6470						$elm$core$Basics$eq(
6471							_Utils_chr('/')))),
6472				chompName),
6473			$elm$parser$Parser$chompWhile($hecrj$html_parser$Html$Parser$isSpaceCharacter)),
6474		$elm$parser$Parser$chompIf(
6475			$elm$core$Basics$eq(
6476				_Utils_chr('>'))));
6477};
6478var $hecrj$html_parser$Html$Parser$Comment = function (a) {
6479	return {$: 'Comment', a: a};
6480};
6481var $elm$parser$Parser$Advanced$findSubString = _Parser_findSubString;
6482var $elm$parser$Parser$Advanced$fromInfo = F4(
6483	function (row, col, x, context) {
6484		return A2(
6485			$elm$parser$Parser$Advanced$AddRight,
6486			$elm$parser$Parser$Advanced$Empty,

6487			A4($elm$parser$Parser$Advanced$DeadEnd, row, col, x, context));
6488	});
6489var $elm$parser$Parser$Advanced$chompUntil = function (_v0) {
6490	var str = _v0.a;
6491	var expecting = _v0.b;
6492	return $elm$parser$Parser$Advanced$Parser(
6493		function (s) {
6494			var _v1 = A5($elm$parser$Parser$Advanced$findSubString, str, s.offset, s.row, s.col, s.src);
6495			var newOffset = _v1.a;
6496			var newRow = _v1.b;
6497			var newCol = _v1.c;
6498			return _Utils_eq(newOffset, -1) ? A2(
6499				$elm$parser$Parser$Advanced$Bad,
6500				false,
6501				A4($elm$parser$Parser$Advanced$fromInfo, newRow, newCol, expecting, s.context)) : A3(
6502				$elm$parser$Parser$Advanced$Good,
6503				_Utils_cmp(s.offset, newOffset) < 0,
6504				_Utils_Tuple0,
6505				{col: newCol, context: s.context, indent: s.indent, offset: newOffset, row: newRow, src: s.src});
6506		});
6507};
6508var $elm$parser$Parser$Expecting = function (a) {
6509	return {$: 'Expecting', a: a};
6510};
6511var $elm$parser$Parser$Advanced$Token = F2(
6512	function (a, b) {
6513		return {$: 'Token', a: a, b: b};
6514	});
6515var $elm$parser$Parser$toToken = function (str) {
6516	return A2(
6517		$elm$parser$Parser$Advanced$Token,
6518		str,
6519		$elm$parser$Parser$Expecting(str));
6520};
6521var $elm$parser$Parser$chompUntil = function (str) {
6522	return $elm$parser$Parser$Advanced$chompUntil(
6523		$elm$parser$Parser$toToken(str));
6524};
6525var $elm$parser$Parser$Advanced$keeper = F2(
6526	function (parseFunc, parseArg) {
6527		return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$apL, parseFunc, parseArg);
6528	});
6529var $elm$parser$Parser$keeper = $elm$parser$Parser$Advanced$keeper;
6530var $elm$parser$Parser$Advanced$isSubString = _Parser_isSubString;
6531var $elm$parser$Parser$Advanced$token = function (_v0) {
6532	var str = _v0.a;
6533	var expecting = _v0.b;
6534	var progress = !$elm$core$String$isEmpty(str);
6535	return $elm$parser$Parser$Advanced$Parser(
6536		function (s) {
6537			var _v1 = A5($elm$parser$Parser$Advanced$isSubString, str, s.offset, s.row, s.col, s.src);
6538			var newOffset = _v1.a;
6539			var newRow = _v1.b;
6540			var newCol = _v1.c;
6541			return _Utils_eq(newOffset, -1) ? A2(
6542				$elm$parser$Parser$Advanced$Bad,
6543				false,
6544				A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3(
6545				$elm$parser$Parser$Advanced$Good,
6546				progress,
6547				_Utils_Tuple0,
6548				{col: newCol, context: s.context, indent: s.indent, offset: newOffset, row: newRow, src: s.src});
6549		});
6550};
6551var $elm$parser$Parser$token = function (str) {
6552	return $elm$parser$Parser$Advanced$token(
6553		$elm$parser$Parser$toToken(str));
6554};
6555var $hecrj$html_parser$Html$Parser$commentString = A2(
6556	$elm$parser$Parser$keeper,
6557	A2(
6558		$elm$parser$Parser$ignorer,
6559		A2(
6560			$elm$parser$Parser$ignorer,
6561			$elm$parser$Parser$succeed($elm$core$Basics$identity),
6562			$elm$parser$Parser$token('<!')),
6563		$elm$parser$Parser$token('--')),
6564	A2(
6565		$elm$parser$Parser$ignorer,
6566		$elm$parser$Parser$getChompedString(
6567			$elm$parser$Parser$chompUntil('-->')),
6568		$elm$parser$Parser$token('-->')));
6569var $elm$parser$Parser$Advanced$map = F2(
6570	function (func, _v0) {
6571		var parse = _v0.a;
6572		return $elm$parser$Parser$Advanced$Parser(
6573			function (s0) {
6574				var _v1 = parse(s0);
6575				if (_v1.$ === 'Good') {
6576					var p = _v1.a;
6577					var a = _v1.b;
6578					var s1 = _v1.c;
6579					return A3(
6580						$elm$parser$Parser$Advanced$Good,
6581						p,
6582						func(a),
6583						s1);
6584				} else {
6585					var p = _v1.a;
6586					var x = _v1.b;
6587					return A2($elm$parser$Parser$Advanced$Bad, p, x);
6588				}
6589			});
6590	});
6591var $elm$parser$Parser$map = $elm$parser$Parser$Advanced$map;
6592var $hecrj$html_parser$Html$Parser$comment = A2($elm$parser$Parser$map, $hecrj$html_parser$Html$Parser$Comment, $hecrj$html_parser$Html$Parser$commentString);
6593var $elm$core$List$any = F2(
6594	function (isOkay, list) {
6595		any:
6596		while (true) {
6597			if (!list.b) {
6598				return false;
6599			} else {
6600				var x = list.a;
6601				var xs = list.b;
6602				if (isOkay(x)) {
6603					return true;
6604				} else {
6605					var $temp$isOkay = isOkay,
6606						$temp$list = xs;
6607					isOkay = $temp$isOkay;
6608					list = $temp$list;
6609					continue any;
6610				}
6611			}
6612		}
6613	});
6614var $elm$core$List$member = F2(
6615	function (x, xs) {
6616		return A2(
6617			$elm$core$List$any,
6618			function (a) {
6619				return _Utils_eq(a, x);
6620			},
6621			xs);
6622	});
6623var $hecrj$html_parser$Html$Parser$voidElements = _List_fromArray(
6624	['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
6625var $hecrj$html_parser$Html$Parser$isVoidElement = function (name) {
6626	return A2($elm$core$List$member, name, $hecrj$html_parser$Html$Parser$voidElements);
6627};
6628var $elm$parser$Parser$Done = function (a) {
6629	return {$: 'Done', a: a};
6630};
6631var $elm$parser$Parser$Loop = function (a) {
6632	return {$: 'Loop', a: a};
6633};
6634var $elm$parser$Parser$Advanced$loopHelp = F4(
6635	function (p, state, callback, s0) {
6636		loopHelp:
6637		while (true) {
6638			var _v0 = callback(state);
6639			var parse = _v0.a;
6640			var _v1 = parse(s0);
6641			if (_v1.$ === 'Good') {
6642				var p1 = _v1.a;
6643				var step = _v1.b;
6644				var s1 = _v1.c;
6645				if (step.$ === 'Loop') {
6646					var newState = step.a;
6647					var $temp$p = p || p1,
6648						$temp$state = newState,
6649						$temp$callback = callback,
6650						$temp$s0 = s1;
6651					p = $temp$p;
6652					state = $temp$state;
6653					callback = $temp$callback;
6654					s0 = $temp$s0;
6655					continue loopHelp;
6656				} else {
6657					var result = step.a;
6658					return A3($elm$parser$Parser$Advanced$Good, p || p1, result, s1);
6659				}
6660			} else {
6661				var p1 = _v1.a;
6662				var x = _v1.b;
6663				return A2($elm$parser$Parser$Advanced$Bad, p || p1, x);
6664			}
6665		}
6666	});
6667var $elm$parser$Parser$Advanced$loop = F2(
6668	function (state, callback) {
6669		return $elm$parser$Parser$Advanced$Parser(
6670			function (s) {
6671				return A4($elm$parser$Parser$Advanced$loopHelp, false, state, callback, s);
6672			});
6673	});
6674var $elm$parser$Parser$Advanced$Done = function (a) {
6675	return {$: 'Done', a: a};
6676};
6677var $elm$parser$Parser$Advanced$Loop = function (a) {
6678	return {$: 'Loop', a: a};
6679};
6680var $elm$parser$Parser$toAdvancedStep = function (step) {
6681	if (step.$ === 'Loop') {
6682		var s = step.a;
6683		return $elm$parser$Parser$Advanced$Loop(s);
6684	} else {
6685		var a = step.a;
6686		return $elm$parser$Parser$Advanced$Done(a);
6687	}
6688};
6689var $elm$parser$Parser$loop = F2(
6690	function (state, callback) {
6691		return A2(
6692			$elm$parser$Parser$Advanced$loop,
6693			state,
6694			function (s) {
6695				return A2(
6696					$elm$parser$Parser$map,
6697					$elm$parser$Parser$toAdvancedStep,
6698					callback(s));
6699			});
6700	});
6701var $elm$parser$Parser$Advanced$Append = F2(
6702	function (a, b) {
6703		return {$: 'Append', a: a, b: b};
6704	});
6705var $elm$parser$Parser$Advanced$oneOfHelp = F3(
6706	function (s0, bag, parsers) {
6707		oneOfHelp:
6708		while (true) {
6709			if (!parsers.b) {
6710				return A2($elm$parser$Parser$Advanced$Bad, false, bag);
6711			} else {
6712				var parse = parsers.a.a;
6713				var remainingParsers = parsers.b;
6714				var _v1 = parse(s0);
6715				if (_v1.$ === 'Good') {
6716					var step = _v1;
6717					return step;
6718				} else {
6719					var step = _v1;
6720					var p = step.a;
6721					var x = step.b;
6722					if (p) {
6723						return step;
6724					} else {
6725						var $temp$s0 = s0,
6726							$temp$bag = A2($elm$parser$Parser$Advanced$Append, bag, x),
6727							$temp$parsers = remainingParsers;
6728						s0 = $temp$s0;
6729						bag = $temp$bag;
6730						parsers = $temp$parsers;
6731						continue oneOfHelp;
6732					}
6733				}
6734			}
6735		}
6736	});
6737var $elm$parser$Parser$Advanced$oneOf = function (parsers) {
6738	return $elm$parser$Parser$Advanced$Parser(
6739		function (s) {
6740			return A3($elm$parser$Parser$Advanced$oneOfHelp, s, $elm$parser$Parser$Advanced$Empty, parsers);
6741		});
6742};
6743var $elm$parser$Parser$oneOf = $elm$parser$Parser$Advanced$oneOf;
6744var $hecrj$html_parser$Html$Parser$many = function (parser_) {
6745	return A2(
6746		$elm$parser$Parser$loop,
6747		_List_Nil,
6748		function (list) {
6749			return $elm$parser$Parser$oneOf(
6750				_List_fromArray(
6751					[
6752						A2(
6753						$elm$parser$Parser$map,
6754						function (_new) {
6755							return $elm$parser$Parser$Loop(
6756								A2($elm$core$List$cons, _new, list));
6757						},
6758						parser_),
6759						$elm$parser$Parser$succeed(
6760						$elm$parser$Parser$Done(
6761							$elm$core$List$reverse(list)))
6762					]));
6763		});
6764};
6765var $elm$core$Tuple$pair = F2(
6766	function (a, b) {
6767		return _Utils_Tuple2(a, b);
6768	});
6769var $hecrj$html_parser$Html$Parser$isTagAttributeCharacter = function (c) {
6770	return (!$hecrj$html_parser$Html$Parser$isSpaceCharacter(c)) && ((!_Utils_eq(
6771		c,
6772		_Utils_chr('\"'))) && ((!_Utils_eq(
6773		c,
6774		_Utils_chr('\''))) && ((!_Utils_eq(
6775		c,
6776		_Utils_chr('>'))) && ((!_Utils_eq(
6777		c,
6778		_Utils_chr('/'))) && (!_Utils_eq(
6779		c,
6780		_Utils_chr('=')))))));
6781};
6782var $hecrj$html_parser$Html$Parser$tagAttributeName = A2(
6783	$elm$parser$Parser$map,
6784	$elm$core$String$toLower,
6785	$elm$parser$Parser$getChompedString(
6786		$hecrj$html_parser$Html$Parser$chompOneOrMore($hecrj$html_parser$Html$Parser$isTagAttributeCharacter)));
6787var $hecrj$html_parser$Html$Parser$chompSemicolon = $elm$parser$Parser$chompIf(
6788	$elm$core$Basics$eq(
6789		_Utils_chr(';')));
6790var $elm$core$Dict$RBEmpty_elm_builtin = {$: 'RBEmpty_elm_builtin'};
6791var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin;
6792var $elm$core$Dict$Black = {$: 'Black'};
6793var $elm$core$Dict$RBNode_elm_builtin = F5(
6794	function (a, b, c, d, e) {

6795		return {$: 'RBNode_elm_builtin', a: a, b: b, c: c, d: d, e: e};
6796	});
6797var $elm$core$Dict$Red = {$: 'Red'};
6798var $elm$core$Dict$balance = F5(
6799	function (color, key, value, left, right) {
6800		if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Red')) {
6801			var _v1 = right.a;
6802			var rK = right.b;
6803			var rV = right.c;
6804			var rLeft = right.d;
6805			var rRight = right.e;
6806			if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) {
6807				var _v3 = left.a;
6808				var lK = left.b;
6809				var lV = left.c;
6810				var lLeft = left.d;
6811				var lRight = left.e;
6812				return A5(
6813					$elm$core$Dict$RBNode_elm_builtin,
6814					$elm$core$Dict$Red,
6815					key,
6816					value,
6817					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, lK, lV, lLeft, lRight),
6818					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rLeft, rRight));
6819			} else {
6820				return A5(
6821					$elm$core$Dict$RBNode_elm_builtin,
6822					color,
6823					rK,
6824					rV,
6825					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, left, rLeft),
6826					rRight);
6827			}
6828		} else {
6829			if ((((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) && (left.d.$ === 'RBNode_elm_builtin')) && (left.d.a.$ === 'Red')) {
6830				var _v5 = left.a;
6831				var lK = left.b;
6832				var lV = left.c;
6833				var _v6 = left.d;
6834				var _v7 = _v6.a;
6835				var llK = _v6.b;
6836				var llV = _v6.c;
6837				var llLeft = _v6.d;
6838				var llRight = _v6.e;
6839				var lRight = left.e;
6840				return A5(
6841					$elm$core$Dict$RBNode_elm_builtin,
6842					$elm$core$Dict$Red,
6843					lK,
6844					lV,
6845					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight),
6846					A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, key, value, lRight, right));
6847			} else {
6848				return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right);
6849			}
6850		}
6851	});
6852var $elm$core$Basics$compare = _Utils_compare;
6853var $elm$core$Dict$insertHelp = F3(
6854	function (key, value, dict) {
6855		if (dict.$ === 'RBEmpty_elm_builtin') {
6856			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);
6857		} else {
6858			var nColor = dict.a;
6859			var nKey = dict.b;
6860			var nValue = dict.c;
6861			var nLeft = dict.d;
6862			var nRight = dict.e;
6863			var _v1 = A2($elm$core$Basics$compare, key, nKey);
6864			switch (_v1.$) {
6865				case 'LT':
6866					return A5(
6867						$elm$core$Dict$balance,
6868						nColor,
6869						nKey,
6870						nValue,
6871						A3($elm$core$Dict$insertHelp, key, value, nLeft),
6872						nRight);
6873				case 'EQ':
6874					return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight);
6875				default:
6876					return A5(
6877						$elm$core$Dict$balance,
6878						nColor,
6879						nKey,
6880						nValue,
6881						nLeft,
6882						A3($elm$core$Dict$insertHelp, key, value, nRight));
6883			}
6884		}
6885	});
6886var $elm$core$Dict$insert = F3(
6887	function (key, value, dict) {
6888		var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict);
6889		if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) {
6890			var _v1 = _v0.a;
6891			var k = _v0.b;
6892			var v = _v0.c;
6893			var l = _v0.d;
6894			var r = _v0.e;
6895			return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r);
6896		} else {
6897			var x = _v0;
6898			return x;
6899		}
6900	});
6901var $elm$core$Dict$fromList = function (assocs) {
6902	return A3(
6903		$elm$core$List$foldl,
6904		F2(
6905			function (_v0, dict) {
6906				var key = _v0.a;
6907				var value = _v0.b;
6908				return A3($elm$core$Dict$insert, key, value, dict);
6909			}),
6910		$elm$core$Dict$empty,
6911		assocs);
6912};
6913var $hecrj$html_parser$Html$Parser$NamedCharacterReferences$dict = $elm$core$Dict$fromList(
6914	_List_fromArray(
6915		[
6916			_Utils_Tuple2('Aacute', 'Á'),
6917			_Utils_Tuple2('aacute', 'á'),
6918			_Utils_Tuple2('Abreve', 'Ă'),
6919			_Utils_Tuple2('abreve', 'ă'),
6920			_Utils_Tuple2('ac', '∾'),
6921			_Utils_Tuple2('acd', '∿'),
6922			_Utils_Tuple2('acE', '∾̳'),
6923			_Utils_Tuple2('Acirc', 'Â'),
6924			_Utils_Tuple2('acirc', 'â'),
6925			_Utils_Tuple2('acute', '´'),
6926			_Utils_Tuple2('Acy', 'А'),
6927			_Utils_Tuple2('acy', 'а'),
6928			_Utils_Tuple2('AElig', 'Æ'),
6929			_Utils_Tuple2('aelig', 'æ'),
6930			_Utils_Tuple2('af', '\u2061'),
6931			_Utils_Tuple2('Afr', '\uD835\uDD04'),
6932			_Utils_Tuple2('afr', '\uD835\uDD1E'),

6933			_Utils_Tuple2('Agrave', 'À'),
6934			_Utils_Tuple2('agrave', 'à'),
6935			_Utils_Tuple2('alefsym', 'ℵ'),
6936			_Utils_Tuple2('aleph', 'ℵ'),
6937			_Utils_Tuple2('Alpha', 'Α'),
6938			_Utils_Tuple2('alpha', 'α'),
6939			_Utils_Tuple2('Amacr', 'Ā'),
6940			_Utils_Tuple2('amacr', 'ā'),
6941			_Utils_Tuple2('amalg', '⨿'),
6942			_Utils_Tuple2('amp', '&'),
6943			_Utils_Tuple2('AMP', '&'),
6944			_Utils_Tuple2('andand', '⩕'),
6945			_Utils_Tuple2('And', '⩓'),
6946			_Utils_Tuple2('and', '∧'),
6947			_Utils_Tuple2('andd', '⩜'),
6948			_Utils_Tuple2('andslope', '⩘'),
6949			_Utils_Tuple2('andv', '⩚'),
6950			_Utils_Tuple2('ang', '∠'),
6951			_Utils_Tuple2('ange', '⦤'),
6952			_Utils_Tuple2('angle', '∠'),
6953			_Utils_Tuple2('angmsdaa', '⦨'),
6954			_Utils_Tuple2('angmsdab', '⦩'),
6955			_Utils_Tuple2('angmsdac', '⦪'),
6956			_Utils_Tuple2('angmsdad', '⦫'),
6957			_Utils_Tuple2('angmsdae', '⦬'),
6958			_Utils_Tuple2('angmsdaf', '⦭'),
6959			_Utils_Tuple2('angmsdag', '⦮'),
6960			_Utils_Tuple2('angmsdah', '⦯'),
6961			_Utils_Tuple2('angmsd', '∡'),
6962			_Utils_Tuple2('angrt', '∟'),
6963			_Utils_Tuple2('angrtvb', '⊾'),
6964			_Utils_Tuple2('angrtvbd', '⦝'),
6965			_Utils_Tuple2('angsph', '∢'),
6966			_Utils_Tuple2('angst', 'Å'),
6967			_Utils_Tuple2('angzarr', '⍼'),
6968			_Utils_Tuple2('Aogon', 'Ą'),
6969			_Utils_Tuple2('aogon', 'ą'),
6970			_Utils_Tuple2('Aopf', '\uD835\uDD38'),
6971			_Utils_Tuple2('aopf', '\uD835\uDD52'),
6972			_Utils_Tuple2('apacir', '⩯'),
6973			_Utils_Tuple2('ap', '≈'),
6974			_Utils_Tuple2('apE', 'â©°'),
6975			_Utils_Tuple2('ape', '≊'),
6976			_Utils_Tuple2('apid', '≋'),
6977			_Utils_Tuple2('apos', '\''),
6978			_Utils_Tuple2('ApplyFunction', '\u2061'),
6979			_Utils_Tuple2('approx', '≈'),
6980			_Utils_Tuple2('approxeq', '≊'),
6981			_Utils_Tuple2('Aring', 'Å'),
6982			_Utils_Tuple2('aring', 'Ã¥'),
6983			_Utils_Tuple2('Ascr', '\uD835\uDC9C'),
6984			_Utils_Tuple2('ascr', '\uD835\uDCB6'),
6985			_Utils_Tuple2('Assign', '≔'),
6986			_Utils_Tuple2('ast', '*'),
6987			_Utils_Tuple2('asymp', '≈'),
6988			_Utils_Tuple2('asympeq', '≍'),
6989			_Utils_Tuple2('Atilde', 'Ã'),
6990			_Utils_Tuple2('atilde', 'ã'),
6991			_Utils_Tuple2('Auml', 'Ä'),
6992			_Utils_Tuple2('auml', 'ä'),
6993			_Utils_Tuple2('awconint', '∳'),
6994			_Utils_Tuple2('awint', '⨑'),
6995			_Utils_Tuple2('backcong', '≌'),
6996			_Utils_Tuple2('backepsilon', '϶'),
6997			_Utils_Tuple2('backprime', '‵'),
6998			_Utils_Tuple2('backsim', '∽'),
6999			_Utils_Tuple2('backsimeq', '⋍'),
7000			_Utils_Tuple2('Backslash', '∖'),
7001			_Utils_Tuple2('Barv', '⫧'),
7002			_Utils_Tuple2('barvee', '⊽'),
7003			_Utils_Tuple2('barwed', '⌅'),
7004			_Utils_Tuple2('Barwed', '⌆'),
7005			_Utils_Tuple2('barwedge', '⌅'),
7006			_Utils_Tuple2('bbrk', '⎵'),
7007			_Utils_Tuple2('bbrktbrk', '⎶'),
7008			_Utils_Tuple2('bcong', '≌'),
7009			_Utils_Tuple2('Bcy', 'Б'),
7010			_Utils_Tuple2('bcy', 'б'),
7011			_Utils_Tuple2('bdquo', '„'),
7012			_Utils_Tuple2('becaus', '∵'),
7013			_Utils_Tuple2('because', '∵'),
7014			_Utils_Tuple2('Because', '∵'),
7015			_Utils_Tuple2('bemptyv', '⦰'),
7016			_Utils_Tuple2('bepsi', '϶'),
7017			_Utils_Tuple2('bernou', 'ℬ'),
7018			_Utils_Tuple2('Bernoullis', 'ℬ'),
7019			_Utils_Tuple2('Beta', 'Β'),
7020			_Utils_Tuple2('beta', 'β'),
7021			_Utils_Tuple2('beth', 'ℶ'),
7022			_Utils_Tuple2('between', '≬'),
7023			_Utils_Tuple2('Bfr', '\uD835\uDD05'),
7024			_Utils_Tuple2('bfr', '\uD835\uDD1F'),
7025			_Utils_Tuple2('bigcap', '⋂'),
7026			_Utils_Tuple2('bigcirc', '◯'),
7027			_Utils_Tuple2('bigcup', '⋃'),
7028			_Utils_Tuple2('bigodot', '⨀'),
7029			_Utils_Tuple2('bigoplus', '⨁'),
7030			_Utils_Tuple2('bigotimes', '⨂'),
7031			_Utils_Tuple2('bigsqcup', '⨆'),
7032			_Utils_Tuple2('bigstar', '★'),
7033			_Utils_Tuple2('bigtriangledown', '▽'),
7034			_Utils_Tuple2('bigtriangleup', '△'),
7035			_Utils_Tuple2('biguplus', '⨄'),
7036			_Utils_Tuple2('bigvee', '⋁'),
7037			_Utils_Tuple2('bigwedge', '⋀'),
7038			_Utils_Tuple2('bkarow', '⤍'),
7039			_Utils_Tuple2('blacklozenge', '⧫'),
7040			_Utils_Tuple2('blacksquare', '▪'),
7041			_Utils_Tuple2('blacktriangle', '▴'),
7042			_Utils_Tuple2('blacktriangledown', '▾'),
7043			_Utils_Tuple2('blacktriangleleft', '◂'),
7044			_Utils_Tuple2('blacktriangleright', '▸'),
7045			_Utils_Tuple2('blank', '␣'),
7046			_Utils_Tuple2('blk12', '▒'),
7047			_Utils_Tuple2('blk14', '░'),
7048			_Utils_Tuple2('blk34', '▓'),
7049			_Utils_Tuple2('block', '█'),
7050			_Utils_Tuple2('bne', '=⃥'),
7051			_Utils_Tuple2('bnequiv', '≡⃥'),
7052			_Utils_Tuple2('bNot', 'â«­'),
7053			_Utils_Tuple2('bnot', '⌐'),
7054			_Utils_Tuple2('Bopf', '\uD835\uDD39'),
7055			_Utils_Tuple2('bopf', '\uD835\uDD53'),
7056			_Utils_Tuple2('bot', '⊥'),
7057			_Utils_Tuple2('bottom', '⊥'),
7058			_Utils_Tuple2('bowtie', '⋈'),
7059			_Utils_Tuple2('boxbox', '⧉'),
7060			_Utils_Tuple2('boxdl', '┐'),
7061			_Utils_Tuple2('boxdL', '╕'),
7062			_Utils_Tuple2('boxDl', '╖'),

7063			_Utils_Tuple2('boxDL', '╗'),
7064			_Utils_Tuple2('boxdr', '┌'),
7065			_Utils_Tuple2('boxdR', '╒'),
7066			_Utils_Tuple2('boxDr', '╓'),
7067			_Utils_Tuple2('boxDR', '╔'),
7068			_Utils_Tuple2('boxh', '─'),
7069			_Utils_Tuple2('boxH', '═'),
7070			_Utils_Tuple2('boxhd', '┬'),
7071			_Utils_Tuple2('boxHd', '╤'),
7072			_Utils_Tuple2('boxhD', '╥'),
7073			_Utils_Tuple2('boxHD', '╦'),
7074			_Utils_Tuple2('boxhu', '┴'),
7075			_Utils_Tuple2('boxHu', '╧'),
7076			_Utils_Tuple2('boxhU', '╨'),
7077			_Utils_Tuple2('boxHU', '╩'),
7078			_Utils_Tuple2('boxminus', '⊟'),
7079			_Utils_Tuple2('boxplus', '⊞'),
7080			_Utils_Tuple2('boxtimes', '⊠'),
7081			_Utils_Tuple2('boxul', '┘'),
7082			_Utils_Tuple2('boxuL', '╛'),
7083			_Utils_Tuple2('boxUl', '╜'),
7084			_Utils_Tuple2('boxUL', '╝'),
7085			_Utils_Tuple2('boxur', '└'),
7086			_Utils_Tuple2('boxuR', '╘'),
7087			_Utils_Tuple2('boxUr', '╙'),
7088			_Utils_Tuple2('boxUR', '╚'),
7089			_Utils_Tuple2('boxv', '│'),
7090			_Utils_Tuple2('boxV', '║'),
7091			_Utils_Tuple2('boxvh', '┼'),
7092			_Utils_Tuple2('boxvH', '╪'),
7093			_Utils_Tuple2('boxVh', '╫'),
7094			_Utils_Tuple2('boxVH', '╬'),
7095			_Utils_Tuple2('boxvl', '┤'),
7096			_Utils_Tuple2('boxvL', '╡'),
7097			_Utils_Tuple2('boxVl', '╢'),
7098			_Utils_Tuple2('boxVL', '╣'),
7099			_Utils_Tuple2('boxvr', '├'),
7100			_Utils_Tuple2('boxvR', '╞'),
7101			_Utils_Tuple2('boxVr', '╟'),
7102			_Utils_Tuple2('boxVR', '╠'),
7103			_Utils_Tuple2('bprime', '‵'),
7104			_Utils_Tuple2('breve', '˘'),
7105			_Utils_Tuple2('Breve', '˘'),
7106			_Utils_Tuple2('brvbar', '¦'),
7107			_Utils_Tuple2('bscr', '\uD835\uDCB7'),
7108			_Utils_Tuple2('Bscr', 'ℬ'),
7109			_Utils_Tuple2('bsemi', '⁏'),
7110			_Utils_Tuple2('bsim', '∽'),
7111			_Utils_Tuple2('bsime', '⋍'),
7112			_Utils_Tuple2('bsolb', '⧅'),
7113			_Utils_Tuple2('bsol', '\\'),
7114			_Utils_Tuple2('bsolhsub', '⟈'),
7115			_Utils_Tuple2('bull', '•'),
7116			_Utils_Tuple2('bullet', '•'),
7117			_Utils_Tuple2('bump', '≎'),
7118			_Utils_Tuple2('bumpE', '⪮'),
7119			_Utils_Tuple2('bumpe', '≏'),
7120			_Utils_Tuple2('Bumpeq', '≎'),
7121			_Utils_Tuple2('bumpeq', '≏'),
7122			_Utils_Tuple2('Cacute', 'Ć'),
7123			_Utils_Tuple2('cacute', 'ć'),
7124			_Utils_Tuple2('capand', '⩄'),
7125			_Utils_Tuple2('capbrcup', '⩉'),
7126			_Utils_Tuple2('capcap', '⩋'),
7127			_Utils_Tuple2('cap', '∩'),
7128			_Utils_Tuple2('Cap', '⋒'),
7129			_Utils_Tuple2('capcup', '⩇'),
7130			_Utils_Tuple2('capdot', '⩀'),
7131			_Utils_Tuple2('CapitalDifferentialD', 'ⅅ'),
7132			_Utils_Tuple2('caps', '∩︀'),
7133			_Utils_Tuple2('caret', '⁁'),
7134			_Utils_Tuple2('caron', 'ˇ'),
7135			_Utils_Tuple2('Cayleys', 'ℭ'),
7136			_Utils_Tuple2('ccaps', '⩍'),
7137			_Utils_Tuple2('Ccaron', 'Č'),
7138			_Utils_Tuple2('ccaron', 'č'),
7139			_Utils_Tuple2('Ccedil', 'Ç'),
7140			_Utils_Tuple2('ccedil', 'ç'),
7141			_Utils_Tuple2('Ccirc', 'Ĉ'),
7142			_Utils_Tuple2('ccirc', 'ĉ'),
7143			_Utils_Tuple2('Cconint', '∰'),
7144			_Utils_Tuple2('ccups', '⩌'),
7145			_Utils_Tuple2('ccupssm', '⩐'),
7146			_Utils_Tuple2('Cdot', 'Ċ'),
7147			_Utils_Tuple2('cdot', 'ċ'),
7148			_Utils_Tuple2('cedil', '¸'),
7149			_Utils_Tuple2('Cedilla', '¸'),
7150			_Utils_Tuple2('cemptyv', '⦲'),
7151			_Utils_Tuple2('cent', '¢'),
7152			_Utils_Tuple2('centerdot', '·'),
7153			_Utils_Tuple2('CenterDot', '·'),
7154			_Utils_Tuple2('cfr', '\uD835\uDD20'),
7155			_Utils_Tuple2('Cfr', 'ℭ'),
7156			_Utils_Tuple2('CHcy', 'Ч'),
7157			_Utils_Tuple2('chcy', 'ч'),
7158			_Utils_Tuple2('check', '✓'),
7159			_Utils_Tuple2('checkmark', '✓'),
7160			_Utils_Tuple2('Chi', 'Χ'),
7161			_Utils_Tuple2('chi', 'χ'),
7162			_Utils_Tuple2('circ', 'ˆ'),
7163			_Utils_Tuple2('circeq', '≗'),
7164			_Utils_Tuple2('circlearrowleft', '↺'),
7165			_Utils_Tuple2('circlearrowright', '↻'),
7166			_Utils_Tuple2('circledast', '⊛'),
7167			_Utils_Tuple2('circledcirc', '⊚'),
7168			_Utils_Tuple2('circleddash', '⊝'),
7169			_Utils_Tuple2('CircleDot', '⊙'),
7170			_Utils_Tuple2('circledR', '®'),
7171			_Utils_Tuple2('circledS', 'Ⓢ'),
7172			_Utils_Tuple2('CircleMinus', '⊖'),
7173			_Utils_Tuple2('CirclePlus', '⊕'),
7174			_Utils_Tuple2('CircleTimes', '⊗'),
7175			_Utils_Tuple2('cir', '○'),
7176			_Utils_Tuple2('cirE', '⧃'),
7177			_Utils_Tuple2('cire', '≗'),
7178			_Utils_Tuple2('cirfnint', '⨐'),
7179			_Utils_Tuple2('cirmid', '⫯'),
7180			_Utils_Tuple2('cirscir', '⧂'),
7181			_Utils_Tuple2('ClockwiseContourIntegral', '∲'),
7182			_Utils_Tuple2('CloseCurlyDoubleQuote', '”'),
7183			_Utils_Tuple2('CloseCurlyQuote', '’'),
7184			_Utils_Tuple2('clubs', '♣'),
7185			_Utils_Tuple2('clubsuit', '♣'),
7186			_Utils_Tuple2('colon', ':'),
7187			_Utils_Tuple2('Colon', '∷'),
7188			_Utils_Tuple2('Colone', 'â©´'),
7189			_Utils_Tuple2('colone', '≔'),
7190			_Utils_Tuple2('coloneq', '≔'),
7191			_Utils_Tuple2('comma', ','),
7192			_Utils_Tuple2('commat', '@'),
7193			_Utils_Tuple2('comp', '∁'),
7194			_Utils_Tuple2('compfn', '∘'),
7195			_Utils_Tuple2('complement', '∁'),
7196			_Utils_Tuple2('complexes', 'ℂ'),
7197			_Utils_Tuple2('cong', '≅'),
7198			_Utils_Tuple2('congdot', 'â©­'),
7199			_Utils_Tuple2('Congruent', '≡'),
7200			_Utils_Tuple2('conint', '∮'),
7201			_Utils_Tuple2('Conint', '∯'),
7202			_Utils_Tuple2('ContourIntegral', '∮'),
7203			_Utils_Tuple2('copf', '\uD835\uDD54'),
7204			_Utils_Tuple2('Copf', 'ℂ'),
7205			_Utils_Tuple2('coprod', '∐'),
7206			_Utils_Tuple2('Coproduct', '∐'),
7207			_Utils_Tuple2('copy', '©'),
7208			_Utils_Tuple2('COPY', '©'),
7209			_Utils_Tuple2('copysr', '℗'),
7210			_Utils_Tuple2('CounterClockwiseContourIntegral', '∳'),
7211			_Utils_Tuple2('crarr', '↵'),
7212			_Utils_Tuple2('cross', '✗'),
7213			_Utils_Tuple2('Cross', '⨯'),
7214			_Utils_Tuple2('Cscr', '\uD835\uDC9E'),
7215			_Utils_Tuple2('cscr', '\uD835\uDCB8'),
7216			_Utils_Tuple2('csub', '⫏'),
7217			_Utils_Tuple2('csube', '⫑'),
7218			_Utils_Tuple2('csup', '⫐'),
7219			_Utils_Tuple2('csupe', '⫒'),
7220			_Utils_Tuple2('ctdot', '⋯'),
7221			_Utils_Tuple2('cudarrl', '⤸'),
7222			_Utils_Tuple2('cudarrr', '⤵'),
7223			_Utils_Tuple2('cuepr', '⋞'),
7224			_Utils_Tuple2('cuesc', '⋟'),
7225			_Utils_Tuple2('cularr', '↶'),
7226			_Utils_Tuple2('cularrp', '⤽'),
7227			_Utils_Tuple2('cupbrcap', '⩈'),
7228			_Utils_Tuple2('cupcap', '⩆'),
7229			_Utils_Tuple2('CupCap', '≍'),
7230			_Utils_Tuple2('cup', '∪'),
7231			_Utils_Tuple2('Cup', '⋓'),
7232			_Utils_Tuple2('cupcup', '⩊'),
7233			_Utils_Tuple2('cupdot', '⊍'),
7234			_Utils_Tuple2('cupor', '⩅'),
7235			_Utils_Tuple2('cups', '∪︀'),
7236			_Utils_Tuple2('curarr', '↷'),
7237			_Utils_Tuple2('curarrm', '⤼'),
7238			_Utils_Tuple2('curlyeqprec', '⋞'),
7239			_Utils_Tuple2('curlyeqsucc', '⋟'),
7240			_Utils_Tuple2('curlyvee', '⋎'),
7241			_Utils_Tuple2('curlywedge', '⋏'),
7242			_Utils_Tuple2('curren', '¤'),
7243			_Utils_Tuple2('curvearrowleft', '↶'),
7244			_Utils_Tuple2('curvearrowright', '↷'),
7245			_Utils_Tuple2('cuvee', '⋎'),
7246			_Utils_Tuple2('cuwed', '⋏'),
7247			_Utils_Tuple2('cwconint', '∲'),
7248			_Utils_Tuple2('cwint', '∱'),
7249			_Utils_Tuple2('cylcty', '⌭'),
7250			_Utils_Tuple2('dagger', '†'),
7251			_Utils_Tuple2('Dagger', '‡'),
7252			_Utils_Tuple2('daleth', 'ℸ'),
7253			_Utils_Tuple2('darr', '↓'),
7254			_Utils_Tuple2('Darr', '↡'),
7255			_Utils_Tuple2('dArr', '⇓'),
7256			_Utils_Tuple2('dash', '‐'),
7257			_Utils_Tuple2('Dashv', '⫤'),
7258			_Utils_Tuple2('dashv', '⊣'),
7259			_Utils_Tuple2('dbkarow', '⤏'),
7260			_Utils_Tuple2('dblac', '˝'),
7261			_Utils_Tuple2('Dcaron', 'Ď'),
7262			_Utils_Tuple2('dcaron', 'ď'),
7263			_Utils_Tuple2('Dcy', 'Д'),
7264			_Utils_Tuple2('dcy', 'д'),
7265			_Utils_Tuple2('ddagger', '‡'),
7266			_Utils_Tuple2('ddarr', '⇊'),
7267			_Utils_Tuple2('DD', 'ⅅ'),
7268			_Utils_Tuple2('dd', 'ⅆ'),
7269			_Utils_Tuple2('DDotrahd', '⤑'),
7270			_Utils_Tuple2('ddotseq', 'â©·'),
7271			_Utils_Tuple2('deg', '°'),
7272			_Utils_Tuple2('Del', '∇'),
7273			_Utils_Tuple2('Delta', 'Δ'),
7274			_Utils_Tuple2('delta', 'δ'),
7275			_Utils_Tuple2('demptyv', '⦱'),
7276			_Utils_Tuple2('dfisht', '⥿'),
7277			_Utils_Tuple2('Dfr', '\uD835\uDD07'),
7278			_Utils_Tuple2('dfr', '\uD835\uDD21'),
7279			_Utils_Tuple2('dHar', '⥥'),
7280			_Utils_Tuple2('dharl', '⇃'),
7281			_Utils_Tuple2('dharr', '⇂'),
7282			_Utils_Tuple2('DiacriticalAcute', '´'),
7283			_Utils_Tuple2('DiacriticalDot', '˙'),

7284			_Utils_Tuple2('DiacriticalDoubleAcute', '˝'),
7285			_Utils_Tuple2('DiacriticalGrave', '`'),
7286			_Utils_Tuple2('DiacriticalTilde', '˜'),
7287			_Utils_Tuple2('diam', '⋄'),
7288			_Utils_Tuple2('diamond', '⋄'),
7289			_Utils_Tuple2('Diamond', '⋄'),
7290			_Utils_Tuple2('diamondsuit', '♦'),
7291			_Utils_Tuple2('diams', '♦'),
7292			_Utils_Tuple2('die', '¨'),
7293			_Utils_Tuple2('DifferentialD', 'ⅆ'),
7294			_Utils_Tuple2('digamma', 'ϝ'),
7295			_Utils_Tuple2('disin', '⋲'),
7296			_Utils_Tuple2('div', '÷'),
7297			_Utils_Tuple2('divide', '÷'),
7298			_Utils_Tuple2('divideontimes', '⋇'),
7299			_Utils_Tuple2('divonx', '⋇'),
7300			_Utils_Tuple2('DJcy', 'Ђ'),
7301			_Utils_Tuple2('djcy', 'ђ'),
7302			_Utils_Tuple2('dlcorn', '⌞'),
7303			_Utils_Tuple2('dlcrop', '⌍'),
7304			_Utils_Tuple2('dollar', '$'),
7305			_Utils_Tuple2('Dopf', '\uD835\uDD3B'),
7306			_Utils_Tuple2('dopf', '\uD835\uDD55'),
7307			_Utils_Tuple2('Dot', '¨'),
7308			_Utils_Tuple2('dot', '˙'),
7309			_Utils_Tuple2('DotDot', '⃜'),
7310			_Utils_Tuple2('doteq', '≐'),
7311			_Utils_Tuple2('doteqdot', '≑'),
7312			_Utils_Tuple2('DotEqual', '≐'),
7313			_Utils_Tuple2('dotminus', '∸'),
7314			_Utils_Tuple2('dotplus', '∔'),
7315			_Utils_Tuple2('dotsquare', '⊡'),
7316			_Utils_Tuple2('doublebarwedge', '⌆'),
7317			_Utils_Tuple2('DoubleContourIntegral', '∯'),
7318			_Utils_Tuple2('DoubleDot', '¨'),
7319			_Utils_Tuple2('DoubleDownArrow', '⇓'),
7320			_Utils_Tuple2('DoubleLeftArrow', '⇐'),
7321			_Utils_Tuple2('DoubleLeftRightArrow', '⇔'),
7322			_Utils_Tuple2('DoubleLeftTee', '⫤'),
7323			_Utils_Tuple2('DoubleLongLeftArrow', '⟸'),
7324			_Utils_Tuple2('DoubleLongLeftRightArrow', '⟺'),
7325			_Utils_Tuple2('DoubleLongRightArrow', '⟹'),
7326			_Utils_Tuple2('DoubleRightArrow', '⇒'),
7327			_Utils_Tuple2('DoubleRightTee', '⊨'),
7328			_Utils_Tuple2('DoubleUpArrow', '⇑'),
7329			_Utils_Tuple2('DoubleUpDownArrow', '⇕'),
7330			_Utils_Tuple2('DoubleVerticalBar', '∥'),
7331			_Utils_Tuple2('DownArrowBar', '⤓'),
7332			_Utils_Tuple2('downarrow', '↓'),
7333			_Utils_Tuple2('DownArrow', '↓'),
7334			_Utils_Tuple2('Downarrow', '⇓'),
7335			_Utils_Tuple2('DownArrowUpArrow', '⇵'),
7336			_Utils_Tuple2('DownBreve', '̑'),
7337			_Utils_Tuple2('downdownarrows', '⇊'),
7338			_Utils_Tuple2('downharpoonleft', '⇃'),
7339			_Utils_Tuple2('downharpoonright', '⇂'),
7340			_Utils_Tuple2('DownLeftRightVector', '⥐'),
7341			_Utils_Tuple2('DownLeftTeeVector', '⥞'),
7342			_Utils_Tuple2('DownLeftVectorBar', '⥖'),
7343			_Utils_Tuple2('DownLeftVector', '↽'),
7344			_Utils_Tuple2('DownRightTeeVector', '⥟'),
7345			_Utils_Tuple2('DownRightVectorBar', '⥗'),
7346			_Utils_Tuple2('DownRightVector', '⇁'),
7347			_Utils_Tuple2('DownTeeArrow', '↧'),
7348			_Utils_Tuple2('DownTee', '⊤'),
7349			_Utils_Tuple2('drbkarow', '⤐'),
7350			_Utils_Tuple2('drcorn', '⌟'),
7351			_Utils_Tuple2('drcrop', '⌌'),
7352			_Utils_Tuple2('Dscr', '\uD835\uDC9F'),
7353			_Utils_Tuple2('dscr', '\uD835\uDCB9'),
7354			_Utils_Tuple2('DScy', 'Ѕ'),
7355			_Utils_Tuple2('dscy', 'ѕ'),
7356			_Utils_Tuple2('dsol', '⧶'),
7357			_Utils_Tuple2('Dstrok', 'Đ'),
7358			_Utils_Tuple2('dstrok', 'đ'),
7359			_Utils_Tuple2('dtdot', '⋱'),
7360			_Utils_Tuple2('dtri', '▿'),
7361			_Utils_Tuple2('dtrif', '▾'),
7362			_Utils_Tuple2('duarr', '⇵'),
7363			_Utils_Tuple2('duhar', '⥯'),
7364			_Utils_Tuple2('dwangle', '⦦'),
7365			_Utils_Tuple2('DZcy', 'Џ'),
7366			_Utils_Tuple2('dzcy', 'џ'),
7367			_Utils_Tuple2('dzigrarr', '⟿'),
7368			_Utils_Tuple2('Eacute', 'É'),
7369			_Utils_Tuple2('eacute', 'é'),
7370			_Utils_Tuple2('easter', 'â©®'),
7371			_Utils_Tuple2('Ecaron', 'Ě'),
7372			_Utils_Tuple2('ecaron', 'ě'),
7373			_Utils_Tuple2('Ecirc', 'Ê'),
7374			_Utils_Tuple2('ecirc', 'ê'),
7375			_Utils_Tuple2('ecir', '≖'),
7376			_Utils_Tuple2('ecolon', '≕'),
7377			_Utils_Tuple2('Ecy', 'Э'),
7378			_Utils_Tuple2('ecy', 'э'),
7379			_Utils_Tuple2('eDDot', 'â©·'),
7380			_Utils_Tuple2('Edot', 'Ė'),
7381			_Utils_Tuple2('edot', 'ė'),
7382			_Utils_Tuple2('eDot', '≑'),
7383			_Utils_Tuple2('ee', 'ⅇ'),
7384			_Utils_Tuple2('efDot', '≒'),
7385			_Utils_Tuple2('Efr', '\uD835\uDD08'),
7386			_Utils_Tuple2('efr', '\uD835\uDD22'),
7387			_Utils_Tuple2('eg', '⪚'),
7388			_Utils_Tuple2('Egrave', 'È'),
7389			_Utils_Tuple2('egrave', 'è'),
7390			_Utils_Tuple2('egs', '⪖'),
7391			_Utils_Tuple2('egsdot', '⪘'),
7392			_Utils_Tuple2('el', '⪙'),
7393			_Utils_Tuple2('Element', '∈'),
7394			_Utils_Tuple2('elinters', '⏧'),
7395			_Utils_Tuple2('ell', 'ℓ'),
7396			_Utils_Tuple2('els', '⪕'),
7397			_Utils_Tuple2('elsdot', '⪗'),
7398			_Utils_Tuple2('Emacr', 'Ē'),
7399			_Utils_Tuple2('emacr', 'ē'),
7400			_Utils_Tuple2('empty', '∅'),
7401			_Utils_Tuple2('emptyset', '∅'),
7402			_Utils_Tuple2('EmptySmallSquare', '◻'),
7403			_Utils_Tuple2('emptyv', '∅'),
7404			_Utils_Tuple2('EmptyVerySmallSquare', '▫'),
7405			_Utils_Tuple2('emsp13', '\u2004'),
7406			_Utils_Tuple2('emsp14', '\u2005'),
7407			_Utils_Tuple2('emsp', '\u2003'),
7408			_Utils_Tuple2('ENG', 'Ŋ'),
7409			_Utils_Tuple2('eng', 'ŋ'),
7410			_Utils_Tuple2('ensp', '\u2002'),
7411			_Utils_Tuple2('Eogon', 'Ę'),
7412			_Utils_Tuple2('eogon', 'ę'),
7413			_Utils_Tuple2('Eopf', '\uD835\uDD3C'),
7414			_Utils_Tuple2('eopf', '\uD835\uDD56'),
7415			_Utils_Tuple2('epar', '⋕'),
7416			_Utils_Tuple2('eparsl', '⧣'),
7417			_Utils_Tuple2('eplus', '⩱'),
7418			_Utils_Tuple2('epsi', 'ε'),
7419			_Utils_Tuple2('Epsilon', 'Ε'),
7420			_Utils_Tuple2('epsilon', 'ε'),
7421			_Utils_Tuple2('epsiv', 'ϵ'),
7422			_Utils_Tuple2('eqcirc', '≖'),
7423			_Utils_Tuple2('eqcolon', '≕'),
7424			_Utils_Tuple2('eqsim', '≂'),
7425			_Utils_Tuple2('eqslantgtr', '⪖'),
7426			_Utils_Tuple2('eqslantless', '⪕'),
7427			_Utils_Tuple2('Equal', '⩵'),
7428			_Utils_Tuple2('equals', '='),
7429			_Utils_Tuple2('EqualTilde', '≂'),
7430			_Utils_Tuple2('equest', '≟'),
7431			_Utils_Tuple2('Equilibrium', '⇌'),
7432			_Utils_Tuple2('equiv', '≡'),
7433			_Utils_Tuple2('equivDD', '⩸'),
7434			_Utils_Tuple2('eqvparsl', '⧥'),
7435			_Utils_Tuple2('erarr', '⥱'),
7436			_Utils_Tuple2('erDot', '≓'),
7437			_Utils_Tuple2('escr', 'ℯ'),
7438			_Utils_Tuple2('Escr', 'ℰ'),
7439			_Utils_Tuple2('esdot', '≐'),
7440			_Utils_Tuple2('Esim', '⩳'),
7441			_Utils_Tuple2('esim', '≂'),
7442			_Utils_Tuple2('Eta', 'Η'),
7443			_Utils_Tuple2('eta', 'η'),
7444			_Utils_Tuple2('ETH', 'Ð'),
7445			_Utils_Tuple2('eth', 'ð'),
7446			_Utils_Tuple2('Euml', 'Ë'),
7447			_Utils_Tuple2('euml', 'ë'),
7448			_Utils_Tuple2('euro', '€'),
7449			_Utils_Tuple2('excl', '!'),
7450			_Utils_Tuple2('exist', '∃'),
7451			_Utils_Tuple2('Exists', '∃'),
7452			_Utils_Tuple2('expectation', 'ℰ'),
7453			_Utils_Tuple2('exponentiale', 'ⅇ'),
7454			_Utils_Tuple2('ExponentialE', 'ⅇ'),
7455			_Utils_Tuple2('fallingdotseq', '≒'),
7456			_Utils_Tuple2('Fcy', 'Ф'),
7457			_Utils_Tuple2('fcy', 'ф'),
7458			_Utils_Tuple2('female', '♀'),
7459			_Utils_Tuple2('ffilig', 'ffi'),
7460			_Utils_Tuple2('fflig', 'ff'),
7461			_Utils_Tuple2('ffllig', 'ffl'),

7462			_Utils_Tuple2('Ffr', '\uD835\uDD09'),
7463			_Utils_Tuple2('ffr', '\uD835\uDD23'),
7464			_Utils_Tuple2('filig', 'fi'),
7465			_Utils_Tuple2('FilledSmallSquare', '◼'),
7466			_Utils_Tuple2('FilledVerySmallSquare', '▪'),
7467			_Utils_Tuple2('fjlig', 'fj'),
7468			_Utils_Tuple2('flat', '♭'),
7469			_Utils_Tuple2('fllig', 'fl'),
7470			_Utils_Tuple2('fltns', '▱'),
7471			_Utils_Tuple2('fnof', 'ƒ'),
7472			_Utils_Tuple2('Fopf', '\uD835\uDD3D'),
7473			_Utils_Tuple2('fopf', '\uD835\uDD57'),
7474			_Utils_Tuple2('forall', '∀'),
7475			_Utils_Tuple2('ForAll', '∀'),
7476			_Utils_Tuple2('fork', '⋔'),
7477			_Utils_Tuple2('forkv', '⫙'),
7478			_Utils_Tuple2('Fouriertrf', 'ℱ'),
7479			_Utils_Tuple2('fpartint', '⨍'),
7480			_Utils_Tuple2('frac12', '½'),
7481			_Utils_Tuple2('frac13', '⅓'),
7482			_Utils_Tuple2('frac14', '¼'),
7483			_Utils_Tuple2('frac15', '⅕'),
7484			_Utils_Tuple2('frac16', '⅙'),
7485			_Utils_Tuple2('frac18', '⅛'),
7486			_Utils_Tuple2('frac23', '⅔'),
7487			_Utils_Tuple2('frac25', '⅖'),
7488			_Utils_Tuple2('frac34', '¾'),
7489			_Utils_Tuple2('frac35', '⅗'),
7490			_Utils_Tuple2('frac38', '⅜'),
7491			_Utils_Tuple2('frac45', '⅘'),
7492			_Utils_Tuple2('frac56', '⅚'),
7493			_Utils_Tuple2('frac58', '⅝'),
7494			_Utils_Tuple2('frac78', '⅞'),
7495			_Utils_Tuple2('frasl', '⁄'),
7496			_Utils_Tuple2('frown', '⌢'),
7497			_Utils_Tuple2('fscr', '\uD835\uDCBB'),
7498			_Utils_Tuple2('Fscr', 'ℱ'),
7499			_Utils_Tuple2('gacute', 'ǵ'),
7500			_Utils_Tuple2('Gamma', 'Γ'),
7501			_Utils_Tuple2('gamma', 'γ'),
7502			_Utils_Tuple2('Gammad', 'Ϝ'),
7503			_Utils_Tuple2('gammad', 'ϝ'),
7504			_Utils_Tuple2('gap', '⪆'),
7505			_Utils_Tuple2('Gbreve', 'Ğ'),
7506			_Utils_Tuple2('gbreve', 'ğ'),
7507			_Utils_Tuple2('Gcedil', 'Ä¢'),
7508			_Utils_Tuple2('Gcirc', 'Ĝ'),
7509			_Utils_Tuple2('gcirc', 'ĝ'),
7510			_Utils_Tuple2('Gcy', 'Г'),
7511			_Utils_Tuple2('gcy', 'г'),
7512			_Utils_Tuple2('Gdot', 'Ä '),
7513			_Utils_Tuple2('gdot', 'Ä¡'),
7514			_Utils_Tuple2('ge', '≥'),
7515			_Utils_Tuple2('gE', '≧'),
7516			_Utils_Tuple2('gEl', '⪌'),
7517			_Utils_Tuple2('gel', '⋛'),
7518			_Utils_Tuple2('geq', '≥'),
7519			_Utils_Tuple2('geqq', '≧'),
7520			_Utils_Tuple2('geqslant', '⩾'),
7521			_Utils_Tuple2('gescc', '⪩'),
7522			_Utils_Tuple2('ges', '⩾'),
7523			_Utils_Tuple2('gesdot', '⪀'),
7524			_Utils_Tuple2('gesdoto', '⪂'),
7525			_Utils_Tuple2('gesdotol', '⪄'),
7526			_Utils_Tuple2('gesl', '⋛︀'),
7527			_Utils_Tuple2('gesles', '⪔'),
7528			_Utils_Tuple2('Gfr', '\uD835\uDD0A'),
7529			_Utils_Tuple2('gfr', '\uD835\uDD24'),
7530			_Utils_Tuple2('gg', '≫'),
7531			_Utils_Tuple2('Gg', '⋙'),
7532			_Utils_Tuple2('ggg', '⋙'),
7533			_Utils_Tuple2('gimel', 'ℷ'),
7534			_Utils_Tuple2('GJcy', 'Ѓ'),
7535			_Utils_Tuple2('gjcy', 'ѓ'),
7536			_Utils_Tuple2('gla', '⪥'),
7537			_Utils_Tuple2('gl', '≷'),
7538			_Utils_Tuple2('glE', '⪒'),
7539			_Utils_Tuple2('glj', '⪤'),
7540			_Utils_Tuple2('gnap', '⪊'),
7541			_Utils_Tuple2('gnapprox', '⪊'),
7542			_Utils_Tuple2('gne', '⪈'),
7543			_Utils_Tuple2('gnE', '≩'),
7544			_Utils_Tuple2('gneq', '⪈'),
7545			_Utils_Tuple2('gneqq', '≩'),
7546			_Utils_Tuple2('gnsim', '⋧'),
7547			_Utils_Tuple2('Gopf', '\uD835\uDD3E'),
7548			_Utils_Tuple2('gopf', '\uD835\uDD58'),
7549			_Utils_Tuple2('grave', '`'),
7550			_Utils_Tuple2('GreaterEqual', '≥'),
7551			_Utils_Tuple2('GreaterEqualLess', '⋛'),
7552			_Utils_Tuple2('GreaterFullEqual', '≧'),
7553			_Utils_Tuple2('GreaterGreater', '⪢'),
7554			_Utils_Tuple2('GreaterLess', '≷'),
7555			_Utils_Tuple2('GreaterSlantEqual', '⩾'),
7556			_Utils_Tuple2('GreaterTilde', '≳'),
7557			_Utils_Tuple2('Gscr', '\uD835\uDCA2'),
7558			_Utils_Tuple2('gscr', 'ℊ'),
7559			_Utils_Tuple2('gsim', '≳'),
7560			_Utils_Tuple2('gsime', '⪎'),
7561			_Utils_Tuple2('gsiml', '⪐'),
7562			_Utils_Tuple2('gtcc', '⪧'),
7563			_Utils_Tuple2('gtcir', '⩺'),
7564			_Utils_Tuple2('gt', '>'),
7565			_Utils_Tuple2('GT', '>'),
7566			_Utils_Tuple2('Gt', '≫'),
7567			_Utils_Tuple2('gtdot', '⋗'),
7568			_Utils_Tuple2('gtlPar', '⦕'),
7569			_Utils_Tuple2('gtquest', '⩼'),
7570			_Utils_Tuple2('gtrapprox', '⪆'),
7571			_Utils_Tuple2('gtrarr', '⥸'),
7572			_Utils_Tuple2('gtrdot', '⋗'),
7573			_Utils_Tuple2('gtreqless', '⋛'),
7574			_Utils_Tuple2('gtreqqless', '⪌'),
7575			_Utils_Tuple2('gtrless', '≷'),
7576			_Utils_Tuple2('gtrsim', '≳'),
7577			_Utils_Tuple2('gvertneqq', '≩︀'),
7578			_Utils_Tuple2('gvnE', '≩︀'),
7579			_Utils_Tuple2('Hacek', 'ˇ'),
7580			_Utils_Tuple2('hairsp', '\u200A'),
7581			_Utils_Tuple2('half', '½'),
7582			_Utils_Tuple2('hamilt', 'ℋ'),
7583			_Utils_Tuple2('HARDcy', 'Ъ'),
7584			_Utils_Tuple2('hardcy', 'ъ'),
7585			_Utils_Tuple2('harrcir', '⥈'),
7586			_Utils_Tuple2('harr', '↔'),
7587			_Utils_Tuple2('hArr', '⇔'),
7588			_Utils_Tuple2('harrw', '↭'),
7589			_Utils_Tuple2('Hat', '^'),
7590			_Utils_Tuple2('hbar', 'ℏ'),
7591			_Utils_Tuple2('Hcirc', 'Ĥ'),
7592			_Utils_Tuple2('hcirc', 'Ä¥'),
7593			_Utils_Tuple2('hearts', '♥'),
7594			_Utils_Tuple2('heartsuit', '♥'),
7595			_Utils_Tuple2('hellip', '…'),
7596			_Utils_Tuple2('hercon', '⊹'),
7597			_Utils_Tuple2('hfr', '\uD835\uDD25'),
7598			_Utils_Tuple2('Hfr', 'ℌ'),
7599			_Utils_Tuple2('HilbertSpace', 'ℋ'),
7600			_Utils_Tuple2('hksearow', '⤥'),
7601			_Utils_Tuple2('hkswarow', '⤦'),
7602			_Utils_Tuple2('hoarr', '⇿'),
7603			_Utils_Tuple2('homtht', '∻'),
7604			_Utils_Tuple2('hookleftarrow', '↩'),
7605			_Utils_Tuple2('hookrightarrow', '↪'),
7606			_Utils_Tuple2('hopf', '\uD835\uDD59'),
7607			_Utils_Tuple2('Hopf', 'ℍ'),
7608			_Utils_Tuple2('horbar', '―'),
7609			_Utils_Tuple2('HorizontalLine', '─'),
7610			_Utils_Tuple2('hscr', '\uD835\uDCBD'),
7611			_Utils_Tuple2('Hscr', 'ℋ'),
7612			_Utils_Tuple2('hslash', 'ℏ'),
7613			_Utils_Tuple2('Hstrok', 'Ħ'),
7614			_Utils_Tuple2('hstrok', 'ħ'),
7615			_Utils_Tuple2('HumpDownHump', '≎'),
7616			_Utils_Tuple2('HumpEqual', '≏'),
7617			_Utils_Tuple2('hybull', '⁃'),
7618			_Utils_Tuple2('hyphen', '‐'),
7619			_Utils_Tuple2('Iacute', 'Í'),
7620			_Utils_Tuple2('iacute', 'í'),
7621			_Utils_Tuple2('ic', '\u2063'),
7622			_Utils_Tuple2('Icirc', 'Î'),
7623			_Utils_Tuple2('icirc', 'î'),
7624			_Utils_Tuple2('Icy', 'И'),
7625			_Utils_Tuple2('icy', 'и'),
7626			_Utils_Tuple2('Idot', 'Ä°'),
7627			_Utils_Tuple2('IEcy', 'Е'),
7628			_Utils_Tuple2('iecy', 'е'),
7629			_Utils_Tuple2('iexcl', '¡'),
7630			_Utils_Tuple2('iff', '⇔'),
7631			_Utils_Tuple2('ifr', '\uD835\uDD26'),
7632			_Utils_Tuple2('Ifr', 'ℑ'),
7633			_Utils_Tuple2('Igrave', 'Ì'),
7634			_Utils_Tuple2('igrave', 'ì'),
7635			_Utils_Tuple2('ii', 'ⅈ'),
7636			_Utils_Tuple2('iiiint', '⨌'),
7637			_Utils_Tuple2('iiint', '∭'),
7638			_Utils_Tuple2('iinfin', '⧜'),
7639			_Utils_Tuple2('iiota', '℩'),
7640			_Utils_Tuple2('IJlig', 'IJ'),
7641			_Utils_Tuple2('ijlig', 'ij'),
7642			_Utils_Tuple2('Imacr', 'Ī'),
7643			_Utils_Tuple2('imacr', 'Ä«'),
7644			_Utils_Tuple2('image', 'ℑ'),
7645			_Utils_Tuple2('ImaginaryI', 'ⅈ'),
7646			_Utils_Tuple2('imagline', 'ℐ'),
7647			_Utils_Tuple2('imagpart', 'ℑ'),
7648			_Utils_Tuple2('imath', 'ı'),
7649			_Utils_Tuple2('Im', 'ℑ'),
7650			_Utils_Tuple2('imof', '⊷'),
7651			_Utils_Tuple2('imped', 'Ƶ'),
7652			_Utils_Tuple2('Implies', '⇒'),
7653			_Utils_Tuple2('incare', '℅'),
7654			_Utils_Tuple2('in', '∈'),
7655			_Utils_Tuple2('infin', '∞'),
7656			_Utils_Tuple2('infintie', '⧝'),
7657			_Utils_Tuple2('inodot', 'ı'),
7658			_Utils_Tuple2('intcal', '⊺'),
7659			_Utils_Tuple2('int', '∫'),
7660			_Utils_Tuple2('Int', '∬'),
7661			_Utils_Tuple2('integers', 'ℤ'),
7662			_Utils_Tuple2('Integral', '∫'),
7663			_Utils_Tuple2('intercal', '⊺'),
7664			_Utils_Tuple2('Intersection', '⋂'),

7665			_Utils_Tuple2('intlarhk', '⨗'),
7666			_Utils_Tuple2('intprod', '⨼'),
7667			_Utils_Tuple2('InvisibleComma', '\u2063'),
7668			_Utils_Tuple2('InvisibleTimes', '\u2062'),
7669			_Utils_Tuple2('IOcy', 'Ё'),
7670			_Utils_Tuple2('iocy', 'ё'),
7671			_Utils_Tuple2('Iogon', 'Ä®'),
7672			_Utils_Tuple2('iogon', 'į'),
7673			_Utils_Tuple2('Iopf', '\uD835\uDD40'),
7674			_Utils_Tuple2('iopf', '\uD835\uDD5A'),
7675			_Utils_Tuple2('Iota', 'Ι'),
7676			_Utils_Tuple2('iota', 'ι'),
7677			_Utils_Tuple2('iprod', '⨼'),
7678			_Utils_Tuple2('iquest', '¿'),
7679			_Utils_Tuple2('iscr', '\uD835\uDCBE'),
7680			_Utils_Tuple2('Iscr', 'ℐ'),
7681			_Utils_Tuple2('isin', '∈'),
7682			_Utils_Tuple2('isindot', '⋵'),
7683			_Utils_Tuple2('isinE', '⋹'),
7684			_Utils_Tuple2('isins', '⋴'),
7685			_Utils_Tuple2('isinsv', '⋳'),
7686			_Utils_Tuple2('isinv', '∈'),
7687			_Utils_Tuple2('it', '\u2062'),
7688			_Utils_Tuple2('Itilde', 'Ĩ'),
7689			_Utils_Tuple2('itilde', 'Ä©'),
7690			_Utils_Tuple2('Iukcy', 'І'),
7691			_Utils_Tuple2('iukcy', 'і'),
7692			_Utils_Tuple2('Iuml', 'Ï'),
7693			_Utils_Tuple2('iuml', 'ï'),
7694			_Utils_Tuple2('Jcirc', 'Ä´'),
7695			_Utils_Tuple2('jcirc', 'ĵ'),
7696			_Utils_Tuple2('Jcy', 'Й'),
7697			_Utils_Tuple2('jcy', 'й'),
7698			_Utils_Tuple2('Jfr', '\uD835\uDD0D'),
7699			_Utils_Tuple2('jfr', '\uD835\uDD27'),
7700			_Utils_Tuple2('jmath', 'È·'),
7701			_Utils_Tuple2('Jopf', '\uD835\uDD41'),
7702			_Utils_Tuple2('jopf', '\uD835\uDD5B'),
7703			_Utils_Tuple2('Jscr', '\uD835\uDCA5'),
7704			_Utils_Tuple2('jscr', '\uD835\uDCBF'),
7705			_Utils_Tuple2('Jsercy', 'Ј'),
7706			_Utils_Tuple2('jsercy', 'ј'),
7707			_Utils_Tuple2('Jukcy', 'Є'),
7708			_Utils_Tuple2('jukcy', 'є'),
7709			_Utils_Tuple2('Kappa', 'Κ'),
7710			_Utils_Tuple2('kappa', 'κ'),
7711			_Utils_Tuple2('kappav', 'Ï°'),
7712			_Utils_Tuple2('Kcedil', 'Ķ'),
7713			_Utils_Tuple2('kcedil', 'Ä·'),
7714			_Utils_Tuple2('Kcy', 'К'),
7715			_Utils_Tuple2('kcy', 'к'),
7716			_Utils_Tuple2('Kfr', '\uD835\uDD0E'),
7717			_Utils_Tuple2('kfr', '\uD835\uDD28'),
7718			_Utils_Tuple2('kgreen', 'ĸ'),
7719			_Utils_Tuple2('KHcy', 'Ð¥'),
7720			_Utils_Tuple2('khcy', 'х'),
7721			_Utils_Tuple2('KJcy', 'Ќ'),
7722			_Utils_Tuple2('kjcy', 'ќ'),
7723			_Utils_Tuple2('Kopf', '\uD835\uDD42'),
7724			_Utils_Tuple2('kopf', '\uD835\uDD5C'),
7725			_Utils_Tuple2('Kscr', '\uD835\uDCA6'),
7726			_Utils_Tuple2('kscr', '\uD835\uDCC0'),
7727			_Utils_Tuple2('lAarr', '⇚'),
7728			_Utils_Tuple2('Lacute', 'Ĺ'),
7729			_Utils_Tuple2('lacute', 'ĺ'),
7730			_Utils_Tuple2('laemptyv', '⦴'),
7731			_Utils_Tuple2('lagran', 'ℒ'),
7732			_Utils_Tuple2('Lambda', 'Λ'),
7733			_Utils_Tuple2('lambda', 'λ'),
7734			_Utils_Tuple2('lang', '⟨'),
7735			_Utils_Tuple2('Lang', '⟪'),
7736			_Utils_Tuple2('langd', '⦑'),
7737			_Utils_Tuple2('langle', '⟨'),
7738			_Utils_Tuple2('lap', '⪅'),
7739			_Utils_Tuple2('Laplacetrf', 'ℒ'),
7740			_Utils_Tuple2('laquo', '«'),
7741			_Utils_Tuple2('larrb', '⇤'),
7742			_Utils_Tuple2('larrbfs', '⤟'),
7743			_Utils_Tuple2('larr', '←'),
7744			_Utils_Tuple2('Larr', '↞'),
7745			_Utils_Tuple2('lArr', '⇐'),
7746			_Utils_Tuple2('larrfs', '⤝'),
7747			_Utils_Tuple2('larrhk', '↩'),
7748			_Utils_Tuple2('larrlp', '↫'),
7749			_Utils_Tuple2('larrpl', '⤹'),
7750			_Utils_Tuple2('larrsim', '⥳'),
7751			_Utils_Tuple2('larrtl', '↢'),
7752			_Utils_Tuple2('latail', '⤙'),
7753			_Utils_Tuple2('lAtail', '⤛'),
7754			_Utils_Tuple2('lat', '⪫'),
7755			_Utils_Tuple2('late', '⪭'),
7756			_Utils_Tuple2('lates', '⪭︀'),
7757			_Utils_Tuple2('lbarr', '⤌'),
7758			_Utils_Tuple2('lBarr', '⤎'),
7759			_Utils_Tuple2('lbbrk', '❲'),
7760			_Utils_Tuple2('lbrace', '{'),
7761			_Utils_Tuple2('lbrack', '['),
7762			_Utils_Tuple2('lbrke', '⦋'),
7763			_Utils_Tuple2('lbrksld', '⦏'),
7764			_Utils_Tuple2('lbrkslu', '⦍'),
7765			_Utils_Tuple2('Lcaron', 'Ľ'),
7766			_Utils_Tuple2('lcaron', 'ľ'),
7767			_Utils_Tuple2('Lcedil', 'Ä»'),
7768			_Utils_Tuple2('lcedil', 'ļ'),
7769			_Utils_Tuple2('lceil', '⌈'),
7770			_Utils_Tuple2('lcub', '{'),
7771			_Utils_Tuple2('Lcy', 'Л'),
7772			_Utils_Tuple2('lcy', 'л'),
7773			_Utils_Tuple2('ldca', '⤶'),
7774			_Utils_Tuple2('ldquo', '“'),
7775			_Utils_Tuple2('ldquor', '„'),
7776			_Utils_Tuple2('ldrdhar', '⥧'),
7777			_Utils_Tuple2('ldrushar', '⥋'),
7778			_Utils_Tuple2('ldsh', '↲'),
7779			_Utils_Tuple2('le', '≤'),
7780			_Utils_Tuple2('lE', '≦'),
7781			_Utils_Tuple2('LeftAngleBracket', '⟨'),
7782			_Utils_Tuple2('LeftArrowBar', '⇤'),
7783			_Utils_Tuple2('leftarrow', '←'),
7784			_Utils_Tuple2('LeftArrow', '←'),
7785			_Utils_Tuple2('Leftarrow', '⇐'),
7786			_Utils_Tuple2('LeftArrowRightArrow', '⇆'),
7787			_Utils_Tuple2('leftarrowtail', '↢'),
7788			_Utils_Tuple2('LeftCeiling', '⌈'),
7789			_Utils_Tuple2('LeftDoubleBracket', '⟦'),
7790			_Utils_Tuple2('LeftDownTeeVector', '⥡'),
7791			_Utils_Tuple2('LeftDownVectorBar', '⥙'),
7792			_Utils_Tuple2('LeftDownVector', '⇃'),
7793			_Utils_Tuple2('LeftFloor', '⌊'),
7794			_Utils_Tuple2('leftharpoondown', '↽'),

7795			_Utils_Tuple2('leftharpoonup', '↼'),
7796			_Utils_Tuple2('leftleftarrows', '⇇'),
7797			_Utils_Tuple2('leftrightarrow', '↔'),
7798			_Utils_Tuple2('LeftRightArrow', '↔'),
7799			_Utils_Tuple2('Leftrightarrow', '⇔'),
7800			_Utils_Tuple2('leftrightarrows', '⇆'),
7801			_Utils_Tuple2('leftrightharpoons', '⇋'),
7802			_Utils_Tuple2('leftrightsquigarrow', '↭'),
7803			_Utils_Tuple2('LeftRightVector', '⥎'),
7804			_Utils_Tuple2('LeftTeeArrow', '↤'),
7805			_Utils_Tuple2('LeftTee', '⊣'),
7806			_Utils_Tuple2('LeftTeeVector', '⥚'),
7807			_Utils_Tuple2('leftthreetimes', '⋋'),
7808			_Utils_Tuple2('LeftTriangleBar', '⧏'),
7809			_Utils_Tuple2('LeftTriangle', '⊲'),
7810			_Utils_Tuple2('LeftTriangleEqual', '⊴'),
7811			_Utils_Tuple2('LeftUpDownVector', '⥑'),
7812			_Utils_Tuple2('LeftUpTeeVector', '⥠'),
7813			_Utils_Tuple2('LeftUpVectorBar', '⥘'),
7814			_Utils_Tuple2('LeftUpVector', '↿'),
7815			_Utils_Tuple2('LeftVectorBar', '⥒'),
7816			_Utils_Tuple2('LeftVector', '↼'),
7817			_Utils_Tuple2('lEg', '⪋'),
7818			_Utils_Tuple2('leg', '⋚'),
7819			_Utils_Tuple2('leq', '≤'),
7820			_Utils_Tuple2('leqq', '≦'),
7821			_Utils_Tuple2('leqslant', '⩽'),
7822			_Utils_Tuple2('lescc', '⪨'),
7823			_Utils_Tuple2('les', '⩽'),
7824			_Utils_Tuple2('lesdot', 'â©¿'),
7825			_Utils_Tuple2('lesdoto', '⪁'),
7826			_Utils_Tuple2('lesdotor', '⪃'),
7827			_Utils_Tuple2('lesg', '⋚︀'),
7828			_Utils_Tuple2('lesges', '⪓'),
7829			_Utils_Tuple2('lessapprox', '⪅'),
7830			_Utils_Tuple2('lessdot', '⋖'),
7831			_Utils_Tuple2('lesseqgtr', '⋚'),
7832			_Utils_Tuple2('lesseqqgtr', '⪋'),
7833			_Utils_Tuple2('LessEqualGreater', '⋚'),
7834			_Utils_Tuple2('LessFullEqual', '≦'),
7835			_Utils_Tuple2('LessGreater', '≶'),
7836			_Utils_Tuple2('lessgtr', '≶'),
7837			_Utils_Tuple2('LessLess', '⪡'),
7838			_Utils_Tuple2('lesssim', '≲'),
7839			_Utils_Tuple2('LessSlantEqual', '⩽'),
7840			_Utils_Tuple2('LessTilde', '≲'),
7841			_Utils_Tuple2('lfisht', '⥼'),
7842			_Utils_Tuple2('lfloor', '⌊'),
7843			_Utils_Tuple2('Lfr', '\uD835\uDD0F'),
7844			_Utils_Tuple2('lfr', '\uD835\uDD29'),
7845			_Utils_Tuple2('lg', '≶'),
7846			_Utils_Tuple2('lgE', '⪑'),
7847			_Utils_Tuple2('lHar', '⥢'),
7848			_Utils_Tuple2('lhard', '↽'),
7849			_Utils_Tuple2('lharu', '↼'),
7850			_Utils_Tuple2('lharul', '⥪'),
7851			_Utils_Tuple2('lhblk', '▄'),
7852			_Utils_Tuple2('LJcy', 'Љ'),
7853			_Utils_Tuple2('ljcy', 'љ'),
7854			_Utils_Tuple2('llarr', '⇇'),
7855			_Utils_Tuple2('ll', '≪'),
7856			_Utils_Tuple2('Ll', '⋘'),
7857			_Utils_Tuple2('llcorner', '⌞'),
7858			_Utils_Tuple2('Lleftarrow', '⇚'),
7859			_Utils_Tuple2('llhard', '⥫'),
7860			_Utils_Tuple2('lltri', '◺'),
7861			_Utils_Tuple2('Lmidot', 'Ä¿'),
7862			_Utils_Tuple2('lmidot', 'ŀ'),
7863			_Utils_Tuple2('lmoustache', '⎰'),
7864			_Utils_Tuple2('lmoust', '⎰'),
7865			_Utils_Tuple2('lnap', '⪉'),
7866			_Utils_Tuple2('lnapprox', '⪉'),
7867			_Utils_Tuple2('lne', '⪇'),
7868			_Utils_Tuple2('lnE', '≨'),
7869			_Utils_Tuple2('lneq', '⪇'),
7870			_Utils_Tuple2('lneqq', '≨'),
7871			_Utils_Tuple2('lnsim', '⋦'),
7872			_Utils_Tuple2('loang', '⟬'),
7873			_Utils_Tuple2('loarr', '⇽'),
7874			_Utils_Tuple2('lobrk', '⟦'),
7875			_Utils_Tuple2('longleftarrow', '⟵'),
7876			_Utils_Tuple2('LongLeftArrow', '⟵'),
7877			_Utils_Tuple2('Longleftarrow', '⟸'),
7878			_Utils_Tuple2('longleftrightarrow', '⟷'),
7879			_Utils_Tuple2('LongLeftRightArrow', '⟷'),
7880			_Utils_Tuple2('Longleftrightarrow', '⟺'),
7881			_Utils_Tuple2('longmapsto', '⟼'),
7882			_Utils_Tuple2('longrightarrow', '⟶'),
7883			_Utils_Tuple2('LongRightArrow', '⟶'),
7884			_Utils_Tuple2('Longrightarrow', '⟹'),
7885			_Utils_Tuple2('looparrowleft', '↫'),
7886			_Utils_Tuple2('looparrowright', '↬'),
7887			_Utils_Tuple2('lopar', '⦅'),
7888			_Utils_Tuple2('Lopf', '\uD835\uDD43'),
7889			_Utils_Tuple2('lopf', '\uD835\uDD5D'),
7890			_Utils_Tuple2('loplus', '⨭'),
7891			_Utils_Tuple2('lotimes', '⨴'),
7892			_Utils_Tuple2('lowast', '∗'),
7893			_Utils_Tuple2('lowbar', '_'),
7894			_Utils_Tuple2('LowerLeftArrow', '↙'),
7895			_Utils_Tuple2('LowerRightArrow', '↘'),
7896			_Utils_Tuple2('loz', '◊'),
7897			_Utils_Tuple2('lozenge', '◊'),
7898			_Utils_Tuple2('lozf', '⧫'),
7899			_Utils_Tuple2('lpar', '('),
7900			_Utils_Tuple2('lparlt', '⦓'),
7901			_Utils_Tuple2('lrarr', '⇆'),
7902			_Utils_Tuple2('lrcorner', '⌟'),
7903			_Utils_Tuple2('lrhar', '⇋'),
7904			_Utils_Tuple2('lrhard', '⥭'),
7905			_Utils_Tuple2('lrm', '\u200E'),
7906			_Utils_Tuple2('lrtri', '⊿'),
7907			_Utils_Tuple2('lsaquo', '‹'),
7908			_Utils_Tuple2('lscr', '\uD835\uDCC1'),
7909			_Utils_Tuple2('Lscr', 'ℒ'),
7910			_Utils_Tuple2('lsh', '↰'),
7911			_Utils_Tuple2('Lsh', '↰'),
7912			_Utils_Tuple2('lsim', '≲'),
7913			_Utils_Tuple2('lsime', '⪍'),
7914			_Utils_Tuple2('lsimg', '⪏'),
7915			_Utils_Tuple2('lsqb', '['),
7916			_Utils_Tuple2('lsquo', '‘'),
7917			_Utils_Tuple2('lsquor', '‚'),
7918			_Utils_Tuple2('Lstrok', 'Ł'),
7919			_Utils_Tuple2('lstrok', 'ł'),
7920			_Utils_Tuple2('ltcc', '⪦'),
7921			_Utils_Tuple2('ltcir', '⩹'),
7922			_Utils_Tuple2('lt', '<'),
7923			_Utils_Tuple2('LT', '<'),
7924			_Utils_Tuple2('Lt', '≪'),
7925			_Utils_Tuple2('ltdot', '⋖'),
7926			_Utils_Tuple2('lthree', '⋋'),
7927			_Utils_Tuple2('ltimes', '⋉'),
7928			_Utils_Tuple2('ltlarr', '⥶'),
7929			_Utils_Tuple2('ltquest', 'â©»'),
7930			_Utils_Tuple2('ltri', '◃'),
7931			_Utils_Tuple2('ltrie', '⊴'),
7932			_Utils_Tuple2('ltrif', '◂'),
7933			_Utils_Tuple2('ltrPar', '⦖'),
7934			_Utils_Tuple2('lurdshar', '⥊'),
7935			_Utils_Tuple2('luruhar', '⥦'),
7936			_Utils_Tuple2('lvertneqq', '≨︀'),
7937			_Utils_Tuple2('lvnE', '≨︀'),
7938			_Utils_Tuple2('macr', '¯'),
7939			_Utils_Tuple2('male', '♂'),
7940			_Utils_Tuple2('malt', '✠'),
7941			_Utils_Tuple2('maltese', '✠'),
7942			_Utils_Tuple2('Map', '⤅'),
7943			_Utils_Tuple2('map', '↦'),
7944			_Utils_Tuple2('mapsto', '↦'),
7945			_Utils_Tuple2('mapstodown', '↧'),
7946			_Utils_Tuple2('mapstoleft', '↤'),

7947			_Utils_Tuple2('mapstoup', '↥'),
7948			_Utils_Tuple2('marker', '▮'),
7949			_Utils_Tuple2('mcomma', '⨩'),
7950			_Utils_Tuple2('Mcy', 'М'),
7951			_Utils_Tuple2('mcy', 'м'),
7952			_Utils_Tuple2('mdash', '—'),
7953			_Utils_Tuple2('mDDot', '∺'),
7954			_Utils_Tuple2('measuredangle', '∡'),
7955			_Utils_Tuple2('MediumSpace', '\u205F'),
7956			_Utils_Tuple2('Mellintrf', 'ℳ'),
7957			_Utils_Tuple2('Mfr', '\uD835\uDD10'),
7958			_Utils_Tuple2('mfr', '\uD835\uDD2A'),
7959			_Utils_Tuple2('mho', '℧'),
7960			_Utils_Tuple2('micro', 'µ'),
7961			_Utils_Tuple2('midast', '*'),
7962			_Utils_Tuple2('midcir', 'â«°'),
7963			_Utils_Tuple2('mid', '∣'),
7964			_Utils_Tuple2('middot', '·'),
7965			_Utils_Tuple2('minusb', '⊟'),
7966			_Utils_Tuple2('minus', '−'),
7967			_Utils_Tuple2('minusd', '∸'),
7968			_Utils_Tuple2('minusdu', '⨪'),
7969			_Utils_Tuple2('MinusPlus', '∓'),
7970			_Utils_Tuple2('mlcp', '⫛'),
7971			_Utils_Tuple2('mldr', '…'),
7972			_Utils_Tuple2('mnplus', '∓'),
7973			_Utils_Tuple2('models', '⊧'),
7974			_Utils_Tuple2('Mopf', '\uD835\uDD44'),
7975			_Utils_Tuple2('mopf', '\uD835\uDD5E'),
7976			_Utils_Tuple2('mp', '∓'),
7977			_Utils_Tuple2('mscr', '\uD835\uDCC2'),
7978			_Utils_Tuple2('Mscr', 'ℳ'),
7979			_Utils_Tuple2('mstpos', '∾'),
7980			_Utils_Tuple2('Mu', 'Μ'),
7981			_Utils_Tuple2('mu', 'μ'),
7982			_Utils_Tuple2('multimap', '⊸'),
7983			_Utils_Tuple2('mumap', '⊸'),
7984			_Utils_Tuple2('nabla', '∇'),
7985			_Utils_Tuple2('Nacute', 'Ń'),
7986			_Utils_Tuple2('nacute', 'ń'),
7987			_Utils_Tuple2('nang', '∠⃒'),
7988			_Utils_Tuple2('nap', '≉'),
7989			_Utils_Tuple2('napE', '⩰̸'),
7990			_Utils_Tuple2('napid', '≋̸'),
7991			_Utils_Tuple2('napos', 'ʼn'),
7992			_Utils_Tuple2('napprox', '≉'),
7993			_Utils_Tuple2('natural', '♮'),
7994			_Utils_Tuple2('naturals', 'ℕ'),
7995			_Utils_Tuple2('natur', '♮'),
7996			_Utils_Tuple2('nbsp', '\u00A0'),
7997			_Utils_Tuple2('nbump', '≎̸'),
7998			_Utils_Tuple2('nbumpe', '≏̸'),
7999			_Utils_Tuple2('ncap', '⩃'),
8000			_Utils_Tuple2('Ncaron', 'Ň'),
8001			_Utils_Tuple2('ncaron', 'ň'),
8002			_Utils_Tuple2('Ncedil', 'Ņ'),
8003			_Utils_Tuple2('ncedil', 'ņ'),
8004			_Utils_Tuple2('ncong', '≇'),
8005			_Utils_Tuple2('ncongdot', '⩭̸'),
8006			_Utils_Tuple2('ncup', '⩂'),
8007			_Utils_Tuple2('Ncy', 'Н'),
8008			_Utils_Tuple2('ncy', 'н'),
8009			_Utils_Tuple2('ndash', '–'),
8010			_Utils_Tuple2('nearhk', '⤤'),
8011			_Utils_Tuple2('nearr', '↗'),
8012			_Utils_Tuple2('neArr', '⇗'),
8013			_Utils_Tuple2('nearrow', '↗'),
8014			_Utils_Tuple2('ne', '≠'),
8015			_Utils_Tuple2('nedot', '≐̸'),
8016			_Utils_Tuple2('NegativeMediumSpace', '\u200B'),
8017			_Utils_Tuple2('NegativeThickSpace', '\u200B'),
8018			_Utils_Tuple2('NegativeThinSpace', '\u200B'),
8019			_Utils_Tuple2('NegativeVeryThinSpace', '\u200B'),
8020			_Utils_Tuple2('nequiv', '≢'),
8021			_Utils_Tuple2('nesear', '⤨'),
8022			_Utils_Tuple2('nesim', '≂̸'),
8023			_Utils_Tuple2('NestedGreaterGreater', '≫'),
8024			_Utils_Tuple2('NestedLessLess', '≪'),
8025			_Utils_Tuple2('NewLine', '\n'),
8026			_Utils_Tuple2('nexist', '∄'),
8027			_Utils_Tuple2('nexists', '∄'),
8028			_Utils_Tuple2('Nfr', '\uD835\uDD11'),
8029			_Utils_Tuple2('nfr', '\uD835\uDD2B'),
8030			_Utils_Tuple2('ngE', '≧̸'),
8031			_Utils_Tuple2('nge', '≱'),
8032			_Utils_Tuple2('ngeq', '≱'),
8033			_Utils_Tuple2('ngeqq', '≧̸'),
8034			_Utils_Tuple2('ngeqslant', '⩾̸'),
8035			_Utils_Tuple2('nges', '⩾̸'),
8036			_Utils_Tuple2('nGg', '⋙̸'),
8037			_Utils_Tuple2('ngsim', '≵'),
8038			_Utils_Tuple2('nGt', '≫⃒'),
8039			_Utils_Tuple2('ngt', '≯'),
8040			_Utils_Tuple2('ngtr', '≯'),
8041			_Utils_Tuple2('nGtv', '≫̸'),
8042			_Utils_Tuple2('nharr', '↮'),
8043			_Utils_Tuple2('nhArr', '⇎'),
8044			_Utils_Tuple2('nhpar', '⫲'),
8045			_Utils_Tuple2('ni', '∋'),
8046			_Utils_Tuple2('nis', '⋼'),
8047			_Utils_Tuple2('nisd', '⋺'),
8048			_Utils_Tuple2('niv', '∋'),
8049			_Utils_Tuple2('NJcy', 'Њ'),
8050			_Utils_Tuple2('njcy', 'њ'),
8051			_Utils_Tuple2('nlarr', '↚'),
8052			_Utils_Tuple2('nlArr', '⇍'),
8053			_Utils_Tuple2('nldr', '‥'),
8054			_Utils_Tuple2('nlE', '≦̸'),
8055			_Utils_Tuple2('nle', '≰'),
8056			_Utils_Tuple2('nleftarrow', '↚'),
8057			_Utils_Tuple2('nLeftarrow', '⇍'),
8058			_Utils_Tuple2('nleftrightarrow', '↮'),
8059			_Utils_Tuple2('nLeftrightarrow', '⇎'),
8060			_Utils_Tuple2('nleq', '≰'),
8061			_Utils_Tuple2('nleqq', '≦̸'),
8062			_Utils_Tuple2('nleqslant', '⩽̸'),
8063			_Utils_Tuple2('nles', '⩽̸'),
8064			_Utils_Tuple2('nless', '≮'),
8065			_Utils_Tuple2('nLl', '⋘̸'),
8066			_Utils_Tuple2('nlsim', '≴'),
8067			_Utils_Tuple2('nLt', '≪⃒'),
8068			_Utils_Tuple2('nlt', '≮'),
8069			_Utils_Tuple2('nltri', '⋪'),
8070			_Utils_Tuple2('nltrie', '⋬'),
8071			_Utils_Tuple2('nLtv', '≪̸'),
8072			_Utils_Tuple2('nmid', '∤'),
8073			_Utils_Tuple2('NoBreak', '\u2060'),
8074			_Utils_Tuple2('NonBreakingSpace', '\u00A0'),
8075			_Utils_Tuple2('nopf', '\uD835\uDD5F'),
8076			_Utils_Tuple2('Nopf', 'ℕ'),
8077			_Utils_Tuple2('Not', '⫬'),
8078			_Utils_Tuple2('not', '¬'),
8079			_Utils_Tuple2('NotCongruent', '≢'),
8080			_Utils_Tuple2('NotCupCap', '≭'),
8081			_Utils_Tuple2('NotDoubleVerticalBar', '∦'),
8082			_Utils_Tuple2('NotElement', '∉'),
8083			_Utils_Tuple2('NotEqual', '≠'),
8084			_Utils_Tuple2('NotEqualTilde', '≂̸'),
8085			_Utils_Tuple2('NotExists', '∄'),
8086			_Utils_Tuple2('NotGreater', '≯'),
8087			_Utils_Tuple2('NotGreaterEqual', '≱'),

8088			_Utils_Tuple2('NotGreaterFullEqual', '≧̸'),
8089			_Utils_Tuple2('NotGreaterGreater', '≫̸'),
8090			_Utils_Tuple2('NotGreaterLess', '≹'),
8091			_Utils_Tuple2('NotGreaterSlantEqual', '⩾̸'),
8092			_Utils_Tuple2('NotGreaterTilde', '≵'),
8093			_Utils_Tuple2('NotHumpDownHump', '≎̸'),
8094			_Utils_Tuple2('NotHumpEqual', '≏̸'),
8095			_Utils_Tuple2('notin', '∉'),
8096			_Utils_Tuple2('notindot', '⋵̸'),
8097			_Utils_Tuple2('notinE', '⋹̸'),
8098			_Utils_Tuple2('notinva', '∉'),
8099			_Utils_Tuple2('notinvb', '⋷'),
8100			_Utils_Tuple2('notinvc', '⋶'),
8101			_Utils_Tuple2('NotLeftTriangleBar', '⧏̸'),
8102			_Utils_Tuple2('NotLeftTriangle', '⋪'),
8103			_Utils_Tuple2('NotLeftTriangleEqual', '⋬'),
8104			_Utils_Tuple2('NotLess', '≮'),
8105			_Utils_Tuple2('NotLessEqual', '≰'),
8106			_Utils_Tuple2('NotLessGreater', '≸'),
8107			_Utils_Tuple2('NotLessLess', '≪̸'),
8108			_Utils_Tuple2('NotLessSlantEqual', '⩽̸'),
8109			_Utils_Tuple2('NotLessTilde', '≴'),
8110			_Utils_Tuple2('NotNestedGreaterGreater', '⪢̸'),
8111			_Utils_Tuple2('NotNestedLessLess', '⪡̸'),
8112			_Utils_Tuple2('notni', '∌'),
8113			_Utils_Tuple2('notniva', '∌'),
8114			_Utils_Tuple2('notnivb', '⋾'),
8115			_Utils_Tuple2('notnivc', '⋽'),
8116			_Utils_Tuple2('NotPrecedes', '⊀'),
8117			_Utils_Tuple2('NotPrecedesEqual', '⪯̸'),
8118			_Utils_Tuple2('NotPrecedesSlantEqual', '⋠'),
8119			_Utils_Tuple2('NotReverseElement', '∌'),
8120			_Utils_Tuple2('NotRightTriangleBar', '⧐̸'),
8121			_Utils_Tuple2('NotRightTriangle', '⋫'),
8122			_Utils_Tuple2('NotRightTriangleEqual', '⋭'),
8123			_Utils_Tuple2('NotSquareSubset', '⊏̸'),
8124			_Utils_Tuple2('NotSquareSubsetEqual', '⋢'),
8125			_Utils_Tuple2('NotSquareSuperset', '⊐̸'),
8126			_Utils_Tuple2('NotSquareSupersetEqual', '⋣'),
8127			_Utils_Tuple2('NotSubset', '⊂⃒'),
8128			_Utils_Tuple2('NotSubsetEqual', '⊈'),
8129			_Utils_Tuple2('NotSucceeds', '⊁'),
8130			_Utils_Tuple2('NotSucceedsEqual', '⪰̸'),
8131			_Utils_Tuple2('NotSucceedsSlantEqual', '⋡'),
8132			_Utils_Tuple2('NotSucceedsTilde', '≿̸'),
8133			_Utils_Tuple2('NotSuperset', '⊃⃒'),
8134			_Utils_Tuple2('NotSupersetEqual', '⊉'),
8135			_Utils_Tuple2('NotTilde', '≁'),
8136			_Utils_Tuple2('NotTildeEqual', '≄'),
8137			_Utils_Tuple2('NotTildeFullEqual', '≇'),
8138			_Utils_Tuple2('NotTildeTilde', '≉'),
8139			_Utils_Tuple2('NotVerticalBar', '∤'),
8140			_Utils_Tuple2('nparallel', '∦'),
8141			_Utils_Tuple2('npar', '∦'),
8142			_Utils_Tuple2('nparsl', '⫽⃥'),
8143			_Utils_Tuple2('npart', '∂̸'),
8144			_Utils_Tuple2('npolint', '⨔'),
8145			_Utils_Tuple2('npr', '⊀'),
8146			_Utils_Tuple2('nprcue', '⋠'),
8147			_Utils_Tuple2('nprec', '⊀'),
8148			_Utils_Tuple2('npreceq', '⪯̸'),
8149			_Utils_Tuple2('npre', '⪯̸'),
8150			_Utils_Tuple2('nrarrc', '⤳̸'),
8151			_Utils_Tuple2('nrarr', '↛'),
8152			_Utils_Tuple2('nrArr', '⇏'),
8153			_Utils_Tuple2('nrarrw', '↝̸'),
8154			_Utils_Tuple2('nrightarrow', '↛'),
8155			_Utils_Tuple2('nRightarrow', '⇏'),
8156			_Utils_Tuple2('nrtri', '⋫'),
8157			_Utils_Tuple2('nrtrie', '⋭'),
8158			_Utils_Tuple2('nsc', '⊁'),
8159			_Utils_Tuple2('nsccue', '⋡'),
8160			_Utils_Tuple2('nsce', '⪰̸'),
8161			_Utils_Tuple2('Nscr', '\uD835\uDCA9'),
8162			_Utils_Tuple2('nscr', '\uD835\uDCC3'),
8163			_Utils_Tuple2('nshortmid', '∤'),
8164			_Utils_Tuple2('nshortparallel', '∦'),
8165			_Utils_Tuple2('nsim', '≁'),
8166			_Utils_Tuple2('nsime', '≄'),
8167			_Utils_Tuple2('nsimeq', '≄'),
8168			_Utils_Tuple2('nsmid', '∤'),
8169			_Utils_Tuple2('nspar', '∦'),
8170			_Utils_Tuple2('nsqsube', '⋢'),
8171			_Utils_Tuple2('nsqsupe', '⋣'),
8172			_Utils_Tuple2('nsub', '⊄'),
8173			_Utils_Tuple2('nsubE', '⫅̸'),
8174			_Utils_Tuple2('nsube', '⊈'),
8175			_Utils_Tuple2('nsubset', '⊂⃒'),
8176			_Utils_Tuple2('nsubseteq', '⊈'),
8177			_Utils_Tuple2('nsubseteqq', '⫅̸'),
8178			_Utils_Tuple2('nsucc', '⊁'),
8179			_Utils_Tuple2('nsucceq', '⪰̸'),
8180			_Utils_Tuple2('nsup', '⊅'),
8181			_Utils_Tuple2('nsupE', '⫆̸'),
8182			_Utils_Tuple2('nsupe', '⊉'),
8183			_Utils_Tuple2('nsupset', '⊃⃒'),
8184			_Utils_Tuple2('nsupseteq', '⊉'),
8185			_Utils_Tuple2('nsupseteqq', '⫆̸'),
8186			_Utils_Tuple2('ntgl', '≹'),
8187			_Utils_Tuple2('Ntilde', 'Ñ'),
8188			_Utils_Tuple2('ntilde', 'ñ'),
8189			_Utils_Tuple2('ntlg', '≸'),
8190			_Utils_Tuple2('ntriangleleft', '⋪'),
8191			_Utils_Tuple2('ntrianglelefteq', '⋬'),
8192			_Utils_Tuple2('ntriangleright', '⋫'),
8193			_Utils_Tuple2('ntrianglerighteq', '⋭'),
8194			_Utils_Tuple2('Nu', 'Ν'),
8195			_Utils_Tuple2('nu', 'ν'),
8196			_Utils_Tuple2('num', '#'),
8197			_Utils_Tuple2('numero', '№'),
8198			_Utils_Tuple2('numsp', '\u2007'),
8199			_Utils_Tuple2('nvap', '≍⃒'),
8200			_Utils_Tuple2('nvdash', '⊬'),
8201			_Utils_Tuple2('nvDash', '⊭'),
8202			_Utils_Tuple2('nVdash', '⊮'),

8203			_Utils_Tuple2('nVDash', '⊯'),
8204			_Utils_Tuple2('nvge', '≥⃒'),
8205			_Utils_Tuple2('nvgt', '>⃒'),
8206			_Utils_Tuple2('nvHarr', '⤄'),
8207			_Utils_Tuple2('nvinfin', '⧞'),
8208			_Utils_Tuple2('nvlArr', '⤂'),
8209			_Utils_Tuple2('nvle', '≤⃒'),
8210			_Utils_Tuple2('nvlt', '<⃒'),
8211			_Utils_Tuple2('nvltrie', '⊴⃒'),
8212			_Utils_Tuple2('nvrArr', '⤃'),
8213			_Utils_Tuple2('nvrtrie', '⊵⃒'),
8214			_Utils_Tuple2('nvsim', '∼⃒'),
8215			_Utils_Tuple2('nwarhk', '⤣'),
8216			_Utils_Tuple2('nwarr', '↖'),
8217			_Utils_Tuple2('nwArr', '⇖'),
8218			_Utils_Tuple2('nwarrow', '↖'),
8219			_Utils_Tuple2('nwnear', '⤧'),
8220			_Utils_Tuple2('Oacute', 'Ó'),
8221			_Utils_Tuple2('oacute', 'ó'),
8222			_Utils_Tuple2('oast', '⊛'),
8223			_Utils_Tuple2('Ocirc', 'Ô'),
8224			_Utils_Tuple2('ocirc', 'ô'),
8225			_Utils_Tuple2('ocir', '⊚'),
8226			_Utils_Tuple2('Ocy', 'О'),
8227			_Utils_Tuple2('ocy', 'о'),
8228			_Utils_Tuple2('odash', '⊝'),
8229			_Utils_Tuple2('Odblac', 'Ő'),
8230			_Utils_Tuple2('odblac', 'ő'),
8231			_Utils_Tuple2('odiv', '⨸'),
8232			_Utils_Tuple2('odot', '⊙'),
8233			_Utils_Tuple2('odsold', '⦼'),
8234			_Utils_Tuple2('OElig', 'Œ'),
8235			_Utils_Tuple2('oelig', 'œ'),
8236			_Utils_Tuple2('ofcir', '⦿'),
8237			_Utils_Tuple2('Ofr', '\uD835\uDD12'),
8238			_Utils_Tuple2('ofr', '\uD835\uDD2C'),
8239			_Utils_Tuple2('ogon', '˛'),
8240			_Utils_Tuple2('Ograve', 'Ò'),
8241			_Utils_Tuple2('ograve', 'ò'),
8242			_Utils_Tuple2('ogt', '⧁'),
8243			_Utils_Tuple2('ohbar', '⦵'),
8244			_Utils_Tuple2('ohm', 'Ω'),
8245			_Utils_Tuple2('oint', '∮'),
8246			_Utils_Tuple2('olarr', '↺'),
8247			_Utils_Tuple2('olcir', '⦾'),
8248			_Utils_Tuple2('olcross', '⦻'),
8249			_Utils_Tuple2('oline', '‾'),
8250			_Utils_Tuple2('olt', '⧀'),
8251			_Utils_Tuple2('Omacr', 'Ō'),
8252			_Utils_Tuple2('omacr', 'ō'),
8253			_Utils_Tuple2('Omega', 'Ω'),
8254			_Utils_Tuple2('omega', 'ω'),
8255			_Utils_Tuple2('Omicron', 'Ο'),
8256			_Utils_Tuple2('omicron', 'ο'),
8257			_Utils_Tuple2('omid', '⦶'),
8258			_Utils_Tuple2('ominus', '⊖'),
8259			_Utils_Tuple2('Oopf', '\uD835\uDD46'),
8260			_Utils_Tuple2('oopf', '\uD835\uDD60'),
8261			_Utils_Tuple2('opar', '⦷'),
8262			_Utils_Tuple2('OpenCurlyDoubleQuote', '“'),
8263			_Utils_Tuple2('OpenCurlyQuote', '‘'),
8264			_Utils_Tuple2('operp', '⦹'),
8265			_Utils_Tuple2('oplus', '⊕'),
8266			_Utils_Tuple2('orarr', '↻'),

8267			_Utils_Tuple2('Or', '⩔'),
8268			_Utils_Tuple2('or', '∨'),
8269			_Utils_Tuple2('ord', '⩝'),
8270			_Utils_Tuple2('order', 'ℴ'),
8271			_Utils_Tuple2('orderof', 'ℴ'),
8272			_Utils_Tuple2('ordf', 'ª'),
8273			_Utils_Tuple2('ordm', 'º'),
8274			_Utils_Tuple2('origof', '⊶'),
8275			_Utils_Tuple2('oror', '⩖'),
8276			_Utils_Tuple2('orslope', '⩗'),
8277			_Utils_Tuple2('orv', '⩛'),
8278			_Utils_Tuple2('oS', 'Ⓢ'),
8279			_Utils_Tuple2('Oscr', '\uD835\uDCAA'),
8280			_Utils_Tuple2('oscr', 'ℴ'),
8281			_Utils_Tuple2('Oslash', 'Ø'),
8282			_Utils_Tuple2('oslash', 'ø'),
8283			_Utils_Tuple2('osol', '⊘'),
8284			_Utils_Tuple2('Otilde', 'Õ'),
8285			_Utils_Tuple2('otilde', 'õ'),
8286			_Utils_Tuple2('otimesas', '⨶'),
8287			_Utils_Tuple2('Otimes', '⨷'),
8288			_Utils_Tuple2('otimes', '⊗'),
8289			_Utils_Tuple2('Ouml', 'Ö'),
8290			_Utils_Tuple2('ouml', 'ö'),
8291			_Utils_Tuple2('ovbar', '⌽'),
8292			_Utils_Tuple2('OverBar', '‾'),
8293			_Utils_Tuple2('OverBrace', '⏞'),
8294			_Utils_Tuple2('OverBracket', '⎴'),
8295			_Utils_Tuple2('OverParenthesis', '⏜'),
8296			_Utils_Tuple2('para', '¶'),
8297			_Utils_Tuple2('parallel', '∥'),
8298			_Utils_Tuple2('par', '∥'),
8299			_Utils_Tuple2('parsim', '⫳'),
8300			_Utils_Tuple2('parsl', '⫽'),
8301			_Utils_Tuple2('part', '∂'),
8302			_Utils_Tuple2('PartialD', '∂'),
8303			_Utils_Tuple2('Pcy', 'П'),
8304			_Utils_Tuple2('pcy', 'п'),
8305			_Utils_Tuple2('percnt', '%'),
8306			_Utils_Tuple2('period', '.'),
8307			_Utils_Tuple2('permil', '‰'),
8308			_Utils_Tuple2('perp', '⊥'),
8309			_Utils_Tuple2('pertenk', '‱'),
8310			_Utils_Tuple2('Pfr', '\uD835\uDD13'),
8311			_Utils_Tuple2('pfr', '\uD835\uDD2D'),
8312			_Utils_Tuple2('Phi', 'Φ'),
8313			_Utils_Tuple2('phi', 'φ'),
8314			_Utils_Tuple2('phiv', 'ϕ'),
8315			_Utils_Tuple2('phmmat', 'ℳ'),
8316			_Utils_Tuple2('phone', '☎'),
8317			_Utils_Tuple2('Pi', 'Π'),
8318			_Utils_Tuple2('pi', 'π'),
8319			_Utils_Tuple2('pitchfork', '⋔'),
8320			_Utils_Tuple2('piv', 'ϖ'),
8321			_Utils_Tuple2('planck', 'ℏ'),
8322			_Utils_Tuple2('planckh', 'ℎ'),
8323			_Utils_Tuple2('plankv', 'ℏ'),
8324			_Utils_Tuple2('plusacir', '⨣'),
8325			_Utils_Tuple2('plusb', '⊞'),
8326			_Utils_Tuple2('pluscir', '⨢'),
8327			_Utils_Tuple2('plus', '+'),
8328			_Utils_Tuple2('plusdo', '∔'),
8329			_Utils_Tuple2('plusdu', '⨥'),
8330			_Utils_Tuple2('pluse', '⩲'),
8331			_Utils_Tuple2('PlusMinus', '±'),
8332			_Utils_Tuple2('plusmn', '±'),
8333			_Utils_Tuple2('plussim', '⨦'),
8334			_Utils_Tuple2('plustwo', '⨧'),
8335			_Utils_Tuple2('pm', '±'),
8336			_Utils_Tuple2('Poincareplane', 'ℌ'),
8337			_Utils_Tuple2('pointint', '⨕'),
8338			_Utils_Tuple2('popf', '\uD835\uDD61'),
8339			_Utils_Tuple2('Popf', 'ℙ'),
8340			_Utils_Tuple2('pound', '£'),
8341			_Utils_Tuple2('prap', '⪷'),
8342			_Utils_Tuple2('Pr', '⪻'),
8343			_Utils_Tuple2('pr', '≺'),
8344			_Utils_Tuple2('prcue', '≼'),
8345			_Utils_Tuple2('precapprox', '⪷'),
8346			_Utils_Tuple2('prec', '≺'),
8347			_Utils_Tuple2('preccurlyeq', '≼'),
8348			_Utils_Tuple2('Precedes', '≺'),
8349			_Utils_Tuple2('PrecedesEqual', '⪯'),
8350			_Utils_Tuple2('PrecedesSlantEqual', '≼'),
8351			_Utils_Tuple2('PrecedesTilde', '≾'),
8352			_Utils_Tuple2('preceq', '⪯'),
8353			_Utils_Tuple2('precnapprox', '⪹'),
8354			_Utils_Tuple2('precneqq', '⪵'),
8355			_Utils_Tuple2('precnsim', '⋨'),
8356			_Utils_Tuple2('pre', '⪯'),
8357			_Utils_Tuple2('prE', '⪳'),
8358			_Utils_Tuple2('precsim', '≾'),
8359			_Utils_Tuple2('prime', '′'),
8360			_Utils_Tuple2('Prime', '″'),
8361			_Utils_Tuple2('primes', 'ℙ'),
8362			_Utils_Tuple2('prnap', '⪹'),
8363			_Utils_Tuple2('prnE', '⪵'),
8364			_Utils_Tuple2('prnsim', '⋨'),
8365			_Utils_Tuple2('prod', '∏'),
8366			_Utils_Tuple2('Product', '∏'),
8367			_Utils_Tuple2('profalar', '⌮'),
8368			_Utils_Tuple2('profline', '⌒'),

8369			_Utils_Tuple2('profsurf', '⌓'),
8370			_Utils_Tuple2('prop', '∝'),
8371			_Utils_Tuple2('Proportional', '∝'),
8372			_Utils_Tuple2('Proportion', '∷'),
8373			_Utils_Tuple2('propto', '∝'),
8374			_Utils_Tuple2('prsim', '≾'),
8375			_Utils_Tuple2('prurel', '⊰'),
8376			_Utils_Tuple2('Pscr', '\uD835\uDCAB'),
8377			_Utils_Tuple2('pscr', '\uD835\uDCC5'),
8378			_Utils_Tuple2('Psi', 'Ψ'),
8379			_Utils_Tuple2('psi', 'ψ'),
8380			_Utils_Tuple2('puncsp', '\u2008'),
8381			_Utils_Tuple2('Qfr', '\uD835\uDD14'),
8382			_Utils_Tuple2('qfr', '\uD835\uDD2E'),
8383			_Utils_Tuple2('qint', '⨌'),
8384			_Utils_Tuple2('qopf', '\uD835\uDD62'),
8385			_Utils_Tuple2('Qopf', 'ℚ'),
8386			_Utils_Tuple2('qprime', '⁗'),
8387			_Utils_Tuple2('Qscr', '\uD835\uDCAC'),
8388			_Utils_Tuple2('qscr', '\uD835\uDCC6'),
8389			_Utils_Tuple2('quaternions', 'ℍ'),
8390			_Utils_Tuple2('quatint', '⨖'),
8391			_Utils_Tuple2('quest', '?'),
8392			_Utils_Tuple2('questeq', '≟'),
8393			_Utils_Tuple2('quot', '\"'),
8394			_Utils_Tuple2('QUOT', '\"'),
8395			_Utils_Tuple2('rAarr', '⇛'),
8396			_Utils_Tuple2('race', '∽̱'),
8397			_Utils_Tuple2('Racute', 'Ŕ'),
8398			_Utils_Tuple2('racute', 'ŕ'),
8399			_Utils_Tuple2('radic', '√'),
8400			_Utils_Tuple2('raemptyv', '⦳'),
8401			_Utils_Tuple2('rang', '⟩'),
8402			_Utils_Tuple2('Rang', '⟫'),
8403			_Utils_Tuple2('rangd', '⦒'),
8404			_Utils_Tuple2('range', '⦥'),
8405			_Utils_Tuple2('rangle', '⟩'),
8406			_Utils_Tuple2('raquo', '»'),
8407			_Utils_Tuple2('rarrap', '⥵'),
8408			_Utils_Tuple2('rarrb', '⇥'),
8409			_Utils_Tuple2('rarrbfs', '⤠'),
8410			_Utils_Tuple2('rarrc', '⤳'),
8411			_Utils_Tuple2('rarr', '→'),
8412			_Utils_Tuple2('Rarr', '↠'),
8413			_Utils_Tuple2('rArr', '⇒'),
8414			_Utils_Tuple2('rarrfs', '⤞'),
8415			_Utils_Tuple2('rarrhk', '↪'),
8416			_Utils_Tuple2('rarrlp', '↬'),
8417			_Utils_Tuple2('rarrpl', '⥅'),
8418			_Utils_Tuple2('rarrsim', '⥴'),
8419			_Utils_Tuple2('Rarrtl', '⤖'),
8420			_Utils_Tuple2('rarrtl', '↣'),
8421			_Utils_Tuple2('rarrw', '↝'),
8422			_Utils_Tuple2('ratail', '⤚'),
8423			_Utils_Tuple2('rAtail', '⤜'),
8424			_Utils_Tuple2('ratio', '∶'),
8425			_Utils_Tuple2('rationals', 'ℚ'),
8426			_Utils_Tuple2('rbarr', '⤍'),
8427			_Utils_Tuple2('rBarr', '⤏'),
8428			_Utils_Tuple2('RBarr', '⤐'),
8429			_Utils_Tuple2('rbbrk', '❳'),
8430			_Utils_Tuple2('rbrace', '}'),
8431			_Utils_Tuple2('rbrack', ']'),
8432			_Utils_Tuple2('rbrke', '⦌'),
8433			_Utils_Tuple2('rbrksld', '⦎'),
8434			_Utils_Tuple2('rbrkslu', '⦐'),
8435			_Utils_Tuple2('Rcaron', 'Ř'),
8436			_Utils_Tuple2('rcaron', 'ř'),
8437			_Utils_Tuple2('Rcedil', 'Ŗ'),
8438			_Utils_Tuple2('rcedil', 'ŗ'),
8439			_Utils_Tuple2('rceil', '⌉'),
8440			_Utils_Tuple2('rcub', '}'),
8441			_Utils_Tuple2('Rcy', 'Р'),
8442			_Utils_Tuple2('rcy', 'р'),
8443			_Utils_Tuple2('rdca', '⤷'),
8444			_Utils_Tuple2('rdldhar', '⥩'),
8445			_Utils_Tuple2('rdquo', '”'),
8446			_Utils_Tuple2('rdquor', '”'),
8447			_Utils_Tuple2('rdsh', '↳'),
8448			_Utils_Tuple2('real', 'ℜ'),
8449			_Utils_Tuple2('realine', 'ℛ'),
8450			_Utils_Tuple2('realpart', 'ℜ'),
8451			_Utils_Tuple2('reals', 'ℝ'),
8452			_Utils_Tuple2('Re', 'ℜ'),
8453			_Utils_Tuple2('rect', '▭'),
8454			_Utils_Tuple2('reg', '®'),
8455			_Utils_Tuple2('REG', '®'),
8456			_Utils_Tuple2('ReverseElement', '∋'),
8457			_Utils_Tuple2('ReverseEquilibrium', '⇋'),
8458			_Utils_Tuple2('ReverseUpEquilibrium', '⥯'),
8459			_Utils_Tuple2('rfisht', '⥽'),
8460			_Utils_Tuple2('rfloor', '⌋'),
8461			_Utils_Tuple2('rfr', '\uD835\uDD2F'),
8462			_Utils_Tuple2('Rfr', 'ℜ'),
8463			_Utils_Tuple2('rHar', '⥤'),
8464			_Utils_Tuple2('rhard', '⇁'),
8465			_Utils_Tuple2('rharu', '⇀'),
8466			_Utils_Tuple2('rharul', '⥬'),
8467			_Utils_Tuple2('Rho', 'Ρ'),
8468			_Utils_Tuple2('rho', 'ρ'),
8469			_Utils_Tuple2('rhov', 'ϱ'),
8470			_Utils_Tuple2('RightAngleBracket', '⟩'),
8471			_Utils_Tuple2('RightArrowBar', '⇥'),
8472			_Utils_Tuple2('rightarrow', '→'),
8473			_Utils_Tuple2('RightArrow', '→'),
8474			_Utils_Tuple2('Rightarrow', '⇒'),
8475			_Utils_Tuple2('RightArrowLeftArrow', '⇄'),
8476			_Utils_Tuple2('rightarrowtail', '↣'),
8477			_Utils_Tuple2('RightCeiling', '⌉'),
8478			_Utils_Tuple2('RightDoubleBracket', '⟧'),
8479			_Utils_Tuple2('RightDownTeeVector', '⥝'),
8480			_Utils_Tuple2('RightDownVectorBar', '⥕'),
8481			_Utils_Tuple2('RightDownVector', '⇂'),
8482			_Utils_Tuple2('RightFloor', '⌋'),

8483			_Utils_Tuple2('rightharpoondown', '⇁'),
8484			_Utils_Tuple2('rightharpoonup', '⇀'),
8485			_Utils_Tuple2('rightleftarrows', '⇄'),
8486			_Utils_Tuple2('rightleftharpoons', '⇌'),
8487			_Utils_Tuple2('rightrightarrows', '⇉'),
8488			_Utils_Tuple2('rightsquigarrow', '↝'),
8489			_Utils_Tuple2('RightTeeArrow', '↦'),
8490			_Utils_Tuple2('RightTee', '⊢'),
8491			_Utils_Tuple2('RightTeeVector', '⥛'),
8492			_Utils_Tuple2('rightthreetimes', '⋌'),
8493			_Utils_Tuple2('RightTriangleBar', '⧐'),
8494			_Utils_Tuple2('RightTriangle', '⊳'),
8495			_Utils_Tuple2('RightTriangleEqual', '⊵'),
8496			_Utils_Tuple2('RightUpDownVector', '⥏'),
8497			_Utils_Tuple2('RightUpTeeVector', '⥜'),
8498			_Utils_Tuple2('RightUpVectorBar', '⥔'),
8499			_Utils_Tuple2('RightUpVector', '↾'),
8500			_Utils_Tuple2('RightVectorBar', '⥓'),
8501			_Utils_Tuple2('RightVector', '⇀'),
8502			_Utils_Tuple2('ring', '˚'),
8503			_Utils_Tuple2('risingdotseq', '≓'),
8504			_Utils_Tuple2('rlarr', '⇄'),
8505			_Utils_Tuple2('rlhar', '⇌'),
8506			_Utils_Tuple2('rlm', '\u200F'),
8507			_Utils_Tuple2('rmoustache', '⎱'),
8508			_Utils_Tuple2('rmoust', '⎱'),
8509			_Utils_Tuple2('rnmid', 'â«®'),
8510			_Utils_Tuple2('roang', '⟭'),
8511			_Utils_Tuple2('roarr', '⇾'),
8512			_Utils_Tuple2('robrk', '⟧'),
8513			_Utils_Tuple2('ropar', '⦆'),
8514			_Utils_Tuple2('ropf', '\uD835\uDD63'),
8515			_Utils_Tuple2('Ropf', 'ℝ'),
8516			_Utils_Tuple2('roplus', '⨮'),
8517			_Utils_Tuple2('rotimes', '⨵'),
8518			_Utils_Tuple2('RoundImplies', '⥰'),
8519			_Utils_Tuple2('rpar', ')'),
8520			_Utils_Tuple2('rpargt', '⦔'),
8521			_Utils_Tuple2('rppolint', '⨒'),
8522			_Utils_Tuple2('rrarr', '⇉'),
8523			_Utils_Tuple2('Rrightarrow', '⇛'),
8524			_Utils_Tuple2('rsaquo', '›'),
8525			_Utils_Tuple2('rscr', '\uD835\uDCC7'),
8526			_Utils_Tuple2('Rscr', 'ℛ'),
8527			_Utils_Tuple2('rsh', '↱'),
8528			_Utils_Tuple2('Rsh', '↱'),
8529			_Utils_Tuple2('rsqb', ']'),
8530			_Utils_Tuple2('rsquo', '’'),
8531			_Utils_Tuple2('rsquor', '’'),
8532			_Utils_Tuple2('rthree', '⋌'),
8533			_Utils_Tuple2('rtimes', '⋊'),
8534			_Utils_Tuple2('rtri', '▹'),
8535			_Utils_Tuple2('rtrie', '⊵'),
8536			_Utils_Tuple2('rtrif', '▸'),
8537			_Utils_Tuple2('rtriltri', '⧎'),
8538			_Utils_Tuple2('RuleDelayed', '⧴'),
8539			_Utils_Tuple2('ruluhar', '⥨'),
8540			_Utils_Tuple2('rx', '℞'),
8541			_Utils_Tuple2('Sacute', 'Ś'),
8542			_Utils_Tuple2('sacute', 'ś'),
8543			_Utils_Tuple2('sbquo', '‚'),
8544			_Utils_Tuple2('scap', '⪸'),
8545			_Utils_Tuple2('Scaron', 'Å '),
8546			_Utils_Tuple2('scaron', 'Å¡'),
8547			_Utils_Tuple2('Sc', '⪼'),
8548			_Utils_Tuple2('sc', '≻'),
8549			_Utils_Tuple2('sccue', '≽'),
8550			_Utils_Tuple2('sce', '⪰'),
8551			_Utils_Tuple2('scE', '⪴'),
8552			_Utils_Tuple2('Scedil', 'Ş'),
8553			_Utils_Tuple2('scedil', 'ş'),
8554			_Utils_Tuple2('Scirc', 'Ŝ'),
8555			_Utils_Tuple2('scirc', 'ŝ'),
8556			_Utils_Tuple2('scnap', '⪺'),
8557			_Utils_Tuple2('scnE', '⪶'),
8558			_Utils_Tuple2('scnsim', '⋩'),
8559			_Utils_Tuple2('scpolint', '⨓'),
8560			_Utils_Tuple2('scsim', '≿'),
8561			_Utils_Tuple2('Scy', 'С'),
8562			_Utils_Tuple2('scy', 'с'),
8563			_Utils_Tuple2('sdotb', '⊡'),
8564			_Utils_Tuple2('sdot', '⋅'),
8565			_Utils_Tuple2('sdote', '⩦'),
8566			_Utils_Tuple2('searhk', '⤥'),
8567			_Utils_Tuple2('searr', '↘'),
8568			_Utils_Tuple2('seArr', '⇘'),
8569			_Utils_Tuple2('searrow', '↘'),
8570			_Utils_Tuple2('sect', '§'),
8571			_Utils_Tuple2('semi', ';'),
8572			_Utils_Tuple2('seswar', '⤩'),
8573			_Utils_Tuple2('setminus', '∖'),
8574			_Utils_Tuple2('setmn', '∖'),
8575			_Utils_Tuple2('sext', '✶'),
8576			_Utils_Tuple2('Sfr', '\uD835\uDD16'),
8577			_Utils_Tuple2('sfr', '\uD835\uDD30'),
8578			_Utils_Tuple2('sfrown', '⌢'),
8579			_Utils_Tuple2('sharp', '♯'),
8580			_Utils_Tuple2('SHCHcy', 'Щ'),
8581			_Utils_Tuple2('shchcy', 'щ'),
8582			_Utils_Tuple2('SHcy', 'Ш'),
8583			_Utils_Tuple2('shcy', 'ш'),
8584			_Utils_Tuple2('ShortDownArrow', '↓'),
8585			_Utils_Tuple2('ShortLeftArrow', '←'),
8586			_Utils_Tuple2('shortmid', '∣'),
8587			_Utils_Tuple2('shortparallel', '∥'),
8588			_Utils_Tuple2('ShortRightArrow', '→'),
8589			_Utils_Tuple2('ShortUpArrow', '↑'),
8590			_Utils_Tuple2('shy', '\u00AD'),
8591			_Utils_Tuple2('Sigma', 'Σ'),
8592			_Utils_Tuple2('sigma', 'σ'),
8593			_Utils_Tuple2('sigmaf', 'ς'),
8594			_Utils_Tuple2('sigmav', 'ς'),
8595			_Utils_Tuple2('sim', '∼'),
8596			_Utils_Tuple2('simdot', '⩪'),
8597			_Utils_Tuple2('sime', '≃'),
8598			_Utils_Tuple2('simeq', '≃'),
8599			_Utils_Tuple2('simg', '⪞'),
8600			_Utils_Tuple2('simgE', '⪠'),
8601			_Utils_Tuple2('siml', '⪝'),
8602			_Utils_Tuple2('simlE', '⪟'),

8603			_Utils_Tuple2('simne', '≆'),
8604			_Utils_Tuple2('simplus', '⨤'),
8605			_Utils_Tuple2('simrarr', '⥲'),
8606			_Utils_Tuple2('slarr', '←'),
8607			_Utils_Tuple2('SmallCircle', '∘'),
8608			_Utils_Tuple2('smallsetminus', '∖'),
8609			_Utils_Tuple2('smashp', '⨳'),
8610			_Utils_Tuple2('smeparsl', '⧤'),
8611			_Utils_Tuple2('smid', '∣'),
8612			_Utils_Tuple2('smile', '⌣'),
8613			_Utils_Tuple2('smt', '⪪'),
8614			_Utils_Tuple2('smte', '⪬'),
8615			_Utils_Tuple2('smtes', '⪬︀'),
8616			_Utils_Tuple2('SOFTcy', 'Ь'),
8617			_Utils_Tuple2('softcy', 'ь'),
8618			_Utils_Tuple2('solbar', '⌿'),
8619			_Utils_Tuple2('solb', '⧄'),
8620			_Utils_Tuple2('sol', '/'),
8621			_Utils_Tuple2('Sopf', '\uD835\uDD4A'),
8622			_Utils_Tuple2('sopf', '\uD835\uDD64'),
8623			_Utils_Tuple2('spades', '♠'),
8624			_Utils_Tuple2('spadesuit', '♠'),
8625			_Utils_Tuple2('spar', '∥'),
8626			_Utils_Tuple2('sqcap', '⊓'),
8627			_Utils_Tuple2('sqcaps', '⊓︀'),
8628			_Utils_Tuple2('sqcup', '⊔'),
8629			_Utils_Tuple2('sqcups', '⊔︀'),
8630			_Utils_Tuple2('Sqrt', '√'),
8631			_Utils_Tuple2('sqsub', '⊏'),
8632			_Utils_Tuple2('sqsube', '⊑'),
8633			_Utils_Tuple2('sqsubset', '⊏'),
8634			_Utils_Tuple2('sqsubseteq', '⊑'),
8635			_Utils_Tuple2('sqsup', '⊐'),
8636			_Utils_Tuple2('sqsupe', '⊒'),
8637			_Utils_Tuple2('sqsupset', '⊐'),
8638			_Utils_Tuple2('sqsupseteq', '⊒'),
8639			_Utils_Tuple2('square', '□'),
8640			_Utils_Tuple2('Square', '□'),
8641			_Utils_Tuple2('SquareIntersection', '⊓'),
8642			_Utils_Tuple2('SquareSubset', '⊏'),
8643			_Utils_Tuple2('SquareSubsetEqual', '⊑'),
8644			_Utils_Tuple2('SquareSuperset', '⊐'),
8645			_Utils_Tuple2('SquareSupersetEqual', '⊒'),
8646			_Utils_Tuple2('SquareUnion', '⊔'),
8647			_Utils_Tuple2('squarf', '▪'),
8648			_Utils_Tuple2('squ', '□'),
8649			_Utils_Tuple2('squf', '▪'),
8650			_Utils_Tuple2('srarr', '→'),
8651			_Utils_Tuple2('Sscr', '\uD835\uDCAE'),
8652			_Utils_Tuple2('sscr', '\uD835\uDCC8'),
8653			_Utils_Tuple2('ssetmn', '∖'),
8654			_Utils_Tuple2('ssmile', '⌣'),
8655			_Utils_Tuple2('sstarf', '⋆'),
8656			_Utils_Tuple2('Star', '⋆'),
8657			_Utils_Tuple2('star', '☆'),
8658			_Utils_Tuple2('starf', '★'),
8659			_Utils_Tuple2('straightepsilon', 'ϵ'),
8660			_Utils_Tuple2('straightphi', 'ϕ'),
8661			_Utils_Tuple2('strns', '¯'),
8662			_Utils_Tuple2('sub', '⊂'),
8663			_Utils_Tuple2('Sub', '⋐'),
8664			_Utils_Tuple2('subdot', '⪽'),
8665			_Utils_Tuple2('subE', '⫅'),
8666			_Utils_Tuple2('sube', '⊆'),
8667			_Utils_Tuple2('subedot', '⫃'),
8668			_Utils_Tuple2('submult', '⫁'),
8669			_Utils_Tuple2('subnE', '⫋'),
8670			_Utils_Tuple2('subne', '⊊'),
8671			_Utils_Tuple2('subplus', '⪿'),
8672			_Utils_Tuple2('subrarr', '⥹'),
8673			_Utils_Tuple2('subset', '⊂'),
8674			_Utils_Tuple2('Subset', '⋐'),
8675			_Utils_Tuple2('subseteq', '⊆'),
8676			_Utils_Tuple2('subseteqq', '⫅'),
8677			_Utils_Tuple2('SubsetEqual', '⊆'),
8678			_Utils_Tuple2('subsetneq', '⊊'),
8679			_Utils_Tuple2('subsetneqq', '⫋'),
8680			_Utils_Tuple2('subsim', '⫇'),
8681			_Utils_Tuple2('subsub', '⫕'),
8682			_Utils_Tuple2('subsup', '⫓'),
8683			_Utils_Tuple2('succapprox', '⪸'),
8684			_Utils_Tuple2('succ', '≻'),
8685			_Utils_Tuple2('succcurlyeq', '≽'),
8686			_Utils_Tuple2('Succeeds', '≻'),
8687			_Utils_Tuple2('SucceedsEqual', '⪰'),
8688			_Utils_Tuple2('SucceedsSlantEqual', '≽'),
8689			_Utils_Tuple2('SucceedsTilde', '≿'),
8690			_Utils_Tuple2('succeq', '⪰'),
8691			_Utils_Tuple2('succnapprox', '⪺'),
8692			_Utils_Tuple2('succneqq', '⪶'),
8693			_Utils_Tuple2('succnsim', '⋩'),
8694			_Utils_Tuple2('succsim', '≿'),
8695			_Utils_Tuple2('SuchThat', '∋'),
8696			_Utils_Tuple2('sum', '∑'),
8697			_Utils_Tuple2('Sum', '∑'),
8698			_Utils_Tuple2('sung', '♪'),
8699			_Utils_Tuple2('sup1', '¹'),
8700			_Utils_Tuple2('sup2', '²'),
8701			_Utils_Tuple2('sup3', '³'),
8702			_Utils_Tuple2('sup', '⊃'),
8703			_Utils_Tuple2('Sup', '⋑'),
8704			_Utils_Tuple2('supdot', '⪾'),
8705			_Utils_Tuple2('supdsub', '⫘'),
8706			_Utils_Tuple2('supE', '⫆'),
8707			_Utils_Tuple2('supe', '⊇'),
8708			_Utils_Tuple2('supedot', '⫄'),
8709			_Utils_Tuple2('Superset', '⊃'),
8710			_Utils_Tuple2('SupersetEqual', '⊇'),
8711			_Utils_Tuple2('suphsol', '⟉'),
8712			_Utils_Tuple2('suphsub', '⫗'),
8713			_Utils_Tuple2('suplarr', '⥻'),
8714			_Utils_Tuple2('supmult', '⫂'),
8715			_Utils_Tuple2('supnE', '⫌'),
8716			_Utils_Tuple2('supne', '⊋'),
8717			_Utils_Tuple2('supplus', '⫀'),
8718			_Utils_Tuple2('supset', '⊃'),
8719			_Utils_Tuple2('Supset', '⋑'),
8720			_Utils_Tuple2('supseteq', '⊇'),
8721			_Utils_Tuple2('supseteqq', '⫆'),
8722			_Utils_Tuple2('supsetneq', '⊋'),
8723			_Utils_Tuple2('supsetneqq', '⫌'),
8724			_Utils_Tuple2('supsim', '⫈'),
8725			_Utils_Tuple2('supsub', '⫔'),
8726			_Utils_Tuple2('supsup', '⫖'),

8727			_Utils_Tuple2('swarhk', '⤦'),
8728			_Utils_Tuple2('swarr', '↙'),
8729			_Utils_Tuple2('swArr', '⇙'),
8730			_Utils_Tuple2('swarrow', '↙'),
8731			_Utils_Tuple2('swnwar', '⤪'),
8732			_Utils_Tuple2('szlig', 'ß'),
8733			_Utils_Tuple2('Tab', '\t'),
8734			_Utils_Tuple2('target', '⌖'),
8735			_Utils_Tuple2('Tau', 'Τ'),
8736			_Utils_Tuple2('tau', 'τ'),
8737			_Utils_Tuple2('tbrk', '⎴'),
8738			_Utils_Tuple2('Tcaron', 'Ť'),
8739			_Utils_Tuple2('tcaron', 'Å¥'),
8740			_Utils_Tuple2('Tcedil', 'Å¢'),
8741			_Utils_Tuple2('tcedil', 'Å£'),
8742			_Utils_Tuple2('Tcy', 'Т'),
8743			_Utils_Tuple2('tcy', 'т'),
8744			_Utils_Tuple2('tdot', '⃛'),
8745			_Utils_Tuple2('telrec', '⌕'),
8746			_Utils_Tuple2('Tfr', '\uD835\uDD17'),
8747			_Utils_Tuple2('tfr', '\uD835\uDD31'),
8748			_Utils_Tuple2('there4', '∴'),
8749			_Utils_Tuple2('therefore', '∴'),
8750			_Utils_Tuple2('Therefore', '∴'),
8751			_Utils_Tuple2('Theta', 'Θ'),
8752			_Utils_Tuple2('theta', 'θ'),
8753			_Utils_Tuple2('thetasym', 'ϑ'),
8754			_Utils_Tuple2('thetav', 'ϑ'),
8755			_Utils_Tuple2('thickapprox', '≈'),
8756			_Utils_Tuple2('thicksim', '∼'),
8757			_Utils_Tuple2('ThickSpace', '\u205F\u200A'),
8758			_Utils_Tuple2('ThinSpace', '\u2009'),
8759			_Utils_Tuple2('thinsp', '\u2009'),
8760			_Utils_Tuple2('thkap', '≈'),
8761			_Utils_Tuple2('thksim', '∼'),
8762			_Utils_Tuple2('THORN', 'Þ'),
8763			_Utils_Tuple2('thorn', 'þ'),
8764			_Utils_Tuple2('tilde', '˜'),
8765			_Utils_Tuple2('Tilde', '∼'),
8766			_Utils_Tuple2('TildeEqual', '≃'),
8767			_Utils_Tuple2('TildeFullEqual', '≅'),
8768			_Utils_Tuple2('TildeTilde', '≈'),
8769			_Utils_Tuple2('timesbar', '⨱'),
8770			_Utils_Tuple2('timesb', '⊠'),
8771			_Utils_Tuple2('times', '×'),
8772			_Utils_Tuple2('timesd', '⨰'),
8773			_Utils_Tuple2('tint', '∭'),
8774			_Utils_Tuple2('toea', '⤨'),
8775			_Utils_Tuple2('topbot', '⌶'),
8776			_Utils_Tuple2('topcir', '⫱'),
8777			_Utils_Tuple2('top', '⊤'),
8778			_Utils_Tuple2('Topf', '\uD835\uDD4B'),
8779			_Utils_Tuple2('topf', '\uD835\uDD65'),
8780			_Utils_Tuple2('topfork', '⫚'),
8781			_Utils_Tuple2('tosa', '⤩'),
8782			_Utils_Tuple2('tprime', '‴'),
8783			_Utils_Tuple2('trade', '™'),
8784			_Utils_Tuple2('TRADE', '™'),
8785			_Utils_Tuple2('triangle', '▵'),
8786			_Utils_Tuple2('triangledown', '▿'),
8787			_Utils_Tuple2('triangleleft', '◃'),
8788			_Utils_Tuple2('trianglelefteq', '⊴'),
8789			_Utils_Tuple2('triangleq', '≜'),
8790			_Utils_Tuple2('triangleright', '▹'),
8791			_Utils_Tuple2('trianglerighteq', '⊵'),
8792			_Utils_Tuple2('tridot', '◬'),
8793			_Utils_Tuple2('trie', '≜'),
8794			_Utils_Tuple2('triminus', '⨺'),
8795			_Utils_Tuple2('TripleDot', '⃛'),
8796			_Utils_Tuple2('triplus', '⨹'),
8797			_Utils_Tuple2('trisb', '⧍'),
8798			_Utils_Tuple2('tritime', '⨻'),
8799			_Utils_Tuple2('trpezium', '⏢'),
8800			_Utils_Tuple2('Tscr', '\uD835\uDCAF'),
8801			_Utils_Tuple2('tscr', '\uD835\uDCC9'),
8802			_Utils_Tuple2('TScy', 'Ц'),
8803			_Utils_Tuple2('tscy', 'ц'),
8804			_Utils_Tuple2('TSHcy', 'Ћ'),
8805			_Utils_Tuple2('tshcy', 'ћ'),
8806			_Utils_Tuple2('Tstrok', 'Ŧ'),
8807			_Utils_Tuple2('tstrok', 'ŧ'),
8808			_Utils_Tuple2('twixt', '≬'),
8809			_Utils_Tuple2('twoheadleftarrow', '↞'),
8810			_Utils_Tuple2('twoheadrightarrow', '↠'),
8811			_Utils_Tuple2('Uacute', 'Ú'),
8812			_Utils_Tuple2('uacute', 'ú'),
8813			_Utils_Tuple2('uarr', '↑'),
8814			_Utils_Tuple2('Uarr', '↟'),
8815			_Utils_Tuple2('uArr', '⇑'),
8816			_Utils_Tuple2('Uarrocir', '⥉'),
8817			_Utils_Tuple2('Ubrcy', 'Ў'),
8818			_Utils_Tuple2('ubrcy', 'ў'),
8819			_Utils_Tuple2('Ubreve', 'Ŭ'),
8820			_Utils_Tuple2('ubreve', 'Å­'),
8821			_Utils_Tuple2('Ucirc', 'Û'),
8822			_Utils_Tuple2('ucirc', 'û'),
8823			_Utils_Tuple2('Ucy', 'У'),
8824			_Utils_Tuple2('ucy', 'у'),
8825			_Utils_Tuple2('udarr', '⇅'),
8826			_Utils_Tuple2('Udblac', 'Å°'),
8827			_Utils_Tuple2('udblac', 'ű'),
8828			_Utils_Tuple2('udhar', '⥮'),
8829			_Utils_Tuple2('ufisht', '⥾'),
8830			_Utils_Tuple2('Ufr', '\uD835\uDD18'),
8831			_Utils_Tuple2('ufr', '\uD835\uDD32'),
8832			_Utils_Tuple2('Ugrave', 'Ù'),
8833			_Utils_Tuple2('ugrave', 'ù'),
8834			_Utils_Tuple2('uHar', '⥣'),
8835			_Utils_Tuple2('uharl', '↿'),
8836			_Utils_Tuple2('uharr', '↾'),
8837			_Utils_Tuple2('uhblk', '▀'),
8838			_Utils_Tuple2('ulcorn', '⌜'),
8839			_Utils_Tuple2('ulcorner', '⌜'),
8840			_Utils_Tuple2('ulcrop', '⌏'),
8841			_Utils_Tuple2('ultri', '◸'),
8842			_Utils_Tuple2('Umacr', 'Ū'),
8843			_Utils_Tuple2('umacr', 'Å«'),
8844			_Utils_Tuple2('uml', '¨'),
8845			_Utils_Tuple2('UnderBar', '_'),
8846			_Utils_Tuple2('UnderBrace', '⏟'),
8847			_Utils_Tuple2('UnderBracket', '⎵'),
8848			_Utils_Tuple2('UnderParenthesis', '⏝'),
8849			_Utils_Tuple2('Union', '⋃'),
8850			_Utils_Tuple2('UnionPlus', '⊎'),
8851			_Utils_Tuple2('Uogon', 'Ų'),
8852			_Utils_Tuple2('uogon', 'ų'),
8853			_Utils_Tuple2('Uopf', '\uD835\uDD4C'),
8854			_Utils_Tuple2('uopf', '\uD835\uDD66'),
8855			_Utils_Tuple2('UpArrowBar', '⤒'),
8856			_Utils_Tuple2('uparrow', '↑'),
8857			_Utils_Tuple2('UpArrow', '↑'),
8858			_Utils_Tuple2('Uparrow', '⇑'),
8859			_Utils_Tuple2('UpArrowDownArrow', '⇅'),
8860			_Utils_Tuple2('updownarrow', '↕'),
8861			_Utils_Tuple2('UpDownArrow', '↕'),
8862			_Utils_Tuple2('Updownarrow', '⇕'),
8863			_Utils_Tuple2('UpEquilibrium', '⥮'),

8864			_Utils_Tuple2('upharpoonleft', '↿'),
8865			_Utils_Tuple2('upharpoonright', '↾'),
8866			_Utils_Tuple2('uplus', '⊎'),
8867			_Utils_Tuple2('UpperLeftArrow', '↖'),
8868			_Utils_Tuple2('UpperRightArrow', '↗'),
8869			_Utils_Tuple2('upsi', 'υ'),
8870			_Utils_Tuple2('Upsi', 'ϒ'),
8871			_Utils_Tuple2('upsih', 'ϒ'),
8872			_Utils_Tuple2('Upsilon', 'Î¥'),
8873			_Utils_Tuple2('upsilon', 'υ'),
8874			_Utils_Tuple2('UpTeeArrow', '↥'),
8875			_Utils_Tuple2('UpTee', '⊥'),
8876			_Utils_Tuple2('upuparrows', '⇈'),
8877			_Utils_Tuple2('urcorn', '⌝'),
8878			_Utils_Tuple2('urcorner', '⌝'),
8879			_Utils_Tuple2('urcrop', '⌎'),
8880			_Utils_Tuple2('Uring', 'Å®'),
8881			_Utils_Tuple2('uring', 'ů'),
8882			_Utils_Tuple2('urtri', '◹'),
8883			_Utils_Tuple2('Uscr', '\uD835\uDCB0'),
8884			_Utils_Tuple2('uscr', '\uD835\uDCCA'),
8885			_Utils_Tuple2('utdot', '⋰'),
8886			_Utils_Tuple2('Utilde', 'Ũ'),
8887			_Utils_Tuple2('utilde', 'Å©'),
8888			_Utils_Tuple2('utri', '▵'),
8889			_Utils_Tuple2('utrif', '▴'),
8890			_Utils_Tuple2('uuarr', '⇈'),
8891			_Utils_Tuple2('Uuml', 'Ü'),
8892			_Utils_Tuple2('uuml', 'ü'),
8893			_Utils_Tuple2('uwangle', '⦧'),
8894			_Utils_Tuple2('vangrt', '⦜'),
8895			_Utils_Tuple2('varepsilon', 'ϵ'),
8896			_Utils_Tuple2('varkappa', 'Ï°'),
8897			_Utils_Tuple2('varnothing', '∅'),
8898			_Utils_Tuple2('varphi', 'ϕ'),
8899			_Utils_Tuple2('varpi', 'ϖ'),
8900			_Utils_Tuple2('varpropto', '∝'),
8901			_Utils_Tuple2('varr', '↕'),
8902			_Utils_Tuple2('vArr', '⇕'),
8903			_Utils_Tuple2('varrho', 'ϱ'),
8904			_Utils_Tuple2('varsigma', 'ς'),
8905			_Utils_Tuple2('varsubsetneq', '⊊︀'),
8906			_Utils_Tuple2('varsubsetneqq', '⫋︀'),
8907			_Utils_Tuple2('varsupsetneq', '⊋︀'),
8908			_Utils_Tuple2('varsupsetneqq', '⫌︀'),
8909			_Utils_Tuple2('vartheta', 'ϑ'),
8910			_Utils_Tuple2('vartriangleleft', '⊲'),
8911			_Utils_Tuple2('vartriangleright', '⊳'),
8912			_Utils_Tuple2('vBar', '⫨'),
8913			_Utils_Tuple2('Vbar', 'â««'),
8914			_Utils_Tuple2('vBarv', 'â«©'),
8915			_Utils_Tuple2('Vcy', 'В'),
8916			_Utils_Tuple2('vcy', 'в'),
8917			_Utils_Tuple2('vdash', '⊢'),
8918			_Utils_Tuple2('vDash', '⊨'),
8919			_Utils_Tuple2('Vdash', '⊩'),
8920			_Utils_Tuple2('VDash', '⊫'),
8921			_Utils_Tuple2('Vdashl', '⫦'),
8922			_Utils_Tuple2('veebar', '⊻'),
8923			_Utils_Tuple2('vee', '∨'),
8924			_Utils_Tuple2('Vee', '⋁'),
8925			_Utils_Tuple2('veeeq', '≚'),
8926			_Utils_Tuple2('vellip', '⋮'),
8927			_Utils_Tuple2('verbar', '|'),
8928			_Utils_Tuple2('Verbar', '‖'),
8929			_Utils_Tuple2('vert', '|'),
8930			_Utils_Tuple2('Vert', '‖'),
8931			_Utils_Tuple2('VerticalBar', '∣'),
8932			_Utils_Tuple2('VerticalLine', '|'),
8933			_Utils_Tuple2('VerticalSeparator', '❘'),
8934			_Utils_Tuple2('VerticalTilde', '≀'),
8935			_Utils_Tuple2('VeryThinSpace', '\u200A'),
8936			_Utils_Tuple2('Vfr', '\uD835\uDD19'),
8937			_Utils_Tuple2('vfr', '\uD835\uDD33'),
8938			_Utils_Tuple2('vltri', '⊲'),
8939			_Utils_Tuple2('vnsub', '⊂⃒'),
8940			_Utils_Tuple2('vnsup', '⊃⃒'),
8941			_Utils_Tuple2('Vopf', '\uD835\uDD4D'),
8942			_Utils_Tuple2('vopf', '\uD835\uDD67'),
8943			_Utils_Tuple2('vprop', '∝'),
8944			_Utils_Tuple2('vrtri', '⊳'),
8945			_Utils_Tuple2('Vscr', '\uD835\uDCB1'),
8946			_Utils_Tuple2('vscr', '\uD835\uDCCB'),
8947			_Utils_Tuple2('vsubnE', '⫋︀'),
8948			_Utils_Tuple2('vsubne', '⊊︀'),
8949			_Utils_Tuple2('vsupnE', '⫌︀'),
8950			_Utils_Tuple2('vsupne', '⊋︀'),
8951			_Utils_Tuple2('Vvdash', '⊪'),
8952			_Utils_Tuple2('vzigzag', '⦚'),
8953			_Utils_Tuple2('Wcirc', 'Å´'),
8954			_Utils_Tuple2('wcirc', 'ŵ'),
8955			_Utils_Tuple2('wedbar', '⩟'),
8956			_Utils_Tuple2('wedge', '∧'),
8957			_Utils_Tuple2('Wedge', '⋀'),
8958			_Utils_Tuple2('wedgeq', '≙'),
8959			_Utils_Tuple2('weierp', '℘'),
8960			_Utils_Tuple2('Wfr', '\uD835\uDD1A'),
8961			_Utils_Tuple2('wfr', '\uD835\uDD34'),
8962			_Utils_Tuple2('Wopf', '\uD835\uDD4E'),
8963			_Utils_Tuple2('wopf', '\uD835\uDD68'),
8964			_Utils_Tuple2('wp', '℘'),
8965			_Utils_Tuple2('wr', '≀'),
8966			_Utils_Tuple2('wreath', '≀'),
8967			_Utils_Tuple2('Wscr', '\uD835\uDCB2'),
8968			_Utils_Tuple2('wscr', '\uD835\uDCCC'),
8969			_Utils_Tuple2('xcap', '⋂'),
8970			_Utils_Tuple2('xcirc', '◯'),
8971			_Utils_Tuple2('xcup', '⋃'),
8972			_Utils_Tuple2('xdtri', '▽'),
8973			_Utils_Tuple2('Xfr', '\uD835\uDD1B'),
8974			_Utils_Tuple2('xfr', '\uD835\uDD35'),
8975			_Utils_Tuple2('xharr', '⟷'),
8976			_Utils_Tuple2('xhArr', '⟺'),
8977			_Utils_Tuple2('Xi', 'Ξ'),
8978			_Utils_Tuple2('xi', 'ξ'),
8979			_Utils_Tuple2('xlarr', '⟵'),
8980			_Utils_Tuple2('xlArr', '⟸'),
8981			_Utils_Tuple2('xmap', '⟼'),
8982			_Utils_Tuple2('xnis', '⋻'),
8983			_Utils_Tuple2('xodot', '⨀'),
8984			_Utils_Tuple2('Xopf', '\uD835\uDD4F'),
8985			_Utils_Tuple2('xopf', '\uD835\uDD69'),
8986			_Utils_Tuple2('xoplus', '⨁'),
8987			_Utils_Tuple2('xotime', '⨂'),
8988			_Utils_Tuple2('xrarr', '⟶'),
8989			_Utils_Tuple2('xrArr', '⟹'),
8990			_Utils_Tuple2('Xscr', '\uD835\uDCB3'),
8991			_Utils_Tuple2('xscr', '\uD835\uDCCD'),
8992			_Utils_Tuple2('xsqcup', '⨆'),
8993			_Utils_Tuple2('xuplus', '⨄'),
8994			_Utils_Tuple2('xutri', '△'),
8995			_Utils_Tuple2('xvee', '⋁'),
8996			_Utils_Tuple2('xwedge', '⋀'),
8997			_Utils_Tuple2('Yacute', 'Ý'),
8998			_Utils_Tuple2('yacute', 'ý'),
8999			_Utils_Tuple2('YAcy', 'Я'),
9000			_Utils_Tuple2('yacy', 'я'),
9001			_Utils_Tuple2('Ycirc', 'Ŷ'),
9002			_Utils_Tuple2('ycirc', 'Å·'),
9003			_Utils_Tuple2('Ycy', 'Ы'),
9004			_Utils_Tuple2('ycy', 'ы'),
9005			_Utils_Tuple2('yen', 'Â¥'),
9006			_Utils_Tuple2('Yfr', '\uD835\uDD1C'),
9007			_Utils_Tuple2('yfr', '\uD835\uDD36'),
9008			_Utils_Tuple2('YIcy', 'Ї'),
9009			_Utils_Tuple2('yicy', 'ї'),
9010			_Utils_Tuple2('Yopf', '\uD835\uDD50'),
9011			_Utils_Tuple2('yopf', '\uD835\uDD6A'),
9012			_Utils_Tuple2('Yscr', '\uD835\uDCB4'),
9013			_Utils_Tuple2('yscr', '\uD835\uDCCE'),
9014			_Utils_Tuple2('YUcy', 'Ю'),
9015			_Utils_Tuple2('yucy', 'ю'),
9016			_Utils_Tuple2('yuml', 'ÿ'),
9017			_Utils_Tuple2('Yuml', 'Ÿ'),
9018			_Utils_Tuple2('Zacute', 'Ź'),
9019			_Utils_Tuple2('zacute', 'ź'),
9020			_Utils_Tuple2('Zcaron', 'Ž'),
9021			_Utils_Tuple2('zcaron', 'ž'),
9022			_Utils_Tuple2('Zcy', 'З'),
9023			_Utils_Tuple2('zcy', 'з'),
9024			_Utils_Tuple2('Zdot', 'Å»'),
9025			_Utils_Tuple2('zdot', 'ż'),
9026			_Utils_Tuple2('zeetrf', 'ℨ'),
9027			_Utils_Tuple2('ZeroWidthSpace', '\u200B'),
9028			_Utils_Tuple2('Zeta', 'Ζ'),
9029			_Utils_Tuple2('zeta', 'ζ'),
9030			_Utils_Tuple2('zfr', '\uD835\uDD37'),
9031			_Utils_Tuple2('Zfr', 'ℨ'),
9032			_Utils_Tuple2('ZHcy', 'Ж'),
9033			_Utils_Tuple2('zhcy', 'ж'),
9034			_Utils_Tuple2('zigrarr', '⇝'),
9035			_Utils_Tuple2('zopf', '\uD835\uDD6B'),
9036			_Utils_Tuple2('Zopf', 'ℤ'),
9037			_Utils_Tuple2('Zscr', '\uD835\uDCB5'),
9038			_Utils_Tuple2('zscr', '\uD835\uDCCF'),
9039			_Utils_Tuple2('zwj', '\u200D'),
9040			_Utils_Tuple2('zwnj', '\u200C')
9041		]));
9042var $elm$core$Dict$get = F2(
9043	function (targetKey, dict) {
9044		get:
9045		while (true) {
9046			if (dict.$ === 'RBEmpty_elm_builtin') {
9047				return $elm$core$Maybe$Nothing;
9048			} else {
9049				var key = dict.b;
9050				var value = dict.c;
9051				var left = dict.d;
9052				var right = dict.e;

9053				var _v1 = A2($elm$core$Basics$compare, targetKey, key);
9054				switch (_v1.$) {
9055					case 'LT':
9056						var $temp$targetKey = targetKey,
9057							$temp$dict = left;
9058						targetKey = $temp$targetKey;
9059						dict = $temp$dict;
9060						continue get;
9061					case 'EQ':
9062						return $elm$core$Maybe$Just(value);
9063					default:
9064						var $temp$targetKey = targetKey,
9065							$temp$dict = right;
9066						targetKey = $temp$targetKey;
9067						dict = $temp$dict;
9068						continue get;
9069				}
9070			}
9071		}
9072	});
9073var $elm$core$Maybe$withDefault = F2(
9074	function (_default, maybe) {
9075		if (maybe.$ === 'Just') {
9076			var value = maybe.a;
9077			return value;
9078		} else {
9079			return _default;
9080		}
9081	});
9082var $hecrj$html_parser$Html$Parser$namedCharacterReference = A2(
9083	$elm$parser$Parser$map,
9084	function (reference) {
9085		return A2(
9086			$elm$core$Maybe$withDefault,
9087			'&' + (reference + ';'),
9088			A2($elm$core$Dict$get, reference, $hecrj$html_parser$Html$Parser$NamedCharacterReferences$dict));
9089	},
9090	$elm$parser$Parser$getChompedString(
9091		$hecrj$html_parser$Html$Parser$chompOneOrMore($elm$core$Char$isAlpha)));
9092var $elm$core$Basics$composeR = F3(
9093	function (f, g, x) {
9094		return g(
9095			f(x));
9096	});
9097var $elm$core$String$cons = _String_cons;
9098var $elm$core$String$fromChar = function (_char) {
9099	return A2($elm$core$String$cons, _char, '');
9100};
9101var $elm$core$Char$fromCode = _Char_fromCode;
9102var $rtfeldman$elm_hex$Hex$fromStringHelp = F3(
9103	function (position, chars, accumulated) {
9104		fromStringHelp:
9105		while (true) {
9106			if (!chars.b) {
9107				return $elm$core$Result$Ok(accumulated);
9108			} else {
9109				var _char = chars.a;
9110				var rest = chars.b;
9111				switch (_char.valueOf()) {
9112					case '0':
9113						var $temp$position = position - 1,
9114							$temp$chars = rest,
9115							$temp$accumulated = accumulated;
9116						position = $temp$position;
9117						chars = $temp$chars;
9118						accumulated = $temp$accumulated;
9119						continue fromStringHelp;
9120					case '1':
9121						var $temp$position = position - 1,
9122							$temp$chars = rest,
9123							$temp$accumulated = accumulated + A2($elm$core$Basics$pow, 16, position);
9124						position = $temp$position;
9125						chars = $temp$chars;
9126						accumulated = $temp$accumulated;
9127						continue fromStringHelp;
9128					case '2':
9129						var $temp$position = position - 1,
9130							$temp$chars = rest,
9131							$temp$accumulated = accumulated + (2 * A2($elm$core$Basics$pow, 16, position));
9132						position = $temp$position;
9133						chars = $temp$chars;
9134						accumulated = $temp$accumulated;
9135						continue fromStringHelp;
9136					case '3':
9137						var $temp$position = position - 1,
9138							$temp$chars = rest,
9139							$temp$accumulated = accumulated + (3 * A2($elm$core$Basics$pow, 16, position));
9140						position = $temp$position;
9141						chars = $temp$chars;
9142						accumulated = $temp$accumulated;
9143						continue fromStringHelp;
9144					case '4':
9145						var $temp$position = position - 1,
9146							$temp$chars = rest,
9147							$temp$accumulated = accumulated + (4 * A2($elm$core$Basics$pow, 16, position));
9148						position = $temp$position;
9149						chars = $temp$chars;
9150						accumulated = $temp$accumulated;
9151						continue fromStringHelp;
9152					case '5':
9153						var $temp$position = position - 1,
9154							$temp$chars = rest,
9155							$temp$accumulated = accumulated + (5 * A2($elm$core$Basics$pow, 16, position));
9156						position = $temp$position;
9157						chars = $temp$chars;
9158						accumulated = $temp$accumulated;
9159						continue fromStringHelp;
9160					case '6':
9161						var $temp$position = position - 1,
9162							$temp$chars = rest,
9163							$temp$accumulated = accumulated + (6 * A2($elm$core$Basics$pow, 16, position));
9164						position = $temp$position;
9165						chars = $temp$chars;
9166						accumulated = $temp$accumulated;
9167						continue fromStringHelp;
9168					case '7':
9169						var $temp$position = position - 1,
9170							$temp$chars = rest,
9171							$temp$accumulated = accumulated + (7 * A2($elm$core$Basics$pow, 16, position));
9172						position = $temp$position;
9173						chars = $temp$chars;
9174						accumulated = $temp$accumulated;
9175						continue fromStringHelp;
9176					case '8':
9177						var $temp$position = position - 1,
9178							$temp$chars = rest,
9179							$temp$accumulated = accumulated + (8 * A2($elm$core$Basics$pow, 16, position));
9180						position = $temp$position;
9181						chars = $temp$chars;
9182						accumulated = $temp$accumulated;
9183						continue fromStringHelp;
9184					case '9':
9185						var $temp$position = position - 1,
9186							$temp$chars = rest,
9187							$temp$accumulated = accumulated + (9 * A2($elm$core$Basics$pow, 16, position));
9188						position = $temp$position;
9189						chars = $temp$chars;
9190						accumulated = $temp$accumulated;
9191						continue fromStringHelp;
9192					case 'a':
9193						var $temp$position = position - 1,
9194							$temp$chars = rest,
9195							$temp$accumulated = accumulated + (10 * A2($elm$core$Basics$pow, 16, position));
9196						position = $temp$position;
9197						chars = $temp$chars;
9198						accumulated = $temp$accumulated;
9199						continue fromStringHelp;
9200					case 'b':
9201						var $temp$position = position - 1,
9202							$temp$chars = rest,
9203							$temp$accumulated = accumulated + (11 * A2($elm$core$Basics$pow, 16, position));
9204						position = $temp$position;
9205						chars = $temp$chars;
9206						accumulated = $temp$accumulated;
9207						continue fromStringHelp;
9208					case 'c':
9209						var $temp$position = position - 1,
9210							$temp$chars = rest,
9211							$temp$accumulated = accumulated + (12 * A2($elm$core$Basics$pow, 16, position));
9212						position = $temp$position;
9213						chars = $temp$chars;
9214						accumulated = $temp$accumulated;
9215						continue fromStringHelp;
9216					case 'd':
9217						var $temp$position = position - 1,
9218							$temp$chars = rest,
9219							$temp$accumulated = accumulated + (13 * A2($elm$core$Basics$pow, 16, position));
9220						position = $temp$position;
9221						chars = $temp$chars;
9222						accumulated = $temp$accumulated;
9223						continue fromStringHelp;
9224					case 'e':
9225						var $temp$position = position - 1,
9226							$temp$chars = rest,
9227							$temp$accumulated = accumulated + (14 * A2($elm$core$Basics$pow, 16, position));
9228						position = $temp$position;
9229						chars = $temp$chars;
9230						accumulated = $temp$accumulated;
9231						continue fromStringHelp;
9232					case 'f':
9233						var $temp$position = position - 1,
9234							$temp$chars = rest,
9235							$temp$accumulated = accumulated + (15 * A2($elm$core$Basics$pow, 16, position));
9236						position = $temp$position;
9237						chars = $temp$chars;
9238						accumulated = $temp$accumulated;
9239						continue fromStringHelp;
9240					default:
9241						var nonHex = _char;
9242						return $elm$core$Result$Err(
9243							$elm$core$String$fromChar(nonHex) + ' is not a valid hexadecimal character.');
9244				}
9245			}
9246		}
9247	});
9248var $elm$core$Result$map = F2(
9249	function (func, ra) {
9250		if (ra.$ === 'Ok') {
9251			var a = ra.a;
9252			return $elm$core$Result$Ok(
9253				func(a));
9254		} else {
9255			var e = ra.a;
9256			return $elm$core$Result$Err(e);
9257		}
9258	});
9259var $elm$core$Result$mapError = F2(
9260	function (f, result) {
9261		if (result.$ === 'Ok') {
9262			var v = result.a;
9263			return $elm$core$Result$Ok(v);
9264		} else {
9265			var e = result.a;
9266			return $elm$core$Result$Err(
9267				f(e));
9268		}
9269	});
9270var $elm$core$List$tail = function (list) {
9271	if (list.b) {
9272		var x = list.a;
9273		var xs = list.b;
9274		return $elm$core$Maybe$Just(xs);
9275	} else {
9276		return $elm$core$Maybe$Nothing;
9277	}
9278};

9279var $elm$core$String$foldr = _String_foldr;
9280var $elm$core$String$toList = function (string) {
9281	return A3($elm$core$String$foldr, $elm$core$List$cons, _List_Nil, string);
9282};
9283var $rtfeldman$elm_hex$Hex$fromString = function (str) {
9284	if ($elm$core$String$isEmpty(str)) {
9285		return $elm$core$Result$Err('Empty strings are not valid hexadecimal strings.');
9286	} else {
9287		var result = function () {
9288			if (A2($elm$core$String$startsWith, '-', str)) {
9289				var list = A2(
9290					$elm$core$Maybe$withDefault,
9291					_List_Nil,
9292					$elm$core$List$tail(
9293						$elm$core$String$toList(str)));
9294				return A2(
9295					$elm$core$Result$map,
9296					$elm$core$Basics$negate,
9297					A3(
9298						$rtfeldman$elm_hex$Hex$fromStringHelp,
9299						$elm$core$List$length(list) - 1,
9300						list,
9301						0));
9302			} else {
9303				return A3(
9304					$rtfeldman$elm_hex$Hex$fromStringHelp,
9305					$elm$core$String$length(str) - 1,
9306					$elm$core$String$toList(str),
9307					0);
9308			}
9309		}();
9310		var formatError = function (err) {
9311			return A2(
9312				$elm$core$String$join,
9313				' ',
9314				_List_fromArray(
9315					['\"' + (str + '\"'), 'is not a valid hexadecimal string because', err]));
9316		};
9317		return A2($elm$core$Result$mapError, formatError, result);
9318	}
9319};
9320var $elm$core$Char$isHexDigit = function (_char) {
9321	var code = $elm$core$Char$toCode(_char);
9322	return ((48 <= code) && (code <= 57)) || (((65 <= code) && (code <= 70)) || ((97 <= code) && (code <= 102)));
9323};
9324var $hecrj$html_parser$Html$Parser$hexadecimal = A2(
9325	$elm$parser$Parser$andThen,
9326	function (hex) {
9327		var _v0 = $rtfeldman$elm_hex$Hex$fromString(
9328			$elm$core$String$toLower(hex));
9329		if (_v0.$ === 'Ok') {
9330			var value = _v0.a;
9331			return $elm$parser$Parser$succeed(value);
9332		} else {
9333			var error = _v0.a;
9334			return $elm$parser$Parser$problem(error);
9335		}
9336	},
9337	$elm$parser$Parser$getChompedString(
9338		$hecrj$html_parser$Html$Parser$chompOneOrMore($elm$core$Char$isHexDigit)));
9339var $elm$parser$Parser$ExpectingInt = {$: 'ExpectingInt'};
9340var $elm$parser$Parser$Advanced$consumeBase = _Parser_consumeBase;
9341var $elm$parser$Parser$Advanced$consumeBase16 = _Parser_consumeBase16;
9342var $elm$parser$Parser$Advanced$bumpOffset = F2(
9343	function (newOffset, s) {
9344		return {col: s.col + (newOffset - s.offset), context: s.context, indent: s.indent, offset: newOffset, row: s.row, src: s.src};
9345	});
9346var $elm$parser$Parser$Advanced$chompBase10 = _Parser_chompBase10;
9347var $elm$parser$Parser$Advanced$isAsciiCode = _Parser_isAsciiCode;
9348var $elm$parser$Parser$Advanced$consumeExp = F2(
9349	function (offset, src) {
9350		if (A3($elm$parser$Parser$Advanced$isAsciiCode, 101, offset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 69, offset, src)) {
9351			var eOffset = offset + 1;
9352			var expOffset = (A3($elm$parser$Parser$Advanced$isAsciiCode, 43, eOffset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 45, eOffset, src)) ? (eOffset + 1) : eOffset;
9353			var newOffset = A2($elm$parser$Parser$Advanced$chompBase10, expOffset, src);
9354			return _Utils_eq(expOffset, newOffset) ? (-newOffset) : newOffset;
9355		} else {
9356			return offset;
9357		}
9358	});
9359var $elm$parser$Parser$Advanced$consumeDotAndExp = F2(
9360	function (offset, src) {
9361		return A3($elm$parser$Parser$Advanced$isAsciiCode, 46, offset, src) ? A2(
9362			$elm$parser$Parser$Advanced$consumeExp,
9363			A2($elm$parser$Parser$Advanced$chompBase10, offset + 1, src),
9364			src) : A2($elm$parser$Parser$Advanced$consumeExp, offset, src);
9365	});
9366var $elm$parser$Parser$Advanced$finalizeInt = F5(
9367	function (invalid, handler, startOffset, _v0, s) {
9368		var endOffset = _v0.a;
9369		var n = _v0.b;
9370		if (handler.$ === 'Err') {
9371			var x = handler.a;
9372			return A2(
9373				$elm$parser$Parser$Advanced$Bad,
9374				true,
9375				A2($elm$parser$Parser$Advanced$fromState, s, x));
9376		} else {
9377			var toValue = handler.a;
9378			return _Utils_eq(startOffset, endOffset) ? A2(
9379				$elm$parser$Parser$Advanced$Bad,
9380				_Utils_cmp(s.offset, startOffset) < 0,
9381				A2($elm$parser$Parser$Advanced$fromState, s, invalid)) : A3(
9382				$elm$parser$Parser$Advanced$Good,
9383				true,
9384				toValue(n),
9385				A2($elm$parser$Parser$Advanced$bumpOffset, endOffset, s));
9386		}
9387	});
9388var $elm$core$String$toFloat = _String_toFloat;
9389var $elm$parser$Parser$Advanced$finalizeFloat = F6(
9390	function (invalid, expecting, intSettings, floatSettings, intPair, s) {
9391		var intOffset = intPair.a;
9392		var floatOffset = A2($elm$parser$Parser$Advanced$consumeDotAndExp, intOffset, s.src);
9393		if (floatOffset < 0) {
9394			return A2(
9395				$elm$parser$Parser$Advanced$Bad,
9396				true,
9397				A4($elm$parser$Parser$Advanced$fromInfo, s.row, s.col - (floatOffset + s.offset), invalid, s.context));
9398		} else {
9399			if (_Utils_eq(s.offset, floatOffset)) {
9400				return A2(
9401					$elm$parser$Parser$Advanced$Bad,
9402					false,
9403					A2($elm$parser$Parser$Advanced$fromState, s, expecting));
9404			} else {
9405				if (_Utils_eq(intOffset, floatOffset)) {
9406					return A5($elm$parser$Parser$Advanced$finalizeInt, invalid, intSettings, s.offset, intPair, s);
9407				} else {
9408					if (floatSettings.$ === 'Err') {
9409						var x = floatSettings.a;
9410						return A2(
9411							$elm$parser$Parser$Advanced$Bad,
9412							true,
9413							A2($elm$parser$Parser$Advanced$fromState, s, invalid));
9414					} else {
9415						var toValue = floatSettings.a;
9416						var _v1 = $elm$core$String$toFloat(
9417							A3($elm$core$String$slice, s.offset, floatOffset, s.src));
9418						if (_v1.$ === 'Nothing') {
9419							return A2(
9420								$elm$parser$Parser$Advanced$Bad,
9421								true,
9422								A2($elm$parser$Parser$Advanced$fromState, s, invalid));
9423						} else {
9424							var n = _v1.a;
9425							return A3(
9426								$elm$parser$Parser$Advanced$Good,
9427								true,
9428								toValue(n),
9429								A2($elm$parser$Parser$Advanced$bumpOffset, floatOffset, s));
9430						}
9431					}
9432				}
9433			}
9434		}
9435	});
9436var $elm$parser$Parser$Advanced$number = function (c) {
9437	return $elm$parser$Parser$Advanced$Parser(
9438		function (s) {
9439			if (A3($elm$parser$Parser$Advanced$isAsciiCode, 48, s.offset, s.src)) {
9440				var zeroOffset = s.offset + 1;
9441				var baseOffset = zeroOffset + 1;
9442				return A3($elm$parser$Parser$Advanced$isAsciiCode, 120, zeroOffset, s.src) ? A5(
9443					$elm$parser$Parser$Advanced$finalizeInt,
9444					c.invalid,
9445					c.hex,
9446					baseOffset,
9447					A2($elm$parser$Parser$Advanced$consumeBase16, baseOffset, s.src),
9448					s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 111, zeroOffset, s.src) ? A5(
9449					$elm$parser$Parser$Advanced$finalizeInt,
9450					c.invalid,
9451					c.octal,
9452					baseOffset,
9453					A3($elm$parser$Parser$Advanced$consumeBase, 8, baseOffset, s.src),
9454					s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 98, zeroOffset, s.src) ? A5(
9455					$elm$parser$Parser$Advanced$finalizeInt,
9456					c.invalid,
9457					c.binary,
9458					baseOffset,
9459					A3($elm$parser$Parser$Advanced$consumeBase, 2, baseOffset, s.src),
9460					s) : A6(
9461					$elm$parser$Parser$Advanced$finalizeFloat,
9462					c.invalid,
9463					c.expecting,
9464					c._int,
9465					c._float,
9466					_Utils_Tuple2(zeroOffset, 0),
9467					s)));
9468			} else {
9469				return A6(
9470					$elm$parser$Parser$Advanced$finalizeFloat,
9471					c.invalid,
9472					c.expecting,
9473					c._int,
9474					c._float,
9475					A3($elm$parser$Parser$Advanced$consumeBase, 10, s.offset, s.src),
9476					s);
9477			}
9478		});
9479};
9480var $elm$parser$Parser$Advanced$int = F2(
9481	function (expecting, invalid) {
9482		return $elm$parser$Parser$Advanced$number(
9483			{
9484				binary: $elm$core$Result$Err(invalid),
9485				expecting: expecting,
9486				_float: $elm$core$Result$Err(invalid),
9487				hex: $elm$core$Result$Err(invalid),
9488				_int: $elm$core$Result$Ok($elm$core$Basics$identity),

9489				invalid: invalid,
9490				octal: $elm$core$Result$Err(invalid)
9491			});
9492	});
9493var $elm$parser$Parser$int = A2($elm$parser$Parser$Advanced$int, $elm$parser$Parser$ExpectingInt, $elm$parser$Parser$ExpectingInt);
9494var $hecrj$html_parser$Html$Parser$numericCharacterReference = function () {
9495	var codepoint = $elm$parser$Parser$oneOf(
9496		_List_fromArray(
9497			[
9498				A2(
9499				$elm$parser$Parser$keeper,
9500				A2(
9501					$elm$parser$Parser$ignorer,
9502					$elm$parser$Parser$succeed($elm$core$Basics$identity),
9503					$elm$parser$Parser$chompIf(
9504						function (c) {
9505							return _Utils_eq(
9506								c,
9507								_Utils_chr('x')) || _Utils_eq(
9508								c,
9509								_Utils_chr('X'));
9510						})),
9511				$hecrj$html_parser$Html$Parser$hexadecimal),
9512				A2(
9513				$elm$parser$Parser$keeper,
9514				A2(
9515					$elm$parser$Parser$ignorer,
9516					$elm$parser$Parser$succeed($elm$core$Basics$identity),
9517					$elm$parser$Parser$chompWhile(
9518						$elm$core$Basics$eq(
9519							_Utils_chr('0')))),
9520				$elm$parser$Parser$int)
9521			]));
9522	return A2(
9523		$elm$parser$Parser$keeper,
9524		A2(
9525			$elm$parser$Parser$ignorer,
9526			$elm$parser$Parser$succeed($elm$core$Basics$identity),
9527			$elm$parser$Parser$chompIf(
9528				$elm$core$Basics$eq(
9529					_Utils_chr('#')))),
9530		A2(
9531			$elm$parser$Parser$map,
9532			A2($elm$core$Basics$composeR, $elm$core$Char$fromCode, $elm$core$String$fromChar),
9533			codepoint));
9534}();
9535var $hecrj$html_parser$Html$Parser$characterReference = A2(
9536	$elm$parser$Parser$keeper,
9537	A2(
9538		$elm$parser$Parser$ignorer,
9539		$elm$parser$Parser$succeed($elm$core$Basics$identity),
9540		$elm$parser$Parser$chompIf(
9541			$elm$core$Basics$eq(
9542				_Utils_chr('&')))),
9543	$elm$parser$Parser$oneOf(
9544		_List_fromArray(
9545			[
9546				A2(
9547				$elm$parser$Parser$ignorer,
9548				$elm$parser$Parser$backtrackable($hecrj$html_parser$Html$Parser$namedCharacterReference),
9549				$hecrj$html_parser$Html$Parser$chompSemicolon),
9550				A2(
9551				$elm$parser$Parser$ignorer,
9552				$elm$parser$Parser$backtrackable($hecrj$html_parser$Html$Parser$numericCharacterReference),
9553				$hecrj$html_parser$Html$Parser$chompSemicolon),
9554				$elm$parser$Parser$succeed('&')
9555			])));
9556var $hecrj$html_parser$Html$Parser$tagAttributeQuotedValue = function (quote) {
9557	var isQuotedValueChar = function (c) {
9558		return (!_Utils_eq(c, quote)) && (!_Utils_eq(
9559			c,
9560			_Utils_chr('&')));
9561	};
9562	return A2(
9563		$elm$parser$Parser$keeper,
9564		A2(
9565			$elm$parser$Parser$ignorer,
9566			$elm$parser$Parser$succeed($elm$core$Basics$identity),
9567			$elm$parser$Parser$chompIf(
9568				$elm$core$Basics$eq(quote))),
9569		A2(
9570			$elm$parser$Parser$ignorer,
9571			A2(
9572				$elm$parser$Parser$map,
9573				$elm$core$String$join(''),
9574				$hecrj$html_parser$Html$Parser$many(
9575					$elm$parser$Parser$oneOf(
9576						_List_fromArray(
9577							[
9578								$elm$parser$Parser$getChompedString(
9579								$hecrj$html_parser$Html$Parser$chompOneOrMore(isQuotedValueChar)),
9580								$hecrj$html_parser$Html$Parser$characterReference
9581							])))),
9582			$elm$parser$Parser$chompIf(
9583				$elm$core$Basics$eq(quote))));
9584};
9585var $elm$core$List$isEmpty = function (xs) {
9586	if (!xs.b) {
9587		return true;
9588	} else {
9589		return false;
9590	}
9591};
9592var $hecrj$html_parser$Html$Parser$oneOrMore = F2(
9593	function (type_, parser_) {
9594		return A2(
9595			$elm$parser$Parser$loop,
9596			_List_Nil,
9597			function (list) {
9598				return $elm$parser$Parser$oneOf(
9599					_List_fromArray(
9600						[
9601							A2(
9602							$elm$parser$Parser$map,
9603							function (_new) {
9604								return $elm$parser$Parser$Loop(
9605									A2($elm$core$List$cons, _new, list));
9606							},
9607							parser_),
9608							$elm$core$List$isEmpty(list) ? $elm$parser$Parser$problem('expecting at least one ' + type_) : $elm$parser$Parser$succeed(
9609							$elm$parser$Parser$Done(
9610								$elm$core$List$reverse(list)))
9611						]));
9612			});
9613	});
9614var $hecrj$html_parser$Html$Parser$tagAttributeUnquotedValue = function () {
9615	var isUnquotedValueChar = function (c) {
9616		return (!$hecrj$html_parser$Html$Parser$isSpaceCharacter(c)) && ((!_Utils_eq(
9617			c,
9618			_Utils_chr('\"'))) && ((!_Utils_eq(
9619			c,
9620			_Utils_chr('\''))) && ((!_Utils_eq(
9621			c,
9622			_Utils_chr('='))) && ((!_Utils_eq(
9623			c,
9624			_Utils_chr('<'))) && ((!_Utils_eq(
9625			c,
9626			_Utils_chr('>'))) && ((!_Utils_eq(
9627			c,
9628			_Utils_chr('`'))) && (!_Utils_eq(
9629			c,

9630			_Utils_chr('&')))))))));
9631	};
9632	return A2(
9633		$elm$parser$Parser$map,
9634		$elm$core$String$join(''),
9635		A2(
9636			$hecrj$html_parser$Html$Parser$oneOrMore,
9637			'attribute value',
9638			$elm$parser$Parser$oneOf(
9639				_List_fromArray(
9640					[
9641						$elm$parser$Parser$getChompedString(
9642						$hecrj$html_parser$Html$Parser$chompOneOrMore(isUnquotedValueChar)),
9643						$hecrj$html_parser$Html$Parser$characterReference
9644					]))));
9645}();
9646var $hecrj$html_parser$Html$Parser$tagAttributeValue = $elm$parser$Parser$oneOf(
9647	_List_fromArray(
9648		[
9649			A2(
9650			$elm$parser$Parser$keeper,
9651			A2(
9652				$elm$parser$Parser$ignorer,
9653				A2(
9654					$elm$parser$Parser$ignorer,
9655					$elm$parser$Parser$succeed($elm$core$Basics$identity),
9656					$elm$parser$Parser$chompIf(
9657						$elm$core$Basics$eq(
9658							_Utils_chr('=')))),
9659				$elm$parser$Parser$chompWhile($hecrj$html_parser$Html$Parser$isSpaceCharacter)),
9660			$elm$parser$Parser$oneOf(
9661				_List_fromArray(
9662					[
9663						$hecrj$html_parser$Html$Parser$tagAttributeUnquotedValue,
9664						$hecrj$html_parser$Html$Parser$tagAttributeQuotedValue(
9665						_Utils_chr('\"')),
9666						$hecrj$html_parser$Html$Parser$tagAttributeQuotedValue(
9667						_Utils_chr('\''))
9668					]))),
9669			$elm$parser$Parser$succeed('')
9670		]));
9671var $hecrj$html_parser$Html$Parser$tagAttribute = A2(
9672	$elm$parser$Parser$keeper,
9673	A2(
9674		$elm$parser$Parser$keeper,
9675		$elm$parser$Parser$succeed($elm$core$Tuple$pair),
9676		A2(
9677			$elm$parser$Parser$ignorer,
9678			$hecrj$html_parser$Html$Parser$tagAttributeName,
9679			$elm$parser$Parser$chompWhile($hecrj$html_parser$Html$Parser$isSpaceCharacter))),
9680	A2(
9681		$elm$parser$Parser$ignorer,
9682		$hecrj$html_parser$Html$Parser$tagAttributeValue,
9683		$elm$parser$Parser$chompWhile($hecrj$html_parser$Html$Parser$isSpaceCharacter)));
9684var $hecrj$html_parser$Html$Parser$tagAttributes = $hecrj$html_parser$Html$Parser$many($hecrj$html_parser$Html$Parser$tagAttribute);
9685var $hecrj$html_parser$Html$Parser$tagName = A2(
9686	$elm$parser$Parser$map,
9687	$elm$core$String$toLower,
9688	$elm$parser$Parser$getChompedString(
9689		A2(
9690			$elm$parser$Parser$ignorer,
9691			$elm$parser$Parser$chompIf($elm$core$Char$isAlphaNum),
9692			$elm$parser$Parser$chompWhile(
9693				function (c) {
9694					return $elm$core$Char$isAlphaNum(c) || _Utils_eq(
9695						c,
9696						_Utils_chr('-'));
9697				}))));
9698var $hecrj$html_parser$Html$Parser$Text = function (a) {
9699	return {$: 'Text', a: a};
9700};
9701var $hecrj$html_parser$Html$Parser$text = A2(
9702	$elm$parser$Parser$map,
9703	A2(
9704		$elm$core$Basics$composeR,
9705		$elm$core$String$join(''),
9706		$hecrj$html_parser$Html$Parser$Text),
9707	A2(
9708		$hecrj$html_parser$Html$Parser$oneOrMore,
9709		'text element',
9710		$elm$parser$Parser$oneOf(
9711			_List_fromArray(
9712				[
9713					$elm$parser$Parser$getChompedString(
9714					$hecrj$html_parser$Html$Parser$chompOneOrMore(
9715						function (c) {
9716							return (!_Utils_eq(
9717								c,
9718								_Utils_chr('<'))) && (!_Utils_eq(
9719								c,
9720								_Utils_chr('&')));
9721						})),
9722					$hecrj$html_parser$Html$Parser$characterReference
9723				]))));
9724function $hecrj$html_parser$Html$Parser$cyclic$node() {
9725	return $elm$parser$Parser$oneOf(
9726		_List_fromArray(
9727			[
9728				$hecrj$html_parser$Html$Parser$text,
9729				$hecrj$html_parser$Html$Parser$comment,
9730				$hecrj$html_parser$Html$Parser$cyclic$element()
9731			]));
9732}
9733function $hecrj$html_parser$Html$Parser$cyclic$element() {
9734	return A2(
9735		$elm$parser$Parser$andThen,
9736		function (_v0) {
9737			var name = _v0.a;
9738			var attributes = _v0.b;
9739			return $hecrj$html_parser$Html$Parser$isVoidElement(name) ? A2(
9740				$elm$parser$Parser$ignorer,
9741				A2(
9742					$elm$parser$Parser$ignorer,
9743					$elm$parser$Parser$succeed(
9744						A3($hecrj$html_parser$Html$Parser$Element, name, attributes, _List_Nil)),
9745					$elm$parser$Parser$oneOf(
9746						_List_fromArray(
9747							[
9748								$elm$parser$Parser$chompIf(
9749								$elm$core$Basics$eq(
9750									_Utils_chr('/'))),
9751								$elm$parser$Parser$succeed(_Utils_Tuple0)
9752							]))),
9753				$elm$parser$Parser$chompIf(
9754					$elm$core$Basics$eq(
9755						_Utils_chr('>')))) : A2(
9756				$elm$parser$Parser$keeper,
9757				A2(
9758					$elm$parser$Parser$ignorer,
9759					$elm$parser$Parser$succeed(
9760						A2($hecrj$html_parser$Html$Parser$Element, name, attributes)),
9761					$elm$parser$Parser$chompIf(
9762						$elm$core$Basics$eq(
9763							_Utils_chr('>')))),
9764				A2(
9765					$elm$parser$Parser$ignorer,
9766					$hecrj$html_parser$Html$Parser$many(
9767						$elm$parser$Parser$backtrackable(
9768							$hecrj$html_parser$Html$Parser$cyclic$node())),
9769					$hecrj$html_parser$Html$Parser$closingTag(name)));
9770		},
9771		A2(
9772			$elm$parser$Parser$keeper,
9773			A2(
9774				$elm$parser$Parser$keeper,
9775				A2(
9776					$elm$parser$Parser$ignorer,
9777					$elm$parser$Parser$succeed($elm$core$Tuple$pair),
9778					$elm$parser$Parser$chompIf(
9779						$elm$core$Basics$eq(
9780							_Utils_chr('<')))),
9781				A2(
9782					$elm$parser$Parser$ignorer,
9783					$hecrj$html_parser$Html$Parser$tagName,
9784					$elm$parser$Parser$chompWhile($hecrj$html_parser$Html$Parser$isSpaceCharacter))),
9785			$hecrj$html_parser$Html$Parser$tagAttributes));
9786}
9787try {
9788	var $hecrj$html_parser$Html$Parser$node = $hecrj$html_parser$Html$Parser$cyclic$node();
9789	$hecrj$html_parser$Html$Parser$cyclic$node = function () {
9790		return $hecrj$html_parser$Html$Parser$node;
9791	};
9792	var $hecrj$html_parser$Html$Parser$element = $hecrj$html_parser$Html$Parser$cyclic$element

9792();
9793	$hecrj$html_parser$Html$Parser$cyclic$element = function () {
9794		return $hecrj$html_parser$Html$Parser$element;
9795	};
9796} catch ($) {
9797	throw 'Some top-level definitions from `Html.Parser` are causing infinite recursion:\n\n  ┌─────┐\n  │    node\n  │     ↓\n  │    element\n  └─────┘\n\nThese errors are very tricky, so read https://elm-lang.org/0.19.1/bad-recursion to learn how to fix it!';}
9798var $elm$parser$Parser$DeadEnd = F3(
9799	function (row, col, problem) {
9800		return {col: col, problem: problem, row: row};
9801	});
9802var $elm$parser$Parser$problemToDeadEnd = function (p) {
9803	return A3($elm$parser$Parser$DeadEnd, p.row, p.col, p.problem);
9804};
9805var $elm$parser$Parser$Advanced$bagToList = F2(
9806	function (bag, list) {
9807		bagToList:
9808		while (true) {
9809			switch (bag.$) {
9810				case 'Empty':
9811					return list;
9812				case 'AddRight':
9813					var bag1 = bag.a;
9814					var x = bag.b;
9815					var $temp$bag = bag1,
9816						$temp$list = A2($elm$core$List$cons, x, list);
9817					bag = $temp$bag;
9818					list = $temp$list;
9819					continue bagToList;
9820				default:
9821					var bag1 = bag.a;
9822					var bag2 = bag.b;
9823					var $temp$bag = bag1,
9824						$temp$list = A2($elm$parser$Parser$Advanced$bagToList, bag2, list);
9825					bag = $temp$bag;
9826					list = $temp$list;
9827					continue bagToList;
9828			}
9829		}
9830	});
9831var $elm$parser$Parser$Advanced$run = F2(
9832	function (_v0, src) {
9833		var parse = _v0.a;
9834		var _v1 = parse(
9835			{col: 1, context: _List_Nil, indent: 1, offset: 0, row: 1, src: src});
9836		if (_v1.$ === 'Good') {
9837			var value = _v1.b;
9838			return $elm$core$Result$Ok(value);
9839		} else {
9840			var bag = _v1.b;
9841			return $elm$core$Result$Err(
9842				A2($elm$parser$Parser$Advanced$bagToList, bag, _List_Nil));
9843		}
9844	});
9845var $elm$parser$Parser$run = F2(
9846	function (parser, source) {
9847		var _v0 = A2($elm$parser$Parser$Advanced$run, parser, source);
9848		if (_v0.$ === 'Ok') {
9849			var a = _v0.a;
9850			return $elm$core$Result$Ok(a);
9851		} else {
9852			var problems = _v0.a;
9853			return $elm$core$Result$Err(
9854				A2($elm$core$List$map, $elm$parser$Parser$problemToDeadEnd, problems));
9855		}
9856	});
9857var $hecrj$html_parser$Html$Parser$run = function (str) {
9858	return $elm$core$String$isEmpty(str) ? $elm$core$Result$Ok(_List_Nil) : A2(
9859		$elm$parser$Parser$run,
9860		A2($hecrj$html_parser$Html$Parser$oneOrMore, 'node', $hecrj$html_parser$Html$Parser$node),
9861		str);
9862};
9863var $elm$virtual_dom$VirtualDom$node = function (tag) {
9864	return _VirtualDom_node(
9865		_VirtualDom_noScript(tag));
9866};
9867var $elm$html$Html$node = $elm$virtual_dom$VirtualDom$node;
9868var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
9869var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;
9870var $elm$virtual_dom$VirtualDom$attribute = F2(
9871	function (key, value) {
9872		return A2(
9873			_VirtualDom_attribute,
9874			_VirtualDom_noOnOrFormAction(key),
9875			_VirtualDom_noJavaScriptOrHtmlUri(value));
9876	});
9877var $elm$html$Html$Attributes$attribute = $elm$virtual_dom$VirtualDom$attribute;
9878var $hecrj$html_parser$Html$Parser$Util$toAttribute = function (_v0) {
9879	var name = _v0.a;
9880	var value = _v0.b;
9881	return A2($elm$html$Html$Attributes$attribute, name, value);
9882};
9883var $hecrj$html_parser$Html$Parser$Util$toVirtualDom = function (nodes) {
9884	return A2($elm$core$List$map, $hecrj$html_parser$Html$Parser$Util$toVirtualDomEach, nodes);
9885};
9886var $hecrj$html_parser$Html$Parser$Util$toVirtualDomEach = function (node) {
9887	switch (node.$) {
9888		case 'Element':
9889			var name = node.a;
9890			var attrs = node.b;
9891			var children = node.c;
9892			return A3(
9893				$elm$html$Html$node,
9894				name,
9895				A2($elm$core$List$map, $hecrj$html_parser$Html$Parser$Util$toAttribute, attrs),
9896				$hecrj$html_parser$Html$Parser$Util$toVirtualDom(children));
9897		case 'Text':
9898			var s = node.a;
9899			return $elm$html$Html$text(s);
9900		default:
9901			return $elm$html$Html$text('');
9902	}
9903};
9904var $author$project$MainCupnakyma$textHtml = function (t) {
9905	var _v0 = $hecrj$html_parser$Html$Parser$run(t);
9906	if (_v0.$ === 'Ok') {
9907		var nodes = _v0.a;
9908		return $hecrj$html_parser$Html$Parser$Util$toVirtualDom(nodes);
9909	} else {
9910		return _List_Nil;
9911	}
9912};
9913var $author$project$MainCupnakyma$view = function (model) {
9914	return A2(
9915		$elm$html$Html$span,
9916		_List_Nil,
9917		$author$project$MainCupnakyma$textHtml(
9918			$author$project$MainCupnakyma$cupHtmlTable(model)));
9919};
9920var $author$project$MainCupnakyma$main = $elm$browser$Browser$element(
9921	{init: $author$project$MainCupnakyma$init, subscriptions: $author$project$MainCupnakyma$subscriptions, update: $author$project$MainCupnakyma$update, view: $author$project$MainCupnakyma$view});
9922_Platform_export({'MainCupnakyma':{'init':$author$project$MainCupnakyma$main($elm$json$Json$Decode$string)(0)}});}(this));