elm-todomvc minification examples

original.js

(function() {
'use strict';

function F2(fun)
{
  function wrapper(a) { return function(b) { return fun(a,b); }; }
  wrapper.arity = 2;
  wrapper.func = fun;
  return wrapper;
}

function F3(fun)
{
  function wrapper(a) {
    return function(b) { return function(c) { return fun(a, b, c); }; };
  }
  wrapper.arity = 3;
  wrapper.func = fun;
  return wrapper;
}

function F4(fun)
{
  function wrapper(a) { return function(b) { return function(c) {
    return function(d) { return fun(a, b, c, d); }; }; };
  }
  wrapper.arity = 4;
  wrapper.func = fun;
  return wrapper;
}

function F5(fun)
{
  function wrapper(a) { return function(b) { return function(c) {
    return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
  }
  wrapper.arity = 5;
  wrapper.func = fun;
  return wrapper;
}

function F6(fun)
{
  function wrapper(a) { return function(b) { return function(c) {
    return function(d) { return function(e) { return function(f) {
    return fun(a, b, c, d, e, f); }; }; }; }; };
  }
  wrapper.arity = 6;
  wrapper.func = fun;
  return wrapper;
}

function F7(fun)
{
  function wrapper(a) { return function(b) { return function(c) {
    return function(d) { return function(e) { return function(f) {
    return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
  }
  wrapper.arity = 7;
  wrapper.func = fun;
  return wrapper;
}

function F8(fun)
{
  function wrapper(a) { return function(b) { return function(c) {
    return function(d) { return function(e) { return function(f) {
    return function(g) { return function(h) {
    return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
  }
  wrapper.arity = 8;
  wrapper.func = fun;
  return wrapper;
}

function F9(fun)
{
  function wrapper(a) { return function(b) { return function(c) {
    return function(d) { return function(e) { return function(f) {
    return function(g) { return function(h) { return function(i) {
    return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
  }
  wrapper.arity = 9;
  wrapper.func = fun;
  return wrapper;
}

function A2(fun, a, b)
{
  return fun.arity === 2
    ? fun.func(a, b)
    : fun(a)(b);
}
function A3(fun, a, b, c)
{
  return fun.arity === 3
    ? fun.func(a, b, c)
    : fun(a)(b)(c);
}
function A4(fun, a, b, c, d)
{
  return fun.arity === 4
    ? fun.func(a, b, c, d)
    : fun(a)(b)(c)(d);
}
function A5(fun, a, b, c, d, e)
{
  return fun.arity === 5
    ? fun.func(a, b, c, d, e)
    : fun(a)(b)(c)(d)(e);
}
function A6(fun, a, b, c, d, e, f)
{
  return fun.arity === 6
    ? fun.func(a, b, c, d, e, f)
    : fun(a)(b)(c)(d)(e)(f);
}
function A7(fun, a, b, c, d, e, f, g)
{
  return fun.arity === 7
    ? fun.func(a, b, c, d, e, f, g)
    : fun(a)(b)(c)(d)(e)(f)(g);
}
function A8(fun, a, b, c, d, e, f, g, h)
{
  return fun.arity === 8
    ? fun.func(a, b, c, d, e, f, g, h)
    : fun(a)(b)(c)(d)(e)(f)(g)(h);
}
function A9(fun, a, b, c, d, e, f, g, h, i)
{
  return fun.arity === 9
    ? fun.func(a, b, c, d, e, f, g, h, i)
    : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
}

//import Native.List //

var _elm_lang$core$Native_Array = function() {

// A RRB-Tree has two distinct data types.
// Leaf -> "height"  is always 0
//         "table"   is an array of elements
// Node -> "height"  is always greater than 0
//         "table"   is an array of child nodes
//         "lengths" is an array of accumulated lengths of the child nodes

// M is the maximal table size. 32 seems fast. E is the allowed increase
// of search steps when concatting to find an index. Lower values will
// decrease balancing, but will increase search steps.
var M = 32;
var E = 2;

// An empty array.
var empty = {
	ctor: '_Array',
	height: 0,
	table: []
};


function get(i, array)
{
	if (i < 0 || i >= length(array))
	{
		throw new Error(
			'Index ' + i + ' is out of range. Check the length of ' +
			'your array first or use getMaybe or getWithDefault.');
	}
	return unsafeGet(i, array);
}


function unsafeGet(i, array)
{
	for (var x = array.height; x > 0; x--)
	{
		var slot = i >> (x * 5);
		while (array.lengths[slot] <= i)
		{
			slot++;
		}
		if (slot > 0)
		{
			i -= array.lengths[slot - 1];
		}
		array = array.table[slot];
	}
	return array.table[i];
}


// Sets the value at the index i. Only the nodes leading to i will get
// copied and updated.
function set(i, item, array)
{
	if (i < 0 || length(array) <= i)
	{
		return array;
	}
	return unsafeSet(i, item, array);
}


function unsafeSet(i, item, array)
{
	array = nodeCopy(array);

	if (array.height === 0)
	{
		array.table[i] = item;
	}
	else
	{
		var slot = getSlot(i, array);
		if (slot > 0)
		{
			i -= array.lengths[slot - 1];
		}
		array.table[slot] = unsafeSet(i, item, array.table[slot]);
	}
	return array;
}


function initialize(len, f)
{
	if (len <= 0)
	{
		return empty;
	}
	var h = Math.floor( Math.log(len) / Math.log(M) );
	return initialize_(f, h, 0, len);
}

function initialize_(f, h, from, to)
{
	if (h === 0)
	{
		var table = new Array((to - from) % (M + 1));
		for (var i = 0; i < table.length; i++)
		{
		  table[i] = f(from + i);
		}
		return {
			ctor: '_Array',
			height: 0,
			table: table
		};
	}

	var step = Math.pow(M, h);
	var table = new Array(Math.ceil((to - from) / step));
	var lengths = new Array(table.length);
	for (var i = 0; i < table.length; i++)
	{
		table[i] = initialize_(f, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
		lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
	}
	return {
		ctor: '_Array',
		height: h,
		table: table,
		lengths: lengths
	};
}

function fromList(list)
{
	if (list.ctor === '[]')
	{
		return empty;
	}

	// Allocate M sized blocks (table) and write list elements to it.
	var table = new Array(M);
	var nodes = [];
	var i = 0;

	while (list.ctor !== '[]')
	{
		table[i] = list._0;
		list = list._1;
		i++;

		// table is full, so we can push a leaf containing it into the
		// next node.
		if (i === M)
		{
			var leaf = {
				ctor: '_Array',
				height: 0,
				table: table
			};
			fromListPush(leaf, nodes);
			table = new Array(M);
			i = 0;
		}
	}

	// Maybe there is something left on the table.
	if (i > 0)
	{
		var leaf = {
			ctor: '_Array',
			height: 0,
			table: table.splice(0, i)
		};
		fromListPush(leaf, nodes);
	}

	// Go through all of the nodes and eventually push them into higher nodes.
	for (var h = 0; h < nodes.length - 1; h++)
	{
		if (nodes[h].table.length > 0)
		{
			fromListPush(nodes[h], nodes);
		}
	}

	var head = nodes[nodes.length - 1];
	if (head.height > 0 && head.table.length === 1)
	{
		return head.table[0];
	}
	else
	{
		return head;
	}
}

// Push a node into a higher node as a child.
function fromListPush(toPush, nodes)
{
	var h = toPush.height;

	// Maybe the node on this height does not exist.
	if (nodes.length === h)
	{
		var node = {
			ctor: '_Array',
			height: h + 1,
			table: [],
			lengths: []
		};
		nodes.push(node);
	}

	nodes[h].table.push(toPush);
	var len = length(toPush);
	if (nodes[h].lengths.length > 0)
	{
		len += nodes[h].lengths[nodes[h].lengths.length - 1];
	}
	nodes[h].lengths.push(len);

	if (nodes[h].table.length === M)
	{
		fromListPush(nodes[h], nodes);
		nodes[h] = {
			ctor: '_Array',
			height: h + 1,
			table: [],
			lengths: []
		};
	}
}

// Pushes an item via push_ to the bottom right of a tree.
function push(item, a)
{
	var pushed = push_(item, a);
	if (pushed !== null)
	{
		return pushed;
	}

	var newTree = create(item, a.height);
	return siblise(a, newTree);
}

// Recursively tries to push an item to the bottom-right most
// tree possible. If there is no space left for the item,
// null will be returned.
function push_(item, a)
{
	// Handle resursion stop at leaf level.
	if (a.height === 0)
	{
		if (a.table.length < M)
		{
			var newA = {
				ctor: '_Array',
				height: 0,
				table: a.table.slice()
			};
			newA.table.push(item);
			return newA;
		}
		else
		{
		  return null;
		}
	}

	// Recursively push
	var pushed = push_(item, botRight(a));

	// There was space in the bottom right tree, so the slot will
	// be updated.
	if (pushed !== null)
	{
		var newA = nodeCopy(a);
		newA.table[newA.table.length - 1] = pushed;
		newA.lengths[newA.lengths.length - 1]++;
		return newA;
	}

	// When there was no space left, check if there is space left
	// for a new slot with a tree which contains only the item
	// at the bottom.
	if (a.table.length < M)
	{
		var newSlot = create(item, a.height - 1);
		var newA = nodeCopy(a);
		newA.table.push(newSlot);
		newA.lengths.push(newA.lengths[newA.lengths.length - 1] + length(newSlot));
		return newA;
	}
	else
	{
		return null;
	}
}

// Converts an array into a list of elements.
function toList(a)
{
	return toList_(_elm_lang$core$Native_List.Nil, a);
}

function toList_(list, a)
{
	for (var i = a.table.length - 1; i >= 0; i--)
	{
		list =
			a.height === 0
				? _elm_lang$core$Native_List.Cons(a.table[i], list)
				: toList_(list, a.table[i]);
	}
	return list;
}

// Maps a function over the elements of an array.
function map(f, a)
{
	var newA = {
		ctor: '_Array',
		height: a.height,
		table: new Array(a.table.length)
	};
	if (a.height > 0)
	{
		newA.lengths = a.lengths;
	}
	for (var i = 0; i < a.table.length; i++)
	{
		newA.table[i] =
			a.height === 0
				? f(a.table[i])
				: map(f, a.table[i]);
	}
	return newA;
}

// Maps a function over the elements with their index as first argument.
function indexedMap(f, a)
{
	return indexedMap_(f, a, 0);
}

function indexedMap_(f, a, from)
{
	var newA = {
		ctor: '_Array',
		height: a.height,
		table: new Array(a.table.length)
	};
	if (a.height > 0)
	{
		newA.lengths = a.lengths;
	}
	for (var i = 0; i < a.table.length; i++)
	{
		newA.table[i] =
			a.height === 0
				? A2(f, from + i, a.table[i])
				: indexedMap_(f, a.table[i], i == 0 ? from : from + a.lengths[i - 1]);
	}
	return newA;
}

function foldl(f, b, a)
{
	if (a.height === 0)
	{
		for (var i = 0; i < a.table.length; i++)
		{
			b = A2(f, a.table[i], b);
		}
	}
	else
	{
		for (var i = 0; i < a.table.length; i++)
		{
			b = foldl(f, b, a.table[i]);
		}
	}
	return b;
}

function foldr(f, b, a)
{
	if (a.height === 0)
	{
		for (var i = a.table.length; i--; )
		{
			b = A2(f, a.table[i], b);
		}
	}
	else
	{
		for (var i = a.table.length; i--; )
		{
			b = foldr(f, b, a.table[i]);
		}
	}
	return b;
}

// TODO: currently, it slices the right, then the left. This can be
// optimized.
function slice(from, to, a)
{
	if (from < 0)
	{
		from += length(a);
	}
	if (to < 0)
	{
		to += length(a);
	}
	return sliceLeft(from, sliceRight(to, a));
}

function sliceRight(to, a)
{
	if (to === length(a))
	{
		return a;
	}

	// Handle leaf level.
	if (a.height === 0)
	{
		var newA = { ctor:'_Array', height:0 };
		newA.table = a.table.slice(0, to);
		return newA;
	}

	// Slice the right recursively.
	var right = getSlot(to, a);
	var sliced = sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]);

	// Maybe the a node is not even needed, as sliced contains the whole slice.
	if (right === 0)
	{
		return sliced;
	}

	// Create new node.
	var newA = {
		ctor: '_Array',
		height: a.height,
		table: a.table.slice(0, right),
		lengths: a.lengths.slice(0, right)
	};
	if (sliced.table.length > 0)
	{
		newA.table[right] = sliced;
		newA.lengths[right] = length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0);
	}
	return newA;
}

function sliceLeft(from, a)
{
	if (from === 0)
	{
		return a;
	}

	// Handle leaf level.
	if (a.height === 0)
	{
		var newA = { ctor:'_Array', height:0 };
		newA.table = a.table.slice(from, a.table.length + 1);
		return newA;
	}

	// Slice the left recursively.
	var left = getSlot(from, a);
	var sliced = sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]);

	// Maybe the a node is not even needed, as sliced contains the whole slice.
	if (left === a.table.length - 1)
	{
		return sliced;
	}

	// Create new node.
	var newA = {
		ctor: '_Array',
		height: a.height,
		table: a.table.slice(left, a.table.length + 1),
		lengths: new Array(a.table.length - left)
	};
	newA.table[0] = sliced;
	var len = 0;
	for (var i = 0; i < newA.table.length; i++)
	{
		len += length(newA.table[i]);
		newA.lengths[i] = len;
	}

	return newA;
}

// Appends two trees.
function append(a,b)
{
	if (a.table.length === 0)
	{
		return b;
	}
	if (b.table.length === 0)
	{
		return a;
	}

	var c = append_(a, b);

	// Check if both nodes can be crunshed together.
	if (c[0].table.length + c[1].table.length <= M)
	{
		if (c[0].table.length === 0)
		{
			return c[1];
		}
		if (c[1].table.length === 0)
		{
			return c[0];
		}

		// Adjust .table and .lengths
		c[0].table = c[0].table.concat(c[1].table);
		if (c[0].height > 0)
		{
			var len = length(c[0]);
			for (var i = 0; i < c[1].lengths.length; i++)
			{
				c[1].lengths[i] += len;
			}
			c[0].lengths = c[0].lengths.concat(c[1].lengths);
		}

		return c[0];
	}

	if (c[0].height > 0)
	{
		var toRemove = calcToRemove(a, b);
		if (toRemove > E)
		{
			c = shuffle(c[0], c[1], toRemove);
		}
	}

	return siblise(c[0], c[1]);
}

// Returns an array of two nodes; right and left. One node _may_ be empty.
function append_(a, b)
{
	if (a.height === 0 && b.height === 0)
	{
		return [a, b];
	}

	if (a.height !== 1 || b.height !== 1)
	{
		if (a.height === b.height)
		{
			a = nodeCopy(a);
			b = nodeCopy(b);
			var appended = append_(botRight(a), botLeft(b));

			insertRight(a, appended[1]);
			insertLeft(b, appended[0]);
		}
		else if (a.height > b.height)
		{
			a = nodeCopy(a);
			var appended = append_(botRight(a), b);

			insertRight(a, appended[0]);
			b = parentise(appended[1], appended[1].height + 1);
		}
		else
		{
			b = nodeCopy(b);
			var appended = append_(a, botLeft(b));

			var left = appended[0].table.length === 0 ? 0 : 1;
			var right = left === 0 ? 1 : 0;
			insertLeft(b, appended[left]);
			a = parentise(appended[right], appended[right].height + 1);
		}
	}

	// Check if balancing is needed and return based on that.
	if (a.table.length === 0 || b.table.length === 0)
	{
		return [a, b];
	}

	var toRemove = calcToRemove(a, b);
	if (toRemove <= E)
	{
		return [a, b];
	}
	return shuffle(a, b, toRemove);
}

// Helperfunctions for append_. Replaces a child node at the side of the parent.
function insertRight(parent, node)
{
	var index = parent.table.length - 1;
	parent.table[index] = node;
	parent.lengths[index] = length(node);
	parent.lengths[index] += index > 0 ? parent.lengths[index - 1] : 0;
}

function insertLeft(parent, node)
{
	if (node.table.length > 0)
	{
		parent.table[0] = node;
		parent.lengths[0] = length(node);

		var len = length(parent.table[0]);
		for (var i = 1; i < parent.lengths.length; i++)
		{
			len += length(parent.table[i]);
			parent.lengths[i] = len;
		}
	}
	else
	{
		parent.table.shift();
		for (var i = 1; i < parent.lengths.length; i++)
		{
			parent.lengths[i] = parent.lengths[i] - parent.lengths[0];
		}
		parent.lengths.shift();
	}
}

// Returns the extra search steps for E. Refer to the paper.
function calcToRemove(a, b)
{
	var subLengths = 0;
	for (var i = 0; i < a.table.length; i++)
	{
		subLengths += a.table[i].table.length;
	}
	for (var i = 0; i < b.table.length; i++)
	{
		subLengths += b.table[i].table.length;
	}

	var toRemove = a.table.length + b.table.length;
	return toRemove - (Math.floor((subLengths - 1) / M) + 1);
}

// get2, set2 and saveSlot are helpers for accessing elements over two arrays.
function get2(a, b, index)
{
	return index < a.length
		? a[index]
		: b[index - a.length];
}

function set2(a, b, index, value)
{
	if (index < a.length)
	{
		a[index] = value;
	}
	else
	{
		b[index - a.length] = value;
	}
}

function saveSlot(a, b, index, slot)
{
	set2(a.table, b.table, index, slot);

	var l = (index === 0 || index === a.lengths.length)
		? 0
		: get2(a.lengths, a.lengths, index - 1);

	set2(a.lengths, b.lengths, index, l + length(slot));
}

// Creates a node or leaf with a given length at their arrays for perfomance.
// Is only used by shuffle.
function createNode(h, length)
{
	if (length < 0)
	{
		length = 0;
	}
	var a = {
		ctor: '_Array',
		height: h,
		table: new Array(length)
	};
	if (h > 0)
	{
		a.lengths = new Array(length);
	}
	return a;
}

// Returns an array of two balanced nodes.
function shuffle(a, b, toRemove)
{
	var newA = createNode(a.height, Math.min(M, a.table.length + b.table.length - toRemove));
	var newB = createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove));

	// Skip the slots with size M. More precise: copy the slot references
	// to the new node
	var read = 0;
	while (get2(a.table, b.table, read).table.length % M === 0)
	{
		set2(newA.table, newB.table, read, get2(a.table, b.table, read));
		set2(newA.lengths, newB.lengths, read, get2(a.lengths, b.lengths, read));
		read++;
	}

	// Pulling items from left to right, caching in a slot before writing
	// it into the new nodes.
	var write = read;
	var slot = new createNode(a.height - 1, 0);
	var from = 0;

	// If the current slot is still containing data, then there will be at
	// least one more write, so we do not break this loop yet.
	while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove)
	{
		// Find out the max possible items for copying.
		var source = get2(a.table, b.table, read);
		var to = Math.min(M - slot.table.length, source.table.length);

		// Copy and adjust size table.
		slot.table = slot.table.concat(source.table.slice(from, to));
		if (slot.height > 0)
		{
			var len = slot.lengths.length;
			for (var i = len; i < len + to - from; i++)
			{
				slot.lengths[i] = length(slot.table[i]);
				slot.lengths[i] += (i > 0 ? slot.lengths[i - 1] : 0);
			}
		}

		from += to;

		// Only proceed to next slots[i] if the current one was
		// fully copied.
		if (source.table.length <= to)
		{
			read++; from = 0;
		}

		// Only create a new slot if the current one is filled up.
		if (slot.table.length === M)
		{
			saveSlot(newA, newB, write, slot);
			slot = createNode(a.height - 1, 0);
			write++;
		}
	}

	// Cleanup after the loop. Copy the last slot into the new nodes.
	if (slot.table.length > 0)
	{
		saveSlot(newA, newB, write, slot);
		write++;
	}

	// Shift the untouched slots to the left
	while (read < a.table.length + b.table.length )
	{
		saveSlot(newA, newB, write, get2(a.table, b.table, read));
		read++;
		write++;
	}

	return [newA, newB];
}

// Navigation functions
function botRight(a)
{
	return a.table[a.table.length - 1];
}
function botLeft(a)
{
	return a.table[0];
}

// Copies a node for updating. Note that you should not use this if
// only updating only one of "table" or "lengths" for performance reasons.
function nodeCopy(a)
{
	var newA = {
		ctor: '_Array',
		height: a.height,
		table: a.table.slice()
	};
	if (a.height > 0)
	{
		newA.lengths = a.lengths.slice();
	}
	return newA;
}

// Returns how many items are in the tree.
function length(array)
{
	if (array.height === 0)
	{
		return array.table.length;
	}
	else
	{
		return array.lengths[array.lengths.length - 1];
	}
}

// Calculates in which slot of "table" the item probably is, then
// find the exact slot via forward searching in  "lengths". Returns the index.
function getSlot(i, a)
{
	var slot = i >> (5 * a.height);
	while (a.lengths[slot] <= i)
	{
		slot++;
	}
	return slot;
}

// Recursively creates a tree with a given height containing
// only the given item.
function create(item, h)
{
	if (h === 0)
	{
		return {
			ctor: '_Array',
			height: 0,
			table: [item]
		};
	}
	return {
		ctor: '_Array',
		height: h,
		table: [create(item, h - 1)],
		lengths: [1]
	};
}

// Recursively creates a tree that contains the given tree.
function parentise(tree, h)
{
	if (h === tree.height)
	{
		return tree;
	}

	return {
		ctor: '_Array',
		height: h,
		table: [parentise(tree, h - 1)],
		lengths: [length(tree)]
	};
}

// Emphasizes blood brotherhood beneath two trees.
function siblise(a, b)
{
	return {
		ctor: '_Array',
		height: a.height + 1,
		table: [a, b],
		lengths: [length(a), length(a) + length(b)]
	};
}

function toJSArray(a)
{
	var jsArray = new Array(length(a));
	toJSArray_(jsArray, 0, a);
	return jsArray;
}

function toJSArray_(jsArray, i, a)
{
	for (var t = 0; t < a.table.length; t++)
	{
		if (a.height === 0)
		{
			jsArray[i + t] = a.table[t];
		}
		else
		{
			var inc = t === 0 ? 0 : a.lengths[t - 1];
			toJSArray_(jsArray, i + inc, a.table[t]);
		}
	}
}

function fromJSArray(jsArray)
{
	if (jsArray.length === 0)
	{
		return empty;
	}
	var h = Math.floor(Math.log(jsArray.length) / Math.log(M));
	return fromJSArray_(jsArray, h, 0, jsArray.length);
}

function fromJSArray_(jsArray, h, from, to)
{
	if (h === 0)
	{
		return {
			ctor: '_Array',
			height: 0,
			table: jsArray.slice(from, to)
		};
	}

	var step = Math.pow(M, h);
	var table = new Array(Math.ceil((to - from) / step));
	var lengths = new Array(table.length);
	for (var i = 0; i < table.length; i++)
	{
		table[i] = fromJSArray_(jsArray, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
		lengths[i] = length(table[i]) + (i > 0 ? lengths[i - 1] : 0);
	}
	return {
		ctor: '_Array',
		height: h,
		table: table,
		lengths: lengths
	};
}

return {
	empty: empty,
	fromList: fromList,
	toList: toList,
	initialize: F2(initialize),
	append: F2(append),
	push: F2(push),
	slice: F3(slice),
	get: F2(get),
	set: F3(set),
	map: F2(map),
	indexedMap: F2(indexedMap),
	foldl: F3(foldl),
	foldr: F3(foldr),
	length: length,

	toJSArray: toJSArray,
	fromJSArray: fromJSArray
};

}();
//import Native.Utils //

var _elm_lang$core$Native_Basics = function() {

function div(a, b)
{
	return (a / b) | 0;
}
function rem(a, b)
{
	return a % b;
}
function mod(a, b)
{
	if (b === 0)
	{
		throw new Error('Cannot perform mod 0. Division by zero error.');
	}
	var r = a % b;
	var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r + b) : -mod(-a, -b));

	return m === b ? 0 : m;
}
function logBase(base, n)
{
	return Math.log(n) / Math.log(base);
}
function negate(n)
{
	return -n;
}
function abs(n)
{
	return n < 0 ? -n : n;
}

function min(a, b)
{
	return _elm_lang$core$Native_Utils.cmp(a, b) < 0 ? a : b;
}
function max(a, b)
{
	return _elm_lang$core$Native_Utils.cmp(a, b) > 0 ? a : b;
}
function clamp(lo, hi, n)
{
	return _elm_lang$core$Native_Utils.cmp(n, lo) < 0
		? lo
		: _elm_lang$core$Native_Utils.cmp(n, hi) > 0
			? hi
			: n;
}

var ord = ['LT', 'EQ', 'GT'];

function compare(x, y)
{
	return { ctor: ord[_elm_lang$core$Native_Utils.cmp(x, y) + 1] };
}

function xor(a, b)
{
	return a !== b;
}
function not(b)
{
	return !b;
}
function isInfinite(n)
{
	return n === Infinity || n === -Infinity;
}

function truncate(n)
{
	return n | 0;
}

function degrees(d)
{
	return d * Math.PI / 180;
}
function turns(t)
{
	return 2 * Math.PI * t;
}
function fromPolar(point)
{
	var r = point._0;
	var t = point._1;
	return _elm_lang$core$Native_Utils.Tuple2(r * Math.cos(t), r * Math.sin(t));
}
function toPolar(point)
{
	var x = point._0;
	var y = point._1;
	return _elm_lang$core$Native_Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y, x));
}

return {
	div: F2(div),
	rem: F2(rem),
	mod: F2(mod),

	pi: Math.PI,
	e: Math.E,
	cos: Math.cos,
	sin: Math.sin,
	tan: Math.tan,
	acos: Math.acos,
	asin: Math.asin,
	atan: Math.atan,
	atan2: F2(Math.atan2),

	degrees: degrees,
	turns: turns,
	fromPolar: fromPolar,
	toPolar: toPolar,

	sqrt: Math.sqrt,
	logBase: F2(logBase),
	negate: negate,
	abs: abs,
	min: F2(min),
	max: F2(max),
	clamp: F3(clamp),
	compare: F2(compare),

	xor: F2(xor),
	not: not,

	truncate: truncate,
	ceiling: Math.ceil,
	floor: Math.floor,
	round: Math.round,
	toFloat: function(x) { return x; },
	isNaN: isNaN,
	isInfinite: isInfinite
};

}();
//import //

var _elm_lang$core$Native_Utils = function() {

// COMPARISONS

function eq(x, y)
{
	var stack = [];
	var isEqual = eqHelp(x, y, 0, stack);
	var pair;
	while (isEqual && (pair = stack.pop()))
	{
		isEqual = eqHelp(pair.x, pair.y, 0, stack);
	}
	return isEqual;
}


function eqHelp(x, y, depth, stack)
{
	if (depth > 100)
	{
		stack.push({ x: x, y: y });
		return true;
	}

	if (x === y)
	{
		return true;
	}

	if (typeof x !== 'object')
	{
		if (typeof x === 'function')
		{
			throw new Error(
				'Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense.'
				+ ' Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#=='
				+ ' which describes why it is this way and what the better version will look like.'
			);
		}
		return false;
	}

	if (x === null || y === null)
	{
		return false
	}

	if (x instanceof Date)
	{
		return x.getTime() === y.getTime();
	}

	if (!('ctor' in x))
	{
		for (var key in x)
		{
			if (!eqHelp(x[key], y[key], depth + 1, stack))
			{
				return false;
			}
		}
		return true;
	}

	// convert Dicts and Sets to lists
	if (x.ctor === 'RBNode_elm_builtin' || x.ctor === 'RBEmpty_elm_builtin')
	{
		x = _elm_lang$core$Dict$toList(x);
		y = _elm_lang$core$Dict$toList(y);
	}
	if (x.ctor === 'Set_elm_builtin')
	{
		x = _elm_lang$core$Set$toList(x);
		y = _elm_lang$core$Set$toList(y);
	}

	// check if lists are equal without recursion
	if (x.ctor === '::')
	{
		var a = x;
		var b = y;
		while (a.ctor === '::' && b.ctor === '::')
		{
			if (!eqHelp(a._0, b._0, depth + 1, stack))
			{
				return false;
			}
			a = a._1;
			b = b._1;
		}
		return a.ctor === b.ctor;
	}

	// check if Arrays are equal
	if (x.ctor === '_Array')
	{
		var xs = _elm_lang$core$Native_Array.toJSArray(x);
		var ys = _elm_lang$core$Native_Array.toJSArray(y);
		if (xs.length !== ys.length)
		{
			return false;
		}
		for (var i = 0; i < xs.length; i++)
		{
			if (!eqHelp(xs[i], ys[i], depth + 1, stack))
			{
				return false;
			}
		}
		return true;
	}

	if (!eqHelp(x.ctor, y.ctor, depth + 1, stack))
	{
		return false;
	}

	for (var key in x)
	{
		if (!eqHelp(x[key], y[key], depth + 1, stack))
		{
			return false;
		}
	}
	return true;
}

// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
// the particular integer values assigned to LT, EQ, and GT.

var LT = -1, EQ = 0, GT = 1;

function cmp(x, y)
{
	if (typeof x !== 'object')
	{
		return x === y ? EQ : x < y ? LT : GT;
	}

	if (x instanceof String)
	{
		var a = x.valueOf();
		var b = y.valueOf();
		return a === b ? EQ : a < b ? LT : GT;
	}

	if (x.ctor === '::' || x.ctor === '[]')
	{
		while (x.ctor === '::' && y.ctor === '::')
		{
			var ord = cmp(x._0, y._0);
			if (ord !== EQ)
			{
				return ord;
			}
			x = x._1;
			y = y._1;
		}
		return x.ctor === y.ctor ? EQ : x.ctor === '[]' ? LT : GT;
	}

	if (x.ctor.slice(0, 6) === '_Tuple')
	{
		var ord;
		var n = x.ctor.slice(6) - 0;
		var err = 'cannot compare tuples with more than 6 elements.';
		if (n === 0) return EQ;
		if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord;
		if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord;
		if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord;
		if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord;
		if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord;
		if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord;
		if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } }
		return EQ;
	}

	throw new Error(
		'Comparison error: comparison is only defined on ints, '
		+ 'floats, times, chars, strings, lists of comparable values, '
		+ 'and tuples of comparable values.'
	);
}


// COMMON VALUES

var Tuple0 = {
	ctor: '_Tuple0'
};

function Tuple2(x, y)
{
	return {
		ctor: '_Tuple2',
		_0: x,
		_1: y
	};
}

function chr(c)
{
	return new String(c);
}


// GUID

var count = 0;
function guid(_)
{
	return count++;
}


// RECORDS

function update(oldRecord, updatedFields)
{
	var newRecord = {};

	for (var key in oldRecord)
	{
		newRecord[key] = oldRecord[key];
	}

	for (var key in updatedFields)
	{
		newRecord[key] = updatedFields[key];
	}

	return newRecord;
}


//// LIST STUFF ////

var Nil = { ctor: '[]' };

function Cons(hd, tl)
{
	return {
		ctor: '::',
		_0: hd,
		_1: tl
	};
}

function append(xs, ys)
{
	// append Strings
	if (typeof xs === 'string')
	{
		return xs + ys;
	}

	// append Lists
	if (xs.ctor === '[]')
	{
		return ys;
	}
	var root = Cons(xs._0, Nil);
	var curr = root;
	xs = xs._1;
	while (xs.ctor !== '[]')
	{
		curr._1 = Cons(xs._0, Nil);
		xs = xs._1;
		curr = curr._1;
	}
	curr._1 = ys;
	return root;
}


// CRASHES

function crash(moduleName, region)
{
	return function(message) {
		throw new Error(
			'Ran into a `Debug.crash` in module `' + moduleName + '` ' + regionToString(region) + '\n'
			+ 'The message provided by the code author is:\n\n    '
			+ message
		);
	};
}

function crashCase(moduleName, region, value)
{
	return function(message) {
		throw new Error(
			'Ran into a `Debug.crash` in module `' + moduleName + '`\n\n'
			+ 'This was caused by the `case` expression ' + regionToString(region) + '.\n'
			+ 'One of the branches ended with a crash and the following value got through:\n\n    ' + toString(value) + '\n\n'
			+ 'The message provided by the code author is:\n\n    '
			+ message
		);
	};
}

function regionToString(region)
{
	if (region.start.line == region.end.line)
	{
		return 'on line ' + region.start.line;
	}
	return 'between lines ' + region.start.line + ' and ' + region.end.line;
}


// TO STRING

function toString(v)
{
	var type = typeof v;
	if (type === 'function')
	{
		return '<function>';
	}

	if (type === 'boolean')
	{
		return v ? 'True' : 'False';
	}

	if (type === 'number')
	{
		return v + '';
	}

	if (v instanceof String)
	{
		return '\'' + addSlashes(v, true) + '\'';
	}

	if (type === 'string')
	{
		return '"' + addSlashes(v, false) + '"';
	}

	if (v === null)
	{
		return 'null';
	}

	if (type === 'object' && 'ctor' in v)
	{
		var ctorStarter = v.ctor.substring(0, 5);

		if (ctorStarter === '_Tupl')
		{
			var output = [];
			for (var k in v)
			{
				if (k === 'ctor') continue;
				output.push(toString(v[k]));
			}
			return '(' + output.join(',') + ')';
		}

		if (ctorStarter === '_Task')
		{
			return '<task>'
		}

		if (v.ctor === '_Array')
		{
			var list = _elm_lang$core$Array$toList(v);
			return 'Array.fromList ' + toString(list);
		}

		if (v.ctor === '<decoder>')
		{
			return '<decoder>';
		}

		if (v.ctor === '_Process')
		{
			return '<process:' + v.id + '>';
		}

		if (v.ctor === '::')
		{
			var output = '[' + toString(v._0);
			v = v._1;
			while (v.ctor === '::')
			{
				output += ',' + toString(v._0);
				v = v._1;
			}
			return output + ']';
		}

		if (v.ctor === '[]')
		{
			return '[]';
		}

		if (v.ctor === 'Set_elm_builtin')
		{
			return 'Set.fromList ' + toString(_elm_lang$core$Set$toList(v));
		}

		if (v.ctor === 'RBNode_elm_builtin' || v.ctor === 'RBEmpty_elm_builtin')
		{
			return 'Dict.fromList ' + toString(_elm_lang$core$Dict$toList(v));
		}

		var output = '';
		for (var i in v)
		{
			if (i === 'ctor') continue;
			var str = toString(v[i]);
			var c0 = str[0];
			var parenless = c0 === '{' || c0 === '(' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
			output += ' ' + (parenless ? str : '(' + str + ')');
		}
		return v.ctor + output;
	}

	if (type === 'object')
	{
		if (v instanceof Date)
		{
			return '<' + v.toString() + '>';
		}

		if (v.elm_web_socket)
		{
			return '<websocket>';
		}

		var output = [];
		for (var k in v)
		{
			output.push(k + ' = ' + toString(v[k]));
		}
		if (output.length === 0)
		{
			return '{}';
		}
		return '{ ' + output.join(', ') + ' }';
	}

	return '<internal structure>';
}

function addSlashes(str, isChar)
{
	var s = str.replace(/\\/g, '\\\\')
			  .replace(/\n/g, '\\n')
			  .replace(/\t/g, '\\t')
			  .replace(/\r/g, '\\r')
			  .replace(/\v/g, '\\v')
			  .replace(/\0/g, '\\0');
	if (isChar)
	{
		return s.replace(/\'/g, '\\\'');
	}
	else
	{
		return s.replace(/\"/g, '\\"');
	}
}


return {
	eq: eq,
	cmp: cmp,
	Tuple0: Tuple0,
	Tuple2: Tuple2,
	chr: chr,
	update: update,
	guid: guid,

	append: F2(append),

	crash: crash,
	crashCase: crashCase,

	toString: toString
};

}();
var _elm_lang$core$Basics$never = function (_p0) {
	never:
	while (true) {
		var _p1 = _p0;
		var _v1 = _p1._0;
		_p0 = _v1;
		continue never;
	}
};
var _elm_lang$core$Basics$uncurry = F2(
	function (f, _p2) {
		var _p3 = _p2;
		return A2(f, _p3._0, _p3._1);
	});
var _elm_lang$core$Basics$curry = F3(
	function (f, a, b) {
		return f(
			{ctor: '_Tuple2', _0: a, _1: b});
	});
var _elm_lang$core$Basics$flip = F3(
	function (f, b, a) {
		return A2(f, a, b);
	});
var _elm_lang$core$Basics$always = F2(
	function (a, _p4) {
		return a;
	});
var _elm_lang$core$Basics$identity = function (x) {
	return x;
};
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['<|'] = F2(
	function (f, x) {
		return f(x);
	});
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['|>'] = F2(
	function (x, f) {
		return f(x);
	});
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['>>'] = F3(
	function (f, g, x) {
		return g(
			f(x));
	});
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['<<'] = F3(
	function (g, f, x) {
		return g(
			f(x));
	});
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['++'] = _elm_lang$core$Native_Utils.append;
var _elm_lang$core$Basics$toString = _elm_lang$core$Native_Utils.toString;
var _elm_lang$core$Basics$isInfinite = _elm_lang$core$Native_Basics.isInfinite;
var _elm_lang$core$Basics$isNaN = _elm_lang$core$Native_Basics.isNaN;
var _elm_lang$core$Basics$toFloat = _elm_lang$core$Native_Basics.toFloat;
var _elm_lang$core$Basics$ceiling = _elm_lang$core$Native_Basics.ceiling;
var _elm_lang$core$Basics$floor = _elm_lang$core$Native_Basics.floor;
var _elm_lang$core$Basics$truncate = _elm_lang$core$Native_Basics.truncate;
var _elm_lang$core$Basics$round = _elm_lang$core$Native_Basics.round;
var _elm_lang$core$Basics$not = _elm_lang$core$Native_Basics.not;
var _elm_lang$core$Basics$xor = _elm_lang$core$Native_Basics.xor;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['||'] = _elm_lang$core$Native_Basics.or;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['&&'] = _elm_lang$core$Native_Basics.and;
var _elm_lang$core$Basics$max = _elm_lang$core$Native_Basics.max;
var _elm_lang$core$Basics$min = _elm_lang$core$Native_Basics.min;
var _elm_lang$core$Basics$compare = _elm_lang$core$Native_Basics.compare;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['>='] = _elm_lang$core$Native_Basics.ge;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['<='] = _elm_lang$core$Native_Basics.le;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['>'] = _elm_lang$core$Native_Basics.gt;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['<'] = _elm_lang$core$Native_Basics.lt;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['/='] = _elm_lang$core$Native_Basics.neq;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['=='] = _elm_lang$core$Native_Basics.eq;
var _elm_lang$core$Basics$e = _elm_lang$core$Native_Basics.e;
var _elm_lang$core$Basics$pi = _elm_lang$core$Native_Basics.pi;
var _elm_lang$core$Basics$clamp = _elm_lang$core$Native_Basics.clamp;
var _elm_lang$core$Basics$logBase = _elm_lang$core$Native_Basics.logBase;
var _elm_lang$core$Basics$abs = _elm_lang$core$Native_Basics.abs;
var _elm_lang$core$Basics$negate = _elm_lang$core$Native_Basics.negate;
var _elm_lang$core$Basics$sqrt = _elm_lang$core$Native_Basics.sqrt;
var _elm_lang$core$Basics$atan2 = _elm_lang$core$Native_Basics.atan2;
var _elm_lang$core$Basics$atan = _elm_lang$core$Native_Basics.atan;
var _elm_lang$core$Basics$asin = _elm_lang$core$Native_Basics.asin;
var _elm_lang$core$Basics$acos = _elm_lang$core$Native_Basics.acos;
var _elm_lang$core$Basics$tan = _elm_lang$core$Native_Basics.tan;
var _elm_lang$core$Basics$sin = _elm_lang$core$Native_Basics.sin;
var _elm_lang$core$Basics$cos = _elm_lang$core$Native_Basics.cos;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['^'] = _elm_lang$core$Native_Basics.exp;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['%'] = _elm_lang$core$Native_Basics.mod;
var _elm_lang$core$Basics$rem = _elm_lang$core$Native_Basics.rem;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['//'] = _elm_lang$core$Native_Basics.div;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['/'] = _elm_lang$core$Native_Basics.floatDiv;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['*'] = _elm_lang$core$Native_Basics.mul;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['-'] = _elm_lang$core$Native_Basics.sub;
var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
_elm_lang$core$Basics_ops['+'] = _elm_lang$core$Native_Basics.add;
var _elm_lang$core$Basics$toPolar = _elm_lang$core$Native_Basics.toPolar;
var _elm_lang$core$Basics$fromPolar = _elm_lang$core$Native_Basics.fromPolar;
var _elm_lang$core$Basics$turns = _elm_lang$core$Native_Basics.turns;
var _elm_lang$core$Basics$degrees = _elm_lang$core$Native_Basics.degrees;
var _elm_lang$core$Basics$radians = function (t) {
	return t;
};
var _elm_lang$core$Basics$GT = {ctor: 'GT'};
var _elm_lang$core$Basics$EQ = {ctor: 'EQ'};
var _elm_lang$core$Basics$LT = {ctor: 'LT'};
var _elm_lang$core$Basics$JustOneMore = function (a) {
	return {ctor: 'JustOneMore', _0: a};
};

var _elm_lang$core$Maybe$withDefault = F2(
	function ($default, maybe) {
		var _p0 = maybe;
		if (_p0.ctor === 'Just') {
			return _p0._0;
		} else {
			return $default;
		}
	});
var _elm_lang$core$Maybe$Nothing = {ctor: 'Nothing'};
var _elm_lang$core$Maybe$andThen = F2(
	function (callback, maybeValue) {
		var _p1 = maybeValue;
		if (_p1.ctor === 'Just') {
			return callback(_p1._0);
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
var _elm_lang$core$Maybe$Just = function (a) {
	return {ctor: 'Just', _0: a};
};
var _elm_lang$core$Maybe$map = F2(
	function (f, maybe) {
		var _p2 = maybe;
		if (_p2.ctor === 'Just') {
			return _elm_lang$core$Maybe$Just(
				f(_p2._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
var _elm_lang$core$Maybe$map2 = F3(
	function (func, ma, mb) {
		var _p3 = {ctor: '_Tuple2', _0: ma, _1: mb};
		if (((_p3.ctor === '_Tuple2') && (_p3._0.ctor === 'Just')) && (_p3._1.ctor === 'Just')) {
			return _elm_lang$core$Maybe$Just(
				A2(func, _p3._0._0, _p3._1._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
var _elm_lang$core$Maybe$map3 = F4(
	function (func, ma, mb, mc) {
		var _p4 = {ctor: '_Tuple3', _0: ma, _1: mb, _2: mc};
		if ((((_p4.ctor === '_Tuple3') && (_p4._0.ctor === 'Just')) && (_p4._1.ctor === 'Just')) && (_p4._2.ctor === 'Just')) {
			return _elm_lang$core$Maybe$Just(
				A3(func, _p4._0._0, _p4._1._0, _p4._2._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
var _elm_lang$core$Maybe$map4 = F5(
	function (func, ma, mb, mc, md) {
		var _p5 = {ctor: '_Tuple4', _0: ma, _1: mb, _2: mc, _3: md};
		if (((((_p5.ctor === '_Tuple4') && (_p5._0.ctor === 'Just')) && (_p5._1.ctor === 'Just')) && (_p5._2.ctor === 'Just')) && (_p5._3.ctor === 'Just')) {
			return _elm_lang$core$Maybe$Just(
				A4(func, _p5._0._0, _p5._1._0, _p5._2._0, _p5._3._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
var _elm_lang$core$Maybe$map5 = F6(
	function (func, ma, mb, mc, md, me) {
		var _p6 = {ctor: '_Tuple5', _0: ma, _1: mb, _2: mc, _3: md, _4: me};
		if ((((((_p6.ctor === '_Tuple5') && (_p6._0.ctor === 'Just')) && (_p6._1.ctor === 'Just')) && (_p6._2.ctor === 'Just')) && (_p6._3.ctor === 'Just')) && (_p6._4.ctor === 'Just')) {
			return _elm_lang$core$Maybe$Just(
				A5(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0, _p6._4._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});

//import Native.Utils //

var _elm_lang$core$Native_List = function() {

var Nil = { ctor: '[]' };

function Cons(hd, tl)
{
	return { ctor: '::', _0: hd, _1: tl };
}

function fromArray(arr)
{
	var out = Nil;
	for (var i = arr.length; i--; )
	{
		out = Cons(arr[i], out);
	}
	return out;
}

function toArray(xs)
{
	var out = [];
	while (xs.ctor !== '[]')
	{
		out.push(xs._0);
		xs = xs._1;
	}
	return out;
}

function foldr(f, b, xs)
{
	var arr = toArray(xs);
	var acc = b;
	for (var i = arr.length; i--; )
	{
		acc = A2(f, arr[i], acc);
	}
	return acc;
}

function map2(f, xs, ys)
{
	var arr = [];
	while (xs.ctor !== '[]' && ys.ctor !== '[]')
	{
		arr.push(A2(f, xs._0, ys._0));
		xs = xs._1;
		ys = ys._1;
	}
	return fromArray(arr);
}

function map3(f, xs, ys, zs)
{
	var arr = [];
	while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]')
	{
		arr.push(A3(f, xs._0, ys._0, zs._0));
		xs = xs._1;
		ys = ys._1;
		zs = zs._1;
	}
	return fromArray(arr);
}

function map4(f, ws, xs, ys, zs)
{
	var arr = [];
	while (   ws.ctor !== '[]'
		   && xs.ctor !== '[]'
		   && ys.ctor !== '[]'
		   && zs.ctor !== '[]')
	{
		arr.push(A4(f, ws._0, xs._0, ys._0, zs._0));
		ws = ws._1;
		xs = xs._1;
		ys = ys._1;
		zs = zs._1;
	}
	return fromArray(arr);
}

function map5(f, vs, ws, xs, ys, zs)
{
	var arr = [];
	while (   vs.ctor !== '[]'
		   && ws.ctor !== '[]'
		   && xs.ctor !== '[]'
		   && ys.ctor !== '[]'
		   && zs.ctor !== '[]')
	{
		arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0));
		vs = vs._1;
		ws = ws._1;
		xs = xs._1;
		ys = ys._1;
		zs = zs._1;
	}
	return fromArray(arr);
}

function sortBy(f, xs)
{
	return fromArray(toArray(xs).sort(function(a, b) {
		return _elm_lang$core$Native_Utils.cmp(f(a), f(b));
	}));
}

function sortWith(f, xs)
{
	return fromArray(toArray(xs).sort(function(a, b) {
		var ord = f(a)(b).ctor;
		return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1;
	}));
}

return {
	Nil: Nil,
	Cons: Cons,
	cons: F2(Cons),
	toArray: toArray,
	fromArray: fromArray,

	foldr: F3(foldr),

	map2: F3(map2),
	map3: F4(map3),
	map4: F5(map4),
	map5: F6(map5),
	sortBy: F2(sortBy),
	sortWith: F2(sortWith)
};

}();
var _elm_lang$core$List$sortWith = _elm_lang$core$Native_List.sortWith;
var _elm_lang$core$List$sortBy = _elm_lang$core$Native_List.sortBy;
var _elm_lang$core$List$sort = function (xs) {
	return A2(_elm_lang$core$List$sortBy, _elm_lang$core$Basics$identity, xs);
};
var _elm_lang$core$List$singleton = function (value) {
	return {
		ctor: '::',
		_0: value,
		_1: {ctor: '[]'}
	};
};
var _elm_lang$core$List$drop = F2(
	function (n, list) {
		drop:
		while (true) {
			if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
				return list;
			} else {
				var _p0 = list;
				if (_p0.ctor === '[]') {
					return list;
				} else {
					var _v1 = n - 1,
						_v2 = _p0._1;
					n = _v1;
					list = _v2;
					continue drop;
				}
			}
		}
	});
var _elm_lang$core$List$map5 = _elm_lang$core$Native_List.map5;
var _elm_lang$core$List$map4 = _elm_lang$core$Native_List.map4;
var _elm_lang$core$List$map3 = _elm_lang$core$Native_List.map3;
var _elm_lang$core$List$map2 = _elm_lang$core$Native_List.map2;
var _elm_lang$core$List$any = F2(
	function (isOkay, list) {
		any:
		while (true) {
			var _p1 = list;
			if (_p1.ctor === '[]') {
				return false;
			} else {
				if (isOkay(_p1._0)) {
					return true;
				} else {
					var _v4 = isOkay,
						_v5 = _p1._1;
					isOkay = _v4;
					list = _v5;
					continue any;
				}
			}
		}
	});
var _elm_lang$core$List$all = F2(
	function (isOkay, list) {
		return !A2(
			_elm_lang$core$List$any,
			function (_p2) {
				return !isOkay(_p2);
			},
			list);
	});
var _elm_lang$core$List$foldr = _elm_lang$core$Native_List.foldr;
var _elm_lang$core$List$foldl = F3(
	function (func, acc, list) {
		foldl:
		while (true) {
			var _p3 = list;
			if (_p3.ctor === '[]') {
				return acc;
			} else {
				var _v7 = func,
					_v8 = A2(func, _p3._0, acc),
					_v9 = _p3._1;
				func = _v7;
				acc = _v8;
				list = _v9;
				continue foldl;
			}
		}
	});
var _elm_lang$core$List$length = function (xs) {
	return A3(
		_elm_lang$core$List$foldl,
		F2(
			function (_p4, i) {
				return i + 1;
			}),
		0,
		xs);
};
var _elm_lang$core$List$sum = function (numbers) {
	return A3(
		_elm_lang$core$List$foldl,
		F2(
			function (x, y) {
				return x + y;
			}),
		0,
		numbers);
};
var _elm_lang$core$List$product = function (numbers) {
	return A3(
		_elm_lang$core$List$foldl,
		F2(
			function (x, y) {
				return x * y;
			}),
		1,
		numbers);
};
var _elm_lang$core$List$maximum = function (list) {
	var _p5 = list;
	if (_p5.ctor === '::') {
		return _elm_lang$core$Maybe$Just(
			A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$max, _p5._0, _p5._1));
	} else {
		return _elm_lang$core$Maybe$Nothing;
	}
};
var _elm_lang$core$List$minimum = function (list) {
	var _p6 = list;
	if (_p6.ctor === '::') {
		return _elm_lang$core$Maybe$Just(
			A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$min, _p6._0, _p6._1));
	} else {
		return _elm_lang$core$Maybe$Nothing;
	}
};
var _elm_lang$core$List$member = F2(
	function (x, xs) {
		return A2(
			_elm_lang$core$List$any,
			function (a) {
				return _elm_lang$core$Native_Utils.eq(a, x);
			},
			xs);
	});
var _elm_lang$core$List$isEmpty = function (xs) {
	var _p7 = xs;
	if (_p7.ctor === '[]') {
		return true;
	} else {
		return false;
	}
};
var _elm_lang$core$List$tail = function (list) {
	var _p8 = list;
	if (_p8.ctor === '::') {
		return _elm_lang$core$Maybe$Just(_p8._1);
	} else {
		return _elm_lang$core$Maybe$Nothing;
	}
};
var _elm_lang$core$List$head = function (list) {
	var _p9 = list;
	if (_p9.ctor === '::') {
		return _elm_lang$core$Maybe$Just(_p9._0);
	} else {
		return _elm_lang$core$Maybe$Nothing;
	}
};
var _elm_lang$core$List_ops = _elm_lang$core$List_ops || {};
_elm_lang$core$List_ops['::'] = _elm_lang$core$Native_List.cons;
var _elm_lang$core$List$map = F2(
	function (f, xs) {
		return A3(
			_elm_lang$core$List$foldr,
			F2(
				function (x, acc) {
					return {
						ctor: '::',
						_0: f(x),
						_1: acc
					};
				}),
			{ctor: '[]'},
			xs);
	});
var _elm_lang$core$List$filter = F2(
	function (pred, xs) {
		var conditionalCons = F2(
			function (front, back) {
				return pred(front) ? {ctor: '::', _0: front, _1: back} : back;
			});
		return A3(
			_elm_lang$core$List$foldr,
			conditionalCons,
			{ctor: '[]'},
			xs);
	});
var _elm_lang$core$List$maybeCons = F3(
	function (f, mx, xs) {
		var _p10 = f(mx);
		if (_p10.ctor === 'Just') {
			return {ctor: '::', _0: _p10._0, _1: xs};
		} else {
			return xs;
		}
	});
var _elm_lang$core$List$filterMap = F2(
	function (f, xs) {
		return A3(
			_elm_lang$core$List$foldr,
			_elm_lang$core$List$maybeCons(f),
			{ctor: '[]'},
			xs);
	});
var _elm_lang$core$List$reverse = function (list) {
	return A3(
		_elm_lang$core$List$foldl,
		F2(
			function (x, y) {
				return {ctor: '::', _0: x, _1: y};
			}),
		{ctor: '[]'},
		list);
};
var _elm_lang$core$List$scanl = F3(
	function (f, b, xs) {
		var scan1 = F2(
			function (x, accAcc) {
				var _p11 = accAcc;
				if (_p11.ctor === '::') {
					return {
						ctor: '::',
						_0: A2(f, x, _p11._0),
						_1: accAcc
					};
				} else {
					return {ctor: '[]'};
				}
			});
		return _elm_lang$core$List$reverse(
			A3(
				_elm_lang$core$List$foldl,
				scan1,
				{
					ctor: '::',
					_0: b,
					_1: {ctor: '[]'}
				},
				xs));
	});
var _elm_lang$core$List$append = F2(
	function (xs, ys) {
		var _p12 = ys;
		if (_p12.ctor === '[]') {
			return xs;
		} else {
			return A3(
				_elm_lang$core$List$foldr,
				F2(
					function (x, y) {
						return {ctor: '::', _0: x, _1: y};
					}),
				ys,
				xs);
		}
	});
var _elm_lang$core$List$concat = function (lists) {
	return A3(
		_elm_lang$core$List$foldr,
		_elm_lang$core$List$append,
		{ctor: '[]'},
		lists);
};
var _elm_lang$core$List$concatMap = F2(
	function (f, list) {
		return _elm_lang$core$List$concat(
			A2(_elm_lang$core$List$map, f, list));
	});
var _elm_lang$core$List$partition = F2(
	function (pred, list) {
		var step = F2(
			function (x, _p13) {
				var _p14 = _p13;
				var _p16 = _p14._0;
				var _p15 = _p14._1;
				return pred(x) ? {
					ctor: '_Tuple2',
					_0: {ctor: '::', _0: x, _1: _p16},
					_1: _p15
				} : {
					ctor: '_Tuple2',
					_0: _p16,
					_1: {ctor: '::', _0: x, _1: _p15}
				};
			});
		return A3(
			_elm_lang$core$List$foldr,
			step,
			{
				ctor: '_Tuple2',
				_0: {ctor: '[]'},
				_1: {ctor: '[]'}
			},
			list);
	});
var _elm_lang$core$List$unzip = function (pairs) {
	var step = F2(
		function (_p18, _p17) {
			var _p19 = _p18;
			var _p20 = _p17;
			return {
				ctor: '_Tuple2',
				_0: {ctor: '::', _0: _p19._0, _1: _p20._0},
				_1: {ctor: '::', _0: _p19._1, _1: _p20._1}
			};
		});
	return A3(
		_elm_lang$core$List$foldr,
		step,
		{
			ctor: '_Tuple2',
			_0: {ctor: '[]'},
			_1: {ctor: '[]'}
		},
		pairs);
};
var _elm_lang$core$List$intersperse = F2(
	function (sep, xs) {
		var _p21 = xs;
		if (_p21.ctor === '[]') {
			return {ctor: '[]'};
		} else {
			var step = F2(
				function (x, rest) {
					return {
						ctor: '::',
						_0: sep,
						_1: {ctor: '::', _0: x, _1: rest}
					};
				});
			var spersed = A3(
				_elm_lang$core$List$foldr,
				step,
				{ctor: '[]'},
				_p21._1);
			return {ctor: '::', _0: _p21._0, _1: spersed};
		}
	});
var _elm_lang$core$List$takeReverse = F3(
	function (n, list, taken) {
		takeReverse:
		while (true) {
			if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
				return taken;
			} else {
				var _p22 = list;
				if (_p22.ctor === '[]') {
					return taken;
				} else {
					var _v23 = n - 1,
						_v24 = _p22._1,
						_v25 = {ctor: '::', _0: _p22._0, _1: taken};
					n = _v23;
					list = _v24;
					taken = _v25;
					continue takeReverse;
				}
			}
		}
	});
var _elm_lang$core$List$takeTailRec = F2(
	function (n, list) {
		return _elm_lang$core$List$reverse(
			A3(
				_elm_lang$core$List$takeReverse,
				n,
				list,
				{ctor: '[]'}));
	});
var _elm_lang$core$List$takeFast = F3(
	function (ctr, n, list) {
		if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
			return {ctor: '[]'};
		} else {
			var _p23 = {ctor: '_Tuple2', _0: n, _1: list};
			_v26_5:
			do {
				_v26_1:
				do {
					if (_p23.ctor === '_Tuple2') {
						if (_p23._1.ctor === '[]') {
							return list;
						} else {
							if (_p23._1._1.ctor === '::') {
								switch (_p23._0) {
									case 1:
										break _v26_1;
									case 2:
										return {
											ctor: '::',
											_0: _p23._1._0,
											_1: {
												ctor: '::',
												_0: _p23._1._1._0,
												_1: {ctor: '[]'}
											}
										};
									case 3:
										if (_p23._1._1._1.ctor === '::') {
											return {
												ctor: '::',
												_0: _p23._1._0,
												_1: {
													ctor: '::',
													_0: _p23._1._1._0,
													_1: {
														ctor: '::',
														_0: _p23._1._1._1._0,
														_1: {ctor: '[]'}
													}
												}
											};
										} else {
											break _v26_5;
										}
									default:
										if ((_p23._1._1._1.ctor === '::') && (_p23._1._1._1._1.ctor === '::')) {
											var _p28 = _p23._1._1._1._0;
											var _p27 = _p23._1._1._0;
											var _p26 = _p23._1._0;
											var _p25 = _p23._1._1._1._1._0;
											var _p24 = _p23._1._1._1._1._1;
											return (_elm_lang$core$Native_Utils.cmp(ctr, 1000) > 0) ? {
												ctor: '::',
												_0: _p26,
												_1: {
													ctor: '::',
													_0: _p27,
													_1: {
														ctor: '::',
														_0: _p28,
														_1: {
															ctor: '::',
															_0: _p25,
															_1: A2(_elm_lang$core$List$takeTailRec, n - 4, _p24)
														}
													}
												}
											} : {
												ctor: '::',
												_0: _p26,
												_1: {
													ctor: '::',
													_0: _p27,
													_1: {
														ctor: '::',
														_0: _p28,
														_1: {
															ctor: '::',
															_0: _p25,
															_1: A3(_elm_lang$core$List$takeFast, ctr + 1, n - 4, _p24)
														}
													}
												}
											};
										} else {
											break _v26_5;
										}
								}
							} else {
								if (_p23._0 === 1) {
									break _v26_1;
								} else {
									break _v26_5;
								}
							}
						}
					} else {
						break _v26_5;
					}
				} while(false);
				return {
					ctor: '::',
					_0: _p23._1._0,
					_1: {ctor: '[]'}
				};
			} while(false);
			return list;
		}
	});
var _elm_lang$core$List$take = F2(
	function (n, list) {
		return A3(_elm_lang$core$List$takeFast, 0, n, list);
	});
var _elm_lang$core$List$repeatHelp = F3(
	function (result, n, value) {
		repeatHelp:
		while (true) {
			if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) {
				return result;
			} else {
				var _v27 = {ctor: '::', _0: value, _1: result},
					_v28 = n - 1,
					_v29 = value;
				result = _v27;
				n = _v28;
				value = _v29;
				continue repeatHelp;
			}
		}
	});
var _elm_lang$core$List$repeat = F2(
	function (n, value) {
		return A3(
			_elm_lang$core$List$repeatHelp,
			{ctor: '[]'},
			n,
			value);
	});
var _elm_lang$core$List$rangeHelp = F3(
	function (lo, hi, list) {
		rangeHelp:
		while (true) {
			if (_elm_lang$core$Native_Utils.cmp(lo, hi) < 1) {
				var _v30 = lo,
					_v31 = hi - 1,
					_v32 = {ctor: '::', _0: hi, _1: list};
				lo = _v30;
				hi = _v31;
				list = _v32;
				continue rangeHelp;
			} else {
				return list;
			}
		}
	});
var _elm_lang$core$List$range = F2(
	function (lo, hi) {
		return A3(
			_elm_lang$core$List$rangeHelp,
			lo,
			hi,
			{ctor: '[]'});
	});
var _elm_lang$core$List$indexedMap = F2(
	function (f, xs) {
		return A3(
			_elm_lang$core$List$map2,
			f,
			A2(
				_elm_lang$core$List$range,
				0,
				_elm_lang$core$List$length(xs) - 1),
			xs);
	});

var _elm_lang$core$Array$append = _elm_lang$core$Native_Array.append;
var _elm_lang$core$Array$length = _elm_lang$core$Native_Array.length;
var _elm_lang$core$Array$isEmpty = function (array) {
	return _elm_lang$core$Native_Utils.eq(
		_elm_lang$core$Array$length(array),
		0);
};
var _elm_lang$core$Array$slice = _elm_lang$core$Native_Array.slice;
var _elm_lang$core$Array$set = _elm_lang$core$Native_Array.set;
var _elm_lang$core$Array$get = F2(
	function (i, array) {
		return ((_elm_lang$core$Native_Utils.cmp(0, i) < 1) && (_elm_lang$core$Native_Utils.cmp(
			i,
			_elm_lang$core$Native_Array.length(array)) < 0)) ? _elm_lang$core$Maybe$Just(
			A2(_elm_lang$core$Native_Array.get, i, array)) : _elm_lang$core$Maybe$Nothing;
	});
var _elm_lang$core$Array$push = _elm_lang$core$Native_Array.push;
var _elm_lang$core$Array$empty = _elm_lang$core$Native_Array.empty;
var _elm_lang$core$Array$filter = F2(
	function (isOkay, arr) {
		var update = F2(
			function (x, xs) {
				return isOkay(x) ? A2(_elm_lang$core$Native_Array.push, x, xs) : xs;
			});
		return A3(_elm_lang$core$Native_Array.foldl, update, _elm_lang$core$Native_Array.empty, arr);
	});
var _elm_lang$core$Array$foldr = _elm_lang$core$Native_Array.foldr;
var _elm_lang$core$Array$foldl = _elm_lang$core$Native_Array.foldl;
var _elm_lang$core$Array$indexedMap = _elm_lang$core$Native_Array.indexedMap;
var _elm_lang$core$Array$map = _elm_lang$core$Native_Array.map;
var _elm_lang$core$Array$toIndexedList = function (array) {
	return A3(
		_elm_lang$core$List$map2,
		F2(
			function (v0, v1) {
				return {ctor: '_Tuple2', _0: v0, _1: v1};
			}),
		A2(
			_elm_lang$core$List$range,
			0,
			_elm_lang$core$Native_Array.length(array) - 1),
		_elm_lang$core$Native_Array.toList(array));
};
var _elm_lang$core$Array$toList = _elm_lang$core$Native_Array.toList;
var _elm_lang$core$Array$fromList = _elm_lang$core$Native_Array.fromList;
var _elm_lang$core$Array$initialize = _elm_lang$core$Native_Array.initialize;
var _elm_lang$core$Array$repeat = F2(
	function (n, e) {
		return A2(
			_elm_lang$core$Array$initialize,
			n,
			_elm_lang$core$Basics$always(e));
	});
var _elm_lang$core$Array$Array = {ctor: 'Array'};

//import Native.Utils //

var _elm_lang$core$Native_Char = function() {

return {
	fromCode: function(c) { return _elm_lang$core$Native_Utils.chr(String.fromCharCode(c)); },
	toCode: function(c) { return c.charCodeAt(0); },
	toUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toUpperCase()); },
	toLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLowerCase()); },
	toLocaleUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleUpperCase()); },
	toLocaleLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleLowerCase()); }
};

}();
var _elm_lang$core$Char$fromCode = _elm_lang$core$Native_Char.fromCode;
var _elm_lang$core$Char$toCode = _elm_lang$core$Native_Char.toCode;
var _elm_lang$core$Char$toLocaleLower = _elm_lang$core$Native_Char.toLocaleLower;
var _elm_lang$core$Char$toLocaleUpper = _elm_lang$core$Native_Char.toLocaleUpper;
var _elm_lang$core$Char$toLower = _elm_lang$core$Native_Char.toLower;
var _elm_lang$core$Char$toUpper = _elm_lang$core$Native_Char.toUpper;
var _elm_lang$core$Char$isBetween = F3(
	function (low, high, $char) {
		var code = _elm_lang$core$Char$toCode($char);
		return (_elm_lang$core$Native_Utils.cmp(
			code,
			_elm_lang$core$Char$toCode(low)) > -1) && (_elm_lang$core$Native_Utils.cmp(
			code,
			_elm_lang$core$Char$toCode(high)) < 1);
	});
var _elm_lang$core$Char$isUpper = A2(
	_elm_lang$core$Char$isBetween,
	_elm_lang$core$Native_Utils.chr('A'),
	_elm_lang$core$Native_Utils.chr('Z'));
var _elm_lang$core$Char$isLower = A2(
	_elm_lang$core$Char$isBetween,
	_elm_lang$core$Native_Utils.chr('a'),
	_elm_lang$core$Native_Utils.chr('z'));
var _elm_lang$core$Char$isDigit = A2(
	_elm_lang$core$Char$isBetween,
	_elm_lang$core$Native_Utils.chr('0'),
	_elm_lang$core$Native_Utils.chr('9'));
var _elm_lang$core$Char$isOctDigit = A2(
	_elm_lang$core$Char$isBetween,
	_elm_lang$core$Native_Utils.chr('0'),
	_elm_lang$core$Native_Utils.chr('7'));
var _elm_lang$core$Char$isHexDigit = function ($char) {
	return _elm_lang$core$Char$isDigit($char) || (A3(
		_elm_lang$core$Char$isBetween,
		_elm_lang$core$Native_Utils.chr('a'),
		_elm_lang$core$Native_Utils.chr('f'),
		$char) || A3(
		_elm_lang$core$Char$isBetween,
		_elm_lang$core$Native_Utils.chr('A'),
		_elm_lang$core$Native_Utils.chr('F'),
		$char));
};

//import Native.Utils //

var _elm_lang$core$Native_Scheduler = function() {

var MAX_STEPS = 10000;


// TASKS

function succeed(value)
{
	return {
		ctor: '_Task_succeed',
		value: value
	};
}

function fail(error)
{
	return {
		ctor: '_Task_fail',
		value: error
	};
}

function nativeBinding(callback)
{
	return {
		ctor: '_Task_nativeBinding',
		callback: callback,
		cancel: null
	};
}

function andThen(callback, task)
{
	return {
		ctor: '_Task_andThen',
		callback: callback,
		task: task
	};
}

function onError(callback, task)
{
	return {
		ctor: '_Task_onError',
		callback: callback,
		task: task
	};
}

function receive(callback)
{
	return {
		ctor: '_Task_receive',
		callback: callback
	};
}


// PROCESSES

function rawSpawn(task)
{
	var process = {
		ctor: '_Process',
		id: _elm_lang$core$Native_Utils.guid(),
		root: task,
		stack: null,
		mailbox: []
	};

	enqueue(process);

	return process;
}

function spawn(task)
{
	return nativeBinding(function(callback) {
		var process = rawSpawn(task);
		callback(succeed(process));
	});
}

function rawSend(process, msg)
{
	process.mailbox.push(msg);
	enqueue(process);
}

function send(process, msg)
{
	return nativeBinding(function(callback) {
		rawSend(process, msg);
		callback(succeed(_elm_lang$core$Native_Utils.Tuple0));
	});
}

function kill(process)
{
	return nativeBinding(function(callback) {
		var root = process.root;
		if (root.ctor === '_Task_nativeBinding' && root.cancel)
		{
			root.cancel();
		}

		process.root = null;

		callback(succeed(_elm_lang$core$Native_Utils.Tuple0));
	});
}

function sleep(time)
{
	return nativeBinding(function(callback) {
		var id = setTimeout(function() {
			callback(succeed(_elm_lang$core$Native_Utils.Tuple0));
		}, time);

		return function() { clearTimeout(id); };
	});
}


// STEP PROCESSES

function step(numSteps, process)
{
	while (numSteps < MAX_STEPS)
	{
		var ctor = process.root.ctor;

		if (ctor === '_Task_succeed')
		{
			while (process.stack && process.stack.ctor === '_Task_onError')
			{
				process.stack = process.stack.rest;
			}
			if (process.stack === null)
			{
				break;
			}
			process.root = process.stack.callback(process.root.value);
			process.stack = process.stack.rest;
			++numSteps;
			continue;
		}

		if (ctor === '_Task_fail')
		{
			while (process.stack && process.stack.ctor === '_Task_andThen')
			{
				process.stack = process.stack.rest;
			}
			if (process.stack === null)
			{
				break;
			}
			process.root = process.stack.callback(process.root.value);
			process.stack = process.stack.rest;
			++numSteps;
			continue;
		}

		if (ctor === '_Task_andThen')
		{
			process.stack = {
				ctor: '_Task_andThen',
				callback: process.root.callback,
				rest: process.stack
			};
			process.root = process.root.task;
			++numSteps;
			continue;
		}

		if (ctor === '_Task_onError')
		{
			process.stack = {
				ctor: '_Task_onError',
				callback: process.root.callback,
				rest: process.stack
			};
			process.root = process.root.task;
			++numSteps;
			continue;
		}

		if (ctor === '_Task_nativeBinding')
		{
			process.root.cancel = process.root.callback(function(newRoot) {
				process.root = newRoot;
				enqueue(process);
			});

			break;
		}

		if (ctor === '_Task_receive')
		{
			var mailbox = process.mailbox;
			if (mailbox.length === 0)
			{
				break;
			}

			process.root = process.root.callback(mailbox.shift());
			++numSteps;
			continue;
		}

		throw new Error(ctor);
	}

	if (numSteps < MAX_STEPS)
	{
		return numSteps + 1;
	}
	enqueue(process);

	return numSteps;
}


// WORK QUEUE

var working = false;
var workQueue = [];

function enqueue(process)
{
	workQueue.push(process);

	if (!working)
	{
		setTimeout(work, 0);
		working = true;
	}
}

function work()
{
	var numSteps = 0;
	var process;
	while (numSteps < MAX_STEPS && (process = workQueue.shift()))
	{
		if (process.root)
		{
			numSteps = step(numSteps, process);
		}
	}
	if (!process)
	{
		working = false;
		return;
	}
	setTimeout(work, 0);
}


return {
	succeed: succeed,
	fail: fail,
	nativeBinding: nativeBinding,
	andThen: F2(andThen),
	onError: F2(onError),
	receive: receive,

	spawn: spawn,
	kill: kill,
	sleep: sleep,
	send: F2(send),

	rawSpawn: rawSpawn,
	rawSend: rawSend
};

}();
//import //

var _elm_lang$core$Native_Platform = function() {


// PROGRAMS

function program(impl)
{
	return function(flagDecoder)
	{
		return function(object, moduleName)
		{
			object['worker'] = function worker(flags)
			{
				if (typeof flags !== 'undefined')
				{
					throw new Error(
						'The `' + moduleName + '` module does not need flags.\n'
						+ 'Call ' + moduleName + '.worker() with no arguments and you should be all set!'
					);
				}

				return initialize(
					impl.init,
					impl.update,
					impl.subscriptions,
					renderer
				);
			};
		};
	};
}

function programWithFlags(impl)
{
	return function(flagDecoder)
	{
		return function(object, moduleName)
		{
			object['worker'] = function worker(flags)
			{
				if (typeof flagDecoder === 'undefined')
				{
					throw new Error(
						'Are you trying to sneak a Never value into Elm? Trickster!\n'
						+ 'It looks like ' + moduleName + '.main is defined with `programWithFlags` but has type `Program Never`.\n'
						+ 'Use `program` instead if you do not want flags.'
					);
				}

				var result = A2(_elm_lang$core$Native_Json.run, flagDecoder, flags);
				if (result.ctor === 'Err')
				{
					throw new Error(
						moduleName + '.worker(...) was called with an unexpected argument.\n'
						+ 'I tried to convert it to an Elm value, but ran into this problem:\n\n'
						+ result._0
					);
				}

				return initialize(
					impl.init(result._0),
					impl.update,
					impl.subscriptions,
					renderer
				);
			};
		};
	};
}

function renderer(enqueue, _)
{
	return function(_) {};
}


// HTML TO PROGRAM

function htmlToProgram(vnode)
{
	var emptyBag = batch(_elm_lang$core$Native_List.Nil);
	var noChange = _elm_lang$core$Native_Utils.Tuple2(
		_elm_lang$core$Native_Utils.Tuple0,
		emptyBag
	);

	return _elm_lang$virtual_dom$VirtualDom$program({
		init: noChange,
		view: function(model) { return main; },
		update: F2(function(msg, model) { return noChange; }),
		subscriptions: function (model) { return emptyBag; }
	});
}


// INITIALIZE A PROGRAM

function initialize(init, update, subscriptions, renderer)
{
	// ambient state
	var managers = {};
	var updateView;

	// init and update state in main process
	var initApp = _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) {
		var model = init._0;
		updateView = renderer(enqueue, model);
		var cmds = init._1;
		var subs = subscriptions(model);
		dispatchEffects(managers, cmds, subs);
		callback(_elm_lang$core$Native_Scheduler.succeed(model));
	});

	function onMessage(msg, model)
	{
		return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) {
			var results = A2(update, msg, model);
			model = results._0;
			updateView(model);
			var cmds = results._1;
			var subs = subscriptions(model);
			dispatchEffects(managers, cmds, subs);
			callback(_elm_lang$core$Native_Scheduler.succeed(model));
		});
	}

	var mainProcess = spawnLoop(initApp, onMessage);

	function enqueue(msg)
	{
		_elm_lang$core$Native_Scheduler.rawSend(mainProcess, msg);
	}

	var ports = setupEffects(managers, enqueue);

	return ports ? { ports: ports } : {};
}


// EFFECT MANAGERS

var effectManagers = {};

function setupEffects(managers, callback)
{
	var ports;

	// setup all necessary effect managers
	for (var key in effectManagers)
	{
		var manager = effectManagers[key];

		if (manager.isForeign)
		{
			ports = ports || {};
			ports[key] = manager.tag === 'cmd'
				? setupOutgoingPort(key)
				: setupIncomingPort(key, callback);
		}

		managers[key] = makeManager(manager, callback);
	}

	return ports;
}

function makeManager(info, callback)
{
	var router = {
		main: callback,
		self: undefined
	};

	var tag = info.tag;
	var onEffects = info.onEffects;
	var onSelfMsg = info.onSelfMsg;

	function onMessage(msg, state)
	{
		if (msg.ctor === 'self')
		{
			return A3(onSelfMsg, router, msg._0, state);
		}

		var fx = msg._0;
		switch (tag)
		{
			case 'cmd':
				return A3(onEffects, router, fx.cmds, state);

			case 'sub':
				return A3(onEffects, router, fx.subs, state);

			case 'fx':
				return A4(onEffects, router, fx.cmds, fx.subs, state);
		}
	}

	var process = spawnLoop(info.init, onMessage);
	router.self = process;
	return process;
}

function sendToApp(router, msg)
{
	return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback)
	{
		router.main(msg);
		callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0));
	});
}

function sendToSelf(router, msg)
{
	return A2(_elm_lang$core$Native_Scheduler.send, router.self, {
		ctor: 'self',
		_0: msg
	});
}


// HELPER for STATEFUL LOOPS

function spawnLoop(init, onMessage)
{
	var andThen = _elm_lang$core$Native_Scheduler.andThen;

	function loop(state)
	{
		var handleMsg = _elm_lang$core$Native_Scheduler.receive(function(msg) {
			return onMessage(msg, state);
		});
		return A2(andThen, loop, handleMsg);
	}

	var task = A2(andThen, loop, init);

	return _elm_lang$core$Native_Scheduler.rawSpawn(task);
}


// BAGS

function leaf(home)
{
	return function(value)
	{
		return {
			type: 'leaf',
			home: home,
			value: value
		};
	};
}

function batch(list)
{
	return {
		type: 'node',
		branches: list
	};
}

function map(tagger, bag)
{
	return {
		type: 'map',
		tagger: tagger,
		tree: bag
	}
}


// PIPE BAGS INTO EFFECT MANAGERS

function dispatchEffects(managers, cmdBag, subBag)
{
	var effectsDict = {};
	gatherEffects(true, cmdBag, effectsDict, null);
	gatherEffects(false, subBag, effectsDict, null);

	for (var home in managers)
	{
		var fx = home in effectsDict
			? effectsDict[home]
			: {
				cmds: _elm_lang$core$Native_List.Nil,
				subs: _elm_lang$core$Native_List.Nil
			};

		_elm_lang$core$Native_Scheduler.rawSend(managers[home], { ctor: 'fx', _0: fx });
	}
}

function gatherEffects(isCmd, bag, effectsDict, taggers)
{
	switch (bag.type)
	{
		case 'leaf':
			var home = bag.home;
			var effect = toEffect(isCmd, home, taggers, bag.value);
			effectsDict[home] = insert(isCmd, effect, effectsDict[home]);
			return;

		case 'node':
			var list = bag.branches;
			while (list.ctor !== '[]')
			{
				gatherEffects(isCmd, list._0, effectsDict, taggers);
				list = list._1;
			}
			return;

		case 'map':
			gatherEffects(isCmd, bag.tree, effectsDict, {
				tagger: bag.tagger,
				rest: taggers
			});
			return;
	}
}

function toEffect(isCmd, home, taggers, value)
{
	function applyTaggers(x)
	{
		var temp = taggers;
		while (temp)
		{
			x = temp.tagger(x);
			temp = temp.rest;
		}
		return x;
	}

	var map = isCmd
		? effectManagers[home].cmdMap
		: effectManagers[home].subMap;

	return A2(map, applyTaggers, value)
}

function insert(isCmd, newEffect, effects)
{
	effects = effects || {
		cmds: _elm_lang$core$Native_List.Nil,
		subs: _elm_lang$core$Native_List.Nil
	};
	if (isCmd)
	{
		effects.cmds = _elm_lang$core$Native_List.Cons(newEffect, effects.cmds);
		return effects;
	}
	effects.subs = _elm_lang$core$Native_List.Cons(newEffect, effects.subs);
	return effects;
}


// PORTS

function checkPortName(name)
{
	if (name in effectManagers)
	{
		throw new Error('There can only be one port named `' + name + '`, but your program has multiple.');
	}
}


// OUTGOING PORTS

function outgoingPort(name, converter)
{
	checkPortName(name);
	effectManagers[name] = {
		tag: 'cmd',
		cmdMap: outgoingPortMap,
		converter: converter,
		isForeign: true
	};
	return leaf(name);
}

var outgoingPortMap = F2(function cmdMap(tagger, value) {
	return value;
});

function setupOutgoingPort(name)
{
	var subs = [];
	var converter = effectManagers[name].converter;

	// CREATE MANAGER

	var init = _elm_lang$core$Native_Scheduler.succeed(null);

	function onEffects(router, cmdList, state)
	{
		while (cmdList.ctor !== '[]')
		{
			// grab a separate reference to subs in case unsubscribe is called
			var currentSubs = subs;
			var value = converter(cmdList._0);
			for (var i = 0; i < currentSubs.length; i++)
			{
				currentSubs[i](value);
			}
			cmdList = cmdList._1;
		}
		return init;
	}

	effectManagers[name].init = init;
	effectManagers[name].onEffects = F3(onEffects);

	// PUBLIC API

	function subscribe(callback)
	{
		subs.push(callback);
	}

	function unsubscribe(callback)
	{
		// copy subs into a new array in case unsubscribe is called within a
		// subscribed callback
		subs = subs.slice();
		var index = subs.indexOf(callback);
		if (index >= 0)
		{
			subs.splice(index, 1);
		}
	}

	return {
		subscribe: subscribe,
		unsubscribe: unsubscribe
	};
}


// INCOMING PORTS

function incomingPort(name, converter)
{
	checkPortName(name);
	effectManagers[name] = {
		tag: 'sub',
		subMap: incomingPortMap,
		converter: converter,
		isForeign: true
	};
	return leaf(name);
}

var incomingPortMap = F2(function subMap(tagger, finalTagger)
{
	return function(value)
	{
		return tagger(finalTagger(value));
	};
});

function setupIncomingPort(name, callback)
{
	var sentBeforeInit = [];
	var subs = _elm_lang$core$Native_List.Nil;
	var converter = effectManagers[name].converter;
	var currentOnEffects = preInitOnEffects;
	var currentSend = preInitSend;

	// CREATE MANAGER

	var init = _elm_lang$core$Native_Scheduler.succeed(null);

	function preInitOnEffects(router, subList, state)
	{
		var postInitResult = postInitOnEffects(router, subList, state);

		for(var i = 0; i < sentBeforeInit.length; i++)
		{
			postInitSend(sentBeforeInit[i]);
		}

		sentBeforeInit = null; // to release objects held in queue
		currentSend = postInitSend;
		currentOnEffects = postInitOnEffects;
		return postInitResult;
	}

	function postInitOnEffects(router, subList, state)
	{
		subs = subList;
		return init;
	}

	function onEffects(router, subList, state)
	{
		return currentOnEffects(router, subList, state);
	}

	effectManagers[name].init = init;
	effectManagers[name].onEffects = F3(onEffects);

	// PUBLIC API

	function preInitSend(value)
	{
		sentBeforeInit.push(value);
	}

	function postInitSend(value)
	{
		var temp = subs;
		while (temp.ctor !== '[]')
		{
			callback(temp._0(value));
			temp = temp._1;
		}
	}

	function send(incomingValue)
	{
		var result = A2(_elm_lang$core$Json_Decode$decodeValue, converter, incomingValue);
		if (result.ctor === 'Err')
		{
			throw new Error('Trying to send an unexpected type of value through port `' + name + '`:\n' + result._0);
		}

		currentSend(result._0);
	}

	return { send: send };
}

return {
	// routers
	sendToApp: F2(sendToApp),
	sendToSelf: F2(sendToSelf),

	// global setup
	effectManagers: effectManagers,
	outgoingPort: outgoingPort,
	incomingPort: incomingPort,

	htmlToProgram: htmlToProgram,
	program: program,
	programWithFlags: programWithFlags,
	initialize: initialize,

	// effect bags
	leaf: leaf,
	batch: batch,
	map: F2(map)
};

}();

var _elm_lang$core$Platform_Cmd$batch = _elm_lang$core$Native_Platform.batch;
var _elm_lang$core$Platform_Cmd$none = _elm_lang$core$Platform_Cmd$batch(
	{ctor: '[]'});
var _elm_lang$core$Platform_Cmd_ops = _elm_lang$core$Platform_Cmd_ops || {};
_elm_lang$core$Platform_Cmd_ops['!'] = F2(
	function (model, commands) {
		return {
			ctor: '_Tuple2',
			_0: model,
			_1: _elm_lang$core$Platform_Cmd$batch(commands)
		};
	});
var _elm_lang$core$Platform_Cmd$map = _elm_lang$core$Native_Platform.map;
var _elm_lang$core$Platform_Cmd$Cmd = {ctor: 'Cmd'};

var _elm_lang$core$Platform_Sub$batch = _elm_lang$core$Native_Platform.batch;
var _elm_lang$core$Platform_Sub$none = _elm_lang$core$Platform_Sub$batch(
	{ctor: '[]'});
var _elm_lang$core$Platform_Sub$map = _elm_lang$core$Native_Platform.map;
var _elm_lang$core$Platform_Sub$Sub = {ctor: 'Sub'};

var _elm_lang$core$Platform$hack = _elm_lang$core$Native_Scheduler.succeed;
var _elm_lang$core$Platform$sendToSelf = _elm_lang$core$Native_Platform.sendToSelf;
var _elm_lang$core$Platform$sendToApp = _elm_lang$core$Native_Platform.sendToApp;
var _elm_lang$core$Platform$programWithFlags = _elm_lang$core$Native_Platform.programWithFlags;
var _elm_lang$core$Platform$program = _elm_lang$core$Native_Platform.program;
var _elm_lang$core$Platform$Program = {ctor: 'Program'};
var _elm_lang$core$Platform$Task = {ctor: 'Task'};
var _elm_lang$core$Platform$ProcessId = {ctor: 'ProcessId'};
var _elm_lang$core$Platform$Router = {ctor: 'Router'};

var _elm_lang$core$Result$toMaybe = function (result) {
	var _p0 = result;
	if (_p0.ctor === 'Ok') {
		return _elm_lang$core$Maybe$Just(_p0._0);
	} else {
		return _elm_lang$core$Maybe$Nothing;
	}
};
var _elm_lang$core$Result$withDefault = F2(
	function (def, result) {
		var _p1 = result;
		if (_p1.ctor === 'Ok') {
			return _p1._0;
		} else {
			return def;
		}
	});
var _elm_lang$core$Result$Err = function (a) {
	return {ctor: 'Err', _0: a};
};
var _elm_lang$core$Result$andThen = F2(
	function (callback, result) {
		var _p2 = result;
		if (_p2.ctor === 'Ok') {
			return callback(_p2._0);
		} else {
			return _elm_lang$core$Result$Err(_p2._0);
		}
	});
var _elm_lang$core$Result$Ok = function (a) {
	return {ctor: 'Ok', _0: a};
};
var _elm_lang$core$Result$map = F2(
	function (func, ra) {
		var _p3 = ra;
		if (_p3.ctor === 'Ok') {
			return _elm_lang$core$Result$Ok(
				func(_p3._0));
		} else {
			return _elm_lang$core$Result$Err(_p3._0);
		}
	});
var _elm_lang$core$Result$map2 = F3(
	function (func, ra, rb) {
		var _p4 = {ctor: '_Tuple2', _0: ra, _1: rb};
		if (_p4._0.ctor === 'Ok') {
			if (_p4._1.ctor === 'Ok') {
				return _elm_lang$core$Result$Ok(
					A2(func, _p4._0._0, _p4._1._0));
			} else {
				return _elm_lang$core$Result$Err(_p4._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p4._0._0);
		}
	});
var _elm_lang$core$Result$map3 = F4(
	function (func, ra, rb, rc) {
		var _p5 = {ctor: '_Tuple3', _0: ra, _1: rb, _2: rc};
		if (_p5._0.ctor === 'Ok') {
			if (_p5._1.ctor === 'Ok') {
				if (_p5._2.ctor === 'Ok') {
					return _elm_lang$core$Result$Ok(
						A3(func, _p5._0._0, _p5._1._0, _p5._2._0));
				} else {
					return _elm_lang$core$Result$Err(_p5._2._0);
				}
			} else {
				return _elm_lang$core$Result$Err(_p5._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p5._0._0);
		}
	});
var _elm_lang$core$Result$map4 = F5(
	function (func, ra, rb, rc, rd) {
		var _p6 = {ctor: '_Tuple4', _0: ra, _1: rb, _2: rc, _3: rd};
		if (_p6._0.ctor === 'Ok') {
			if (_p6._1.ctor === 'Ok') {
				if (_p6._2.ctor === 'Ok') {
					if (_p6._3.ctor === 'Ok') {
						return _elm_lang$core$Result$Ok(
							A4(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0));
					} else {
						return _elm_lang$core$Result$Err(_p6._3._0);
					}
				} else {
					return _elm_lang$core$Result$Err(_p6._2._0);
				}
			} else {
				return _elm_lang$core$Result$Err(_p6._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p6._0._0);
		}
	});
var _elm_lang$core$Result$map5 = F6(
	function (func, ra, rb, rc, rd, re) {
		var _p7 = {ctor: '_Tuple5', _0: ra, _1: rb, _2: rc, _3: rd, _4: re};
		if (_p7._0.ctor === 'Ok') {
			if (_p7._1.ctor === 'Ok') {
				if (_p7._2.ctor === 'Ok') {
					if (_p7._3.ctor === 'Ok') {
						if (_p7._4.ctor === 'Ok') {
							return _elm_lang$core$Result$Ok(
								A5(func, _p7._0._0, _p7._1._0, _p7._2._0, _p7._3._0, _p7._4._0));
						} else {
							return _elm_lang$core$Result$Err(_p7._4._0);
						}
					} else {
						return _elm_lang$core$Result$Err(_p7._3._0);
					}
				} else {
					return _elm_lang$core$Result$Err(_p7._2._0);
				}
			} else {
				return _elm_lang$core$Result$Err(_p7._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p7._0._0);
		}
	});
var _elm_lang$core$Result$mapError = F2(
	function (f, result) {
		var _p8 = result;
		if (_p8.ctor === 'Ok') {
			return _elm_lang$core$Result$Ok(_p8._0);
		} else {
			return _elm_lang$core$Result$Err(
				f(_p8._0));
		}
	});
var _elm_lang$core$Result$fromMaybe = F2(
	function (err, maybe) {
		var _p9 = maybe;
		if (_p9.ctor === 'Just') {
			return _elm_lang$core$Result$Ok(_p9._0);
		} else {
			return _elm_lang$core$Result$Err(err);
		}
	});

var _elm_lang$core$Task$onError = _elm_lang$core$Native_Scheduler.onError;
var _elm_lang$core$Task$andThen = _elm_lang$core$Native_Scheduler.andThen;
var _elm_lang$core$Task$spawnCmd = F2(
	function (router, _p0) {
		var _p1 = _p0;
		return _elm_lang$core$Native_Scheduler.spawn(
			A2(
				_elm_lang$core$Task$andThen,
				_elm_lang$core$Platform$sendToApp(router),
				_p1._0));
	});
var _elm_lang$core$Task$fail = _elm_lang$core$Native_Scheduler.fail;
var _elm_lang$core$Task$mapError = F2(
	function (convert, task) {
		return A2(
			_elm_lang$core$Task$onError,
			function (_p2) {
				return _elm_lang$core$Task$fail(
					convert(_p2));
			},
			task);
	});
var _elm_lang$core$Task$succeed = _elm_lang$core$Native_Scheduler.succeed;
var _elm_lang$core$Task$map = F2(
	function (func, taskA) {
		return A2(
			_elm_lang$core$Task$andThen,
			function (a) {
				return _elm_lang$core$Task$succeed(
					func(a));
			},
			taskA);
	});
var _elm_lang$core$Task$map2 = F3(
	function (func, taskA, taskB) {
		return A2(
			_elm_lang$core$Task$andThen,
			function (a) {
				return A2(
					_elm_lang$core$Task$andThen,
					function (b) {
						return _elm_lang$core$Task$succeed(
							A2(func, a, b));
					},
					taskB);
			},
			taskA);
	});
var _elm_lang$core$Task$map3 = F4(
	function (func, taskA, taskB, taskC) {
		return A2(
			_elm_lang$core$Task$andThen,
			function (a) {
				return A2(
					_elm_lang$core$Task$andThen,
					function (b) {
						return A2(
							_elm_lang$core$Task$andThen,
							function (c) {
								return _elm_lang$core$Task$succeed(
									A3(func, a, b, c));
							},
							taskC);
					},
					taskB);
			},
			taskA);
	});
var _elm_lang$core$Task$map4 = F5(
	function (func, taskA, taskB, taskC, taskD) {
		return A2(
			_elm_lang$core$Task$andThen,
			function (a) {
				return A2(
					_elm_lang$core$Task$andThen,
					function (b) {
						return A2(
							_elm_lang$core$Task$andThen,
							function (c) {
								return A2(
									_elm_lang$core$Task$andThen,
									function (d) {
										return _elm_lang$core$Task$succeed(
											A4(func, a, b, c, d));
									},
									taskD);
							},
							taskC);
					},
					taskB);
			},
			taskA);
	});
var _elm_lang$core$Task$map5 = F6(
	function (func, taskA, taskB, taskC, taskD, taskE) {
		return A2(
			_elm_lang$core$Task$andThen,
			function (a) {
				return A2(
					_elm_lang$core$Task$andThen,
					function (b) {
						return A2(
							_elm_lang$core$Task$andThen,
							function (c) {
								return A2(
									_elm_lang$core$Task$andThen,
									function (d) {
										return A2(
											_elm_lang$core$Task$andThen,
											function (e) {
												return _elm_lang$core$Task$succeed(
													A5(func, a, b, c, d, e));
											},
											taskE);
									},
									taskD);
							},
							taskC);
					},
					taskB);
			},
			taskA);
	});
var _elm_lang$core$Task$sequence = function (tasks) {
	var _p3 = tasks;
	if (_p3.ctor === '[]') {
		return _elm_lang$core$Task$succeed(
			{ctor: '[]'});
	} else {
		return A3(
			_elm_lang$core$Task$map2,
			F2(
				function (x, y) {
					return {ctor: '::', _0: x, _1: y};
				}),
			_p3._0,
			_elm_lang$core$Task$sequence(_p3._1));
	}
};
var _elm_lang$core$Task$onEffects = F3(
	function (router, commands, state) {
		return A2(
			_elm_lang$core$Task$map,
			function (_p4) {
				return {ctor: '_Tuple0'};
			},
			_elm_lang$core$Task$sequence(
				A2(
					_elm_lang$core$List$map,
					_elm_lang$core$Task$spawnCmd(router),
					commands)));
	});
var _elm_lang$core$Task$init = _elm_lang$core$Task$succeed(
	{ctor: '_Tuple0'});
var _elm_lang$core$Task$onSelfMsg = F3(
	function (_p7, _p6, _p5) {
		return _elm_lang$core$Task$succeed(
			{ctor: '_Tuple0'});
	});
var _elm_lang$core$Task$command = _elm_lang$core$Native_Platform.leaf('Task');
var _elm_lang$core$Task$Perform = function (a) {
	return {ctor: 'Perform', _0: a};
};
var _elm_lang$core$Task$perform = F2(
	function (toMessage, task) {
		return _elm_lang$core$Task$command(
			_elm_lang$core$Task$Perform(
				A2(_elm_lang$core$Task$map, toMessage, task)));
	});
var _elm_lang$core$Task$attempt = F2(
	function (resultToMessage, task) {
		return _elm_lang$core$Task$command(
			_elm_lang$core$Task$Perform(
				A2(
					_elm_lang$core$Task$onError,
					function (_p8) {
						return _elm_lang$core$Task$succeed(
							resultToMessage(
								_elm_lang$core$Result$Err(_p8)));
					},
					A2(
						_elm_lang$core$Task$andThen,
						function (_p9) {
							return _elm_lang$core$Task$succeed(
								resultToMessage(
									_elm_lang$core$Result$Ok(_p9)));
						},
						task))));
	});
var _elm_lang$core$Task$cmdMap = F2(
	function (tagger, _p10) {
		var _p11 = _p10;
		return _elm_lang$core$Task$Perform(
			A2(_elm_lang$core$Task$map, tagger, _p11._0));
	});
_elm_lang$core$Native_Platform.effectManagers['Task'] = {pkg: 'elm-lang/core', init: _elm_lang$core$Task$init, onEffects: _elm_lang$core$Task$onEffects, onSelfMsg: _elm_lang$core$Task$onSelfMsg, tag: 'cmd', cmdMap: _elm_lang$core$Task$cmdMap};

//import Native.Utils //

var _elm_lang$core$Native_Debug = function() {

function log(tag, value)
{
	var msg = tag + ': ' + _elm_lang$core$Native_Utils.toString(value);
	var process = process || {};
	if (process.stdout)
	{
		process.stdout.write(msg);
	}
	else
	{
		console.log(msg);
	}
	return value;
}

function crash(message)
{
	throw new Error(message);
}

return {
	crash: crash,
	log: F2(log)
};

}();
//import Maybe, Native.List, Native.Utils, Result //

var _elm_lang$core$Native_String = function() {

function isEmpty(str)
{
	return str.length === 0;
}
function cons(chr, str)
{
	return chr + str;
}
function uncons(str)
{
	var hd = str[0];
	if (hd)
	{
		return _elm_lang$core$Maybe$Just(_elm_lang$core$Native_Utils.Tuple2(_elm_lang$core$Native_Utils.chr(hd), str.slice(1)));
	}
	return _elm_lang$core$Maybe$Nothing;
}
function append(a, b)
{
	return a + b;
}
function concat(strs)
{
	return _elm_lang$core$Native_List.toArray(strs).join('');
}
function length(str)
{
	return str.length;
}
function map(f, str)
{
	var out = str.split('');
	for (var i = out.length; i--; )
	{
		out[i] = f(_elm_lang$core$Native_Utils.chr(out[i]));
	}
	return out.join('');
}
function filter(pred, str)
{
	return str.split('').map(_elm_lang$core$Native_Utils.chr).filter(pred).join('');
}
function reverse(str)
{
	return str.split('').reverse().join('');
}
function foldl(f, b, str)
{
	var len = str.length;
	for (var i = 0; i < len; ++i)
	{
		b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b);
	}
	return b;
}
function foldr(f, b, str)
{
	for (var i = str.length; i--; )
	{
		b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b);
	}
	return b;
}
function split(sep, str)
{
	return _elm_lang$core$Native_List.fromArray(str.split(sep));
}
function join(sep, strs)
{
	return _elm_lang$core$Native_List.toArray(strs).join(sep);
}
function repeat(n, str)
{
	var result = '';
	while (n > 0)
	{
		if (n & 1)
		{
			result += str;
		}
		n >>= 1, str += str;
	}
	return result;
}
function slice(start, end, str)
{
	return str.slice(start, end);
}
function left(n, str)
{
	return n < 1 ? '' : str.slice(0, n);
}
function right(n, str)
{
	return n < 1 ? '' : str.slice(-n);
}
function dropLeft(n, str)
{
	return n < 1 ? str : str.slice(n);
}
function dropRight(n, str)
{
	return n < 1 ? str : str.slice(0, -n);
}
function pad(n, chr, str)
{
	var half = (n - str.length) / 2;
	return repeat(Math.ceil(half), chr) + str + repeat(half | 0, chr);
}
function padRight(n, chr, str)
{
	return str + repeat(n - str.length, chr);
}
function padLeft(n, chr, str)
{
	return repeat(n - str.length, chr) + str;
}

function trim(str)
{
	return str.trim();
}
function trimLeft(str)
{
	return str.replace(/^\s+/, '');
}
function trimRight(str)
{
	return str.replace(/\s+$/, '');
}

function words(str)
{
	return _elm_lang$core$Native_List.fromArray(str.trim().split(/\s+/g));
}
function lines(str)
{
	return _elm_lang$core$Native_List.fromArray(str.split(/\r\n|\r|\n/g));
}

function toUpper(str)
{
	return str.toUpperCase();
}
function toLower(str)
{
	return str.toLowerCase();
}

function any(pred, str)
{
	for (var i = str.length; i--; )
	{
		if (pred(_elm_lang$core$Native_Utils.chr(str[i])))
		{
			return true;
		}
	}
	return false;
}
function all(pred, str)
{
	for (var i = str.length; i--; )
	{
		if (!pred(_elm_lang$core$Native_Utils.chr(str[i])))
		{
			return false;
		}
	}
	return true;
}

function contains(sub, str)
{
	return str.indexOf(sub) > -1;
}
function startsWith(sub, str)
{
	return str.indexOf(sub) === 0;
}
function endsWith(sub, str)
{
	return str.length >= sub.length &&
		str.lastIndexOf(sub) === str.length - sub.length;
}
function indexes(sub, str)
{
	var subLen = sub.length;

	if (subLen < 1)
	{
		return _elm_lang$core$Native_List.Nil;
	}

	var i = 0;
	var is = [];

	while ((i = str.indexOf(sub, i)) > -1)
	{
		is.push(i);
		i = i + subLen;
	}

	return _elm_lang$core$Native_List.fromArray(is);
}


function toInt(s)
{
	var len = s.length;

	// if empty
	if (len === 0)
	{
		return intErr(s);
	}

	// if hex
	var c = s[0];
	if (c === '0' && s[1] === 'x')
	{
		for (var i = 2; i < len; ++i)
		{
			var c = s[i];
			if (('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f'))
			{
				continue;
			}
			return intErr(s);
		}
		return _elm_lang$core$Result$Ok(parseInt(s, 16));
	}

	// is decimal
	if (c > '9' || (c < '0' && c !== '-' && c !== '+'))
	{
		return intErr(s);
	}
	for (var i = 1; i < len; ++i)
	{
		var c = s[i];
		if (c < '0' || '9' < c)
		{
			return intErr(s);
		}
	}

	return _elm_lang$core$Result$Ok(parseInt(s, 10));
}

function intErr(s)
{
	return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int");
}


function toFloat(s)
{
	// check if it is a hex, octal, or binary number
	if (s.length === 0 || /[\sxbo]/.test(s))
	{
		return floatErr(s);
	}
	var n = +s;
	// faster isNaN check
	return n === n ? _elm_lang$core$Result$Ok(n) : floatErr(s);
}

function floatErr(s)
{
	return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float");
}


function toList(str)
{
	return _elm_lang$core$Native_List.fromArray(str.split('').map(_elm_lang$core$Native_Utils.chr));
}
function fromList(chars)
{
	return _elm_lang$core$Native_List.toArray(chars).join('');
}

return {
	isEmpty: isEmpty,
	cons: F2(cons),
	uncons: uncons,
	append: F2(append),
	concat: concat,
	length: length,
	map: F2(map),
	filter: F2(filter),
	reverse: reverse,
	foldl: F3(foldl),
	foldr: F3(foldr),

	split: F2(split),
	join: F2(join),
	repeat: F2(repeat),

	slice: F3(slice),
	left: F2(left),
	right: F2(right),
	dropLeft: F2(dropLeft),
	dropRight: F2(dropRight),

	pad: F3(pad),
	padLeft: F3(padLeft),
	padRight: F3(padRight),

	trim: trim,
	trimLeft: trimLeft,
	trimRight: trimRight,

	words: words,
	lines: lines,

	toUpper: toUpper,
	toLower: toLower,

	any: F2(any),
	all: F2(all),

	contains: F2(contains),
	startsWith: F2(startsWith),
	endsWith: F2(endsWith),
	indexes: F2(indexes),

	toInt: toInt,
	toFloat: toFloat,
	toList: toList,
	fromList: fromList
};

}();

var _elm_lang$core$String$fromList = _elm_lang$core$Native_String.fromList;
var _elm_lang$core$String$toList = _elm_lang$core$Native_String.toList;
var _elm_lang$core$String$toFloat = _elm_lang$core$Native_String.toFloat;
var _elm_lang$core$String$toInt = _elm_lang$core$Native_String.toInt;
var _elm_lang$core$String$indices = _elm_lang$core$Native_String.indexes;
var _elm_lang$core$String$indexes = _elm_lang$core$Native_String.indexes;
var _elm_lang$core$String$endsWith = _elm_lang$core$Native_String.endsWith;
var _elm_lang$core$String$startsWith = _elm_lang$core$Native_String.startsWith;
var _elm_lang$core$String$contains = _elm_lang$core$Native_String.contains;
var _elm_lang$core$String$all = _elm_lang$core$Native_String.all;
var _elm_lang$core$String$any = _elm_lang$core$Native_String.any;
var _elm_lang$core$String$toLower = _elm_lang$core$Native_String.toLower;
var _elm_lang$core$String$toUpper = _elm_lang$core$Native_String.toUpper;
var _elm_lang$core$String$lines = _elm_lang$core$Native_String.lines;
var _elm_lang$core$String$words = _elm_lang$core$Native_String.words;
var _elm_lang$core$String$trimRight = _elm_lang$core$Native_String.trimRight;
var _elm_lang$core$String$trimLeft = _elm_lang$core$Native_String.trimLeft;
var _elm_lang$core$String$trim = _elm_lang$core$Native_String.trim;
var _elm_lang$core$String$padRight = _elm_lang$core$Native_String.padRight;
var _elm_lang$core$String$padLeft = _elm_lang$core$Native_String.padLeft;
var _elm_lang$core$String$pad = _elm_lang$core$Native_String.pad;
var _elm_lang$core$String$dropRight = _elm_lang$core$Native_String.dropRight;
var _elm_lang$core$String$dropLeft = _elm_lang$core$Native_String.dropLeft;
var _elm_lang$core$String$right = _elm_lang$core$Native_String.right;
var _elm_lang$core$String$left = _elm_lang$core$Native_String.left;
var _elm_lang$core$String$slice = _elm_lang$core$Native_String.slice;
var _elm_lang$core$String$repeat = _elm_lang$core$Native_String.repeat;
var _elm_lang$core$String$join = _elm_lang$core$Native_String.join;
var _elm_lang$core$String$split = _elm_lang$core$Native_String.split;
var _elm_lang$core$String$foldr = _elm_lang$core$Native_String.foldr;
var _elm_lang$core$String$foldl = _elm_lang$core$Native_String.foldl;
var _elm_lang$core$String$reverse = _elm_lang$core$Native_String.reverse;
var _elm_lang$core$String$filter = _elm_lang$core$Native_String.filter;
var _elm_lang$core$String$map = _elm_lang$core$Native_String.map;
var _elm_lang$core$String$length = _elm_lang$core$Native_String.length;
var _elm_lang$core$String$concat = _elm_lang$core$Native_String.concat;
var _elm_lang$core$String$append = _elm_lang$core$Native_String.append;
var _elm_lang$core$String$uncons = _elm_lang$core$Native_String.uncons;
var _elm_lang$core$String$cons = _elm_lang$core$Native_String.cons;
var _elm_lang$core$String$fromChar = function ($char) {
	return A2(_elm_lang$core$String$cons, $char, '');
};
var _elm_lang$core$String$isEmpty = _elm_lang$core$Native_String.isEmpty;

var _elm_lang$core$Dict$foldr = F3(
	function (f, acc, t) {
		foldr:
		while (true) {
			var _p0 = t;
			if (_p0.ctor === 'RBEmpty_elm_builtin') {
				return acc;
			} else {
				var _v1 = f,
					_v2 = A3(
					f,
					_p0._1,
					_p0._2,
					A3(_elm_lang$core$Dict$foldr, f, acc, _p0._4)),
					_v3 = _p0._3;
				f = _v1;
				acc = _v2;
				t = _v3;
				continue foldr;
			}
		}
	});
var _elm_lang$core$Dict$keys = function (dict) {
	return A3(
		_elm_lang$core$Dict$foldr,
		F3(
			function (key, value, keyList) {
				return {ctor: '::', _0: key, _1: keyList};
			}),
		{ctor: '[]'},
		dict);
};
var _elm_lang$core$Dict$values = function (dict) {
	return A3(
		_elm_lang$core$Dict$foldr,
		F3(
			function (key, value, valueList) {
				return {ctor: '::', _0: value, _1: valueList};
			}),
		{ctor: '[]'},
		dict);
};
var _elm_lang$core$Dict$toList = function (dict) {
	return A3(
		_elm_lang$core$Dict$foldr,
		F3(
			function (key, value, list) {
				return {
					ctor: '::',
					_0: {ctor: '_Tuple2', _0: key, _1: value},
					_1: list
				};
			}),
		{ctor: '[]'},
		dict);
};
var _elm_lang$core$Dict$foldl = F3(
	function (f, acc, dict) {
		foldl:
		while (true) {
			var _p1 = dict;
			if (_p1.ctor === 'RBEmpty_elm_builtin') {
				return acc;
			} else {
				var _v5 = f,
					_v6 = A3(
					f,
					_p1._1,
					_p1._2,
					A3(_elm_lang$core$Dict$foldl, f, acc, _p1._3)),
					_v7 = _p1._4;
				f = _v5;
				acc = _v6;
				dict = _v7;
				continue foldl;
			}
		}
	});
var _elm_lang$core$Dict$merge = F6(
	function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) {
		var stepState = F3(
			function (rKey, rValue, _p2) {
				stepState:
				while (true) {
					var _p3 = _p2;
					var _p9 = _p3._1;
					var _p8 = _p3._0;
					var _p4 = _p8;
					if (_p4.ctor === '[]') {
						return {
							ctor: '_Tuple2',
							_0: _p8,
							_1: A3(rightStep, rKey, rValue, _p9)
						};
					} else {
						var _p7 = _p4._1;
						var _p6 = _p4._0._1;
						var _p5 = _p4._0._0;
						if (_elm_lang$core$Native_Utils.cmp(_p5, rKey) < 0) {
							var _v10 = rKey,
								_v11 = rValue,
								_v12 = {
								ctor: '_Tuple2',
								_0: _p7,
								_1: A3(leftStep, _p5, _p6, _p9)
							};
							rKey = _v10;
							rValue = _v11;
							_p2 = _v12;
							continue stepState;
						} else {
							if (_elm_lang$core$Native_Utils.cmp(_p5, rKey) > 0) {
								return {
									ctor: '_Tuple2',
									_0: _p8,
									_1: A3(rightStep, rKey, rValue, _p9)
								};
							} else {
								return {
									ctor: '_Tuple2',
									_0: _p7,
									_1: A4(bothStep, _p5, _p6, rValue, _p9)
								};
							}
						}
					}
				}
			});
		var _p10 = A3(
			_elm_lang$core$Dict$foldl,
			stepState,
			{
				ctor: '_Tuple2',
				_0: _elm_lang$core$Dict$toList(leftDict),
				_1: initialResult
			},
			rightDict);
		var leftovers = _p10._0;
		var intermediateResult = _p10._1;
		return A3(
			_elm_lang$core$List$foldl,
			F2(
				function (_p11, result) {
					var _p12 = _p11;
					return A3(leftStep, _p12._0, _p12._1, result);
				}),
			intermediateResult,
			leftovers);
	});
var _elm_lang$core$Dict$reportRemBug = F4(
	function (msg, c, lgot, rgot) {
		return _elm_lang$core$Native_Debug.crash(
			_elm_lang$core$String$concat(
				{
					ctor: '::',
					_0: 'Internal red-black tree invariant violated, expected ',
					_1: {
						ctor: '::',
						_0: msg,
						_1: {
							ctor: '::',
							_0: ' and got ',
							_1: {
								ctor: '::',
								_0: _elm_lang$core$Basics$toString(c),
								_1: {
									ctor: '::',
									_0: '/',
									_1: {
										ctor: '::',
										_0: lgot,
										_1: {
											ctor: '::',
											_0: '/',
											_1: {
												ctor: '::',
												_0: rgot,
												_1: {
													ctor: '::',
													_0: '\nPlease report this bug to <https://github.com/elm-lang/core/issues>',
													_1: {ctor: '[]'}
												}
											}
										}
									}
								}
							}
						}
					}
				}));
	});
var _elm_lang$core$Dict$isBBlack = function (dict) {
	var _p13 = dict;
	_v14_2:
	do {
		if (_p13.ctor === 'RBNode_elm_builtin') {
			if (_p13._0.ctor === 'BBlack') {
				return true;
			} else {
				break _v14_2;
			}
		} else {
			if (_p13._0.ctor === 'LBBlack') {
				return true;
			} else {
				break _v14_2;
			}
		}
	} while(false);
	return false;
};
var _elm_lang$core$Dict$sizeHelp = F2(
	function (n, dict) {
		sizeHelp:
		while (true) {
			var _p14 = dict;
			if (_p14.ctor === 'RBEmpty_elm_builtin') {
				return n;
			} else {
				var _v16 = A2(_elm_lang$core$Dict$sizeHelp, n + 1, _p14._4),
					_v17 = _p14._3;
				n = _v16;
				dict = _v17;
				continue sizeHelp;
			}
		}
	});
var _elm_lang$core$Dict$size = function (dict) {
	return A2(_elm_lang$core$Dict$sizeHelp, 0, dict);
};
var _elm_lang$core$Dict$get = F2(
	function (targetKey, dict) {
		get:
		while (true) {
			var _p15 = dict;
			if (_p15.ctor === 'RBEmpty_elm_builtin') {
				return _elm_lang$core$Maybe$Nothing;
			} else {
				var _p16 = A2(_elm_lang$core$Basics$compare, targetKey, _p15._1);
				switch (_p16.ctor) {
					case 'LT':
						var _v20 = targetKey,
							_v21 = _p15._3;
						targetKey = _v20;
						dict = _v21;
						continue get;
					case 'EQ':
						return _elm_lang$core$Maybe$Just(_p15._2);
					default:
						var _v22 = targetKey,
							_v23 = _p15._4;
						targetKey = _v22;
						dict = _v23;
						continue get;
				}
			}
		}
	});
var _elm_lang$core$Dict$member = F2(
	function (key, dict) {
		var _p17 = A2(_elm_lang$core$Dict$get, key, dict);
		if (_p17.ctor === 'Just') {
			return true;
		} else {
			return false;
		}
	});
var _elm_lang$core$Dict$maxWithDefault = F3(
	function (k, v, r) {
		maxWithDefault:
		while (true) {
			var _p18 = r;
			if (_p18.ctor === 'RBEmpty_elm_builtin') {
				return {ctor: '_Tuple2', _0: k, _1: v};
			} else {
				var _v26 = _p18._1,
					_v27 = _p18._2,
					_v28 = _p18._4;
				k = _v26;
				v = _v27;
				r = _v28;
				continue maxWithDefault;
			}
		}
	});
var _elm_lang$core$Dict$NBlack = {ctor: 'NBlack'};
var _elm_lang$core$Dict$BBlack = {ctor: 'BBlack'};
var _elm_lang$core$Dict$Black = {ctor: 'Black'};
var _elm_lang$core$Dict$blackish = function (t) {
	var _p19 = t;
	if (_p19.ctor === 'RBNode_elm_builtin') {
		var _p20 = _p19._0;
		return _elm_lang$core$Native_Utils.eq(_p20, _elm_lang$core$Dict$Black) || _elm_lang$core$Native_Utils.eq(_p20, _elm_lang$core$Dict$BBlack);
	} else {
		return true;
	}
};
var _elm_lang$core$Dict$Red = {ctor: 'Red'};
var _elm_lang$core$Dict$moreBlack = function (color) {
	var _p21 = color;
	switch (_p21.ctor) {
		case 'Black':
			return _elm_lang$core$Dict$BBlack;
		case 'Red':
			return _elm_lang$core$Dict$Black;
		case 'NBlack':
			return _elm_lang$core$Dict$Red;
		default:
			return _elm_lang$core$Native_Debug.crash('Can\'t make a double black node more black!');
	}
};
var _elm_lang$core$Dict$lessBlack = function (color) {
	var _p22 = color;
	switch (_p22.ctor) {
		case 'BBlack':
			return _elm_lang$core$Dict$Black;
		case 'Black':
			return _elm_lang$core$Dict$Red;
		case 'Red':
			return _elm_lang$core$Dict$NBlack;
		default:
			return _elm_lang$core$Native_Debug.crash('Can\'t make a negative black node less black!');
	}
};
var _elm_lang$core$Dict$LBBlack = {ctor: 'LBBlack'};
var _elm_lang$core$Dict$LBlack = {ctor: 'LBlack'};
var _elm_lang$core$Dict$RBEmpty_elm_builtin = function (a) {
	return {ctor: 'RBEmpty_elm_builtin', _0: a};
};
var _elm_lang$core$Dict$empty = _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack);
var _elm_lang$core$Dict$isEmpty = function (dict) {
	return _elm_lang$core$Native_Utils.eq(dict, _elm_lang$core$Dict$empty);
};
var _elm_lang$core$Dict$RBNode_elm_builtin = F5(
	function (a, b, c, d, e) {
		return {ctor: 'RBNode_elm_builtin', _0: a, _1: b, _2: c, _3: d, _4: e};
	});
var _elm_lang$core$Dict$ensureBlackRoot = function (dict) {
	var _p23 = dict;
	if ((_p23.ctor === 'RBNode_elm_builtin') && (_p23._0.ctor === 'Red')) {
		return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p23._1, _p23._2, _p23._3, _p23._4);
	} else {
		return dict;
	}
};
var _elm_lang$core$Dict$lessBlackTree = function (dict) {
	var _p24 = dict;
	if (_p24.ctor === 'RBNode_elm_builtin') {
		return A5(
			_elm_lang$core$Dict$RBNode_elm_builtin,
			_elm_lang$core$Dict$lessBlack(_p24._0),
			_p24._1,
			_p24._2,
			_p24._3,
			_p24._4);
	} else {
		return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack);
	}
};
var _elm_lang$core$Dict$balancedTree = function (col) {
	return function (xk) {
		return function (xv) {
			return function (yk) {
				return function (yv) {
					return function (zk) {
						return function (zv) {
							return function (a) {
								return function (b) {
									return function (c) {
										return function (d) {
											return A5(
												_elm_lang$core$Dict$RBNode_elm_builtin,
												_elm_lang$core$Dict$lessBlack(col),
												yk,
												yv,
												A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, xk, xv, a, b),
												A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, zk, zv, c, d));
										};
									};
								};
							};
						};
					};
				};
			};
		};
	};
};
var _elm_lang$core$Dict$blacken = function (t) {
	var _p25 = t;
	if (_p25.ctor === 'RBEmpty_elm_builtin') {
		return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack);
	} else {
		return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p25._1, _p25._2, _p25._3, _p25._4);
	}
};
var _elm_lang$core$Dict$redden = function (t) {
	var _p26 = t;
	if (_p26.ctor === 'RBEmpty_elm_builtin') {
		return _elm_lang$core$Native_Debug.crash('can\'t make a Leaf red');
	} else {
		return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, _p26._1, _p26._2, _p26._3, _p26._4);
	}
};
var _elm_lang$core$Dict$balanceHelp = function (tree) {
	var _p27 = tree;
	_v36_6:
	do {
		_v36_5:
		do {
			_v36_4:
			do {
				_v36_3:
				do {
					_v36_2:
					do {
						_v36_1:
						do {
							_v36_0:
							do {
								if (_p27.ctor === 'RBNode_elm_builtin') {
									if (_p27._3.ctor === 'RBNode_elm_builtin') {
										if (_p27._4.ctor === 'RBNode_elm_builtin') {
											switch (_p27._3._0.ctor) {
												case 'Red':
													switch (_p27._4._0.ctor) {
														case 'Red':
															if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) {
																break _v36_0;
															} else {
																if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) {
																	break _v36_1;
																} else {
																	if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) {
																		break _v36_2;
																	} else {
																		if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) {
																			break _v36_3;
																		} else {
																			break _v36_6;
																		}
																	}
																}
															}
														case 'NBlack':
															if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) {
																break _v36_0;
															} else {
																if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) {
																	break _v36_1;
																} else {
																	if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) {
																		break _v36_4;
																	} else {
																		break _v36_6;
																	}
																}
															}
														default:
															if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) {
																break _v36_0;
															} else {
																if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) {
																	break _v36_1;
																} else {
																	break _v36_6;
																}
															}
													}
												case 'NBlack':
													switch (_p27._4._0.ctor) {
														case 'Red':
															if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) {
																break _v36_2;
															} else {
																if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) {
																	break _v36_3;
																} else {
																	if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) {
																		break _v36_5;
																	} else {
																		break _v36_6;
																	}
																}
															}
														case 'NBlack':
															if (_p27._0.ctor === 'BBlack') {
																if ((((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) {
																	break _v36_4;
																} else {
																	if ((((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) {
																		break _v36_5;
																	} else {
																		break _v36_6;
																	}
																}
															} else {
																break _v36_6;
															}
														default:
															if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) {
																break _v36_5;
															} else {
																break _v36_6;
															}
													}
												default:
													switch (_p27._4._0.ctor) {
														case 'Red':
															if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) {
																break _v36_2;
															} else {
																if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) {
																	break _v36_3;
																} else {
																	break _v36_6;
																}
															}
														case 'NBlack':
															if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) {
																break _v36_4;
															} else {
																break _v36_6;
															}
														default:
															break _v36_6;
													}
											}
										} else {
											switch (_p27._3._0.ctor) {
												case 'Red':
													if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) {
														break _v36_0;
													} else {
														if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) {
															break _v36_1;
														} else {
															break _v36_6;
														}
													}
												case 'NBlack':
													if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) {
														break _v36_5;
													} else {
														break _v36_6;
													}
												default:
													break _v36_6;
											}
										}
									} else {
										if (_p27._4.ctor === 'RBNode_elm_builtin') {
											switch (_p27._4._0.ctor) {
												case 'Red':
													if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) {
														break _v36_2;
													} else {
														if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) {
															break _v36_3;
														} else {
															break _v36_6;
														}
													}
												case 'NBlack':
													if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) {
														break _v36_4;
													} else {
														break _v36_6;
													}
												default:
													break _v36_6;
											}
										} else {
											break _v36_6;
										}
									}
								} else {
									break _v36_6;
								}
							} while(false);
							return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._3._1)(_p27._3._3._2)(_p27._3._1)(_p27._3._2)(_p27._1)(_p27._2)(_p27._3._3._3)(_p27._3._3._4)(_p27._3._4)(_p27._4);
						} while(false);
						return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._1)(_p27._3._2)(_p27._3._4._1)(_p27._3._4._2)(_p27._1)(_p27._2)(_p27._3._3)(_p27._3._4._3)(_p27._3._4._4)(_p27._4);
					} while(false);
					return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._3._1)(_p27._4._3._2)(_p27._4._1)(_p27._4._2)(_p27._3)(_p27._4._3._3)(_p27._4._3._4)(_p27._4._4);
				} while(false);
				return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._1)(_p27._4._2)(_p27._4._4._1)(_p27._4._4._2)(_p27._3)(_p27._4._3)(_p27._4._4._3)(_p27._4._4._4);
			} while(false);
			return A5(
				_elm_lang$core$Dict$RBNode_elm_builtin,
				_elm_lang$core$Dict$Black,
				_p27._4._3._1,
				_p27._4._3._2,
				A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3, _p27._4._3._3),
				A5(
					_elm_lang$core$Dict$balance,
					_elm_lang$core$Dict$Black,
					_p27._4._1,
					_p27._4._2,
					_p27._4._3._4,
					_elm_lang$core$Dict$redden(_p27._4._4)));
		} while(false);
		return A5(
			_elm_lang$core$Dict$RBNode_elm_builtin,
			_elm_lang$core$Dict$Black,
			_p27._3._4._1,
			_p27._3._4._2,
			A5(
				_elm_lang$core$Dict$balance,
				_elm_lang$core$Dict$Black,
				_p27._3._1,
				_p27._3._2,
				_elm_lang$core$Dict$redden(_p27._3._3),
				_p27._3._4._3),
			A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3._4._4, _p27._4));
	} while(false);
	return tree;
};
var _elm_lang$core$Dict$balance = F5(
	function (c, k, v, l, r) {
		var tree = A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r);
		return _elm_lang$core$Dict$blackish(tree) ? _elm_lang$core$Dict$balanceHelp(tree) : tree;
	});
var _elm_lang$core$Dict$bubble = F5(
	function (c, k, v, l, r) {
		return (_elm_lang$core$Dict$isBBlack(l) || _elm_lang$core$Dict$isBBlack(r)) ? A5(
			_elm_lang$core$Dict$balance,
			_elm_lang$core$Dict$moreBlack(c),
			k,
			v,
			_elm_lang$core$Dict$lessBlackTree(l),
			_elm_lang$core$Dict$lessBlackTree(r)) : A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r);
	});
var _elm_lang$core$Dict$removeMax = F5(
	function (c, k, v, l, r) {
		var _p28 = r;
		if (_p28.ctor === 'RBEmpty_elm_builtin') {
			return A3(_elm_lang$core$Dict$rem, c, l, r);
		} else {
			return A5(
				_elm_lang$core$Dict$bubble,
				c,
				k,
				v,
				l,
				A5(_elm_lang$core$Dict$removeMax, _p28._0, _p28._1, _p28._2, _p28._3, _p28._4));
		}
	});
var _elm_lang$core$Dict$rem = F3(
	function (color, left, right) {
		var _p29 = {ctor: '_Tuple2', _0: left, _1: right};
		if (_p29._0.ctor === 'RBEmpty_elm_builtin') {
			if (_p29._1.ctor === 'RBEmpty_elm_builtin') {
				var _p30 = color;
				switch (_p30.ctor) {
					case 'Red':
						return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack);
					case 'Black':
						return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBBlack);
					default:
						return _elm_lang$core$Native_Debug.crash('cannot have bblack or nblack nodes at this point');
				}
			} else {
				var _p33 = _p29._1._0;
				var _p32 = _p29._0._0;
				var _p31 = {ctor: '_Tuple3', _0: color, _1: _p32, _2: _p33};
				if ((((_p31.ctor === '_Tuple3') && (_p31._0.ctor === 'Black')) && (_p31._1.ctor === 'LBlack')) && (_p31._2.ctor === 'Red')) {
					return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._1._1, _p29._1._2, _p29._1._3, _p29._1._4);
				} else {
					return A4(
						_elm_lang$core$Dict$reportRemBug,
						'Black/LBlack/Red',
						color,
						_elm_lang$core$Basics$toString(_p32),
						_elm_lang$core$Basics$toString(_p33));
				}
			}
		} else {
			if (_p29._1.ctor === 'RBEmpty_elm_builtin') {
				var _p36 = _p29._1._0;
				var _p35 = _p29._0._0;
				var _p34 = {ctor: '_Tuple3', _0: color, _1: _p35, _2: _p36};
				if ((((_p34.ctor === '_Tuple3') && (_p34._0.ctor === 'Black')) && (_p34._1.ctor === 'Red')) && (_p34._2.ctor === 'LBlack')) {
					return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._0._1, _p29._0._2, _p29._0._3, _p29._0._4);
				} else {
					return A4(
						_elm_lang$core$Dict$reportRemBug,
						'Black/Red/LBlack',
						color,
						_elm_lang$core$Basics$toString(_p35),
						_elm_lang$core$Basics$toString(_p36));
				}
			} else {
				var _p40 = _p29._0._2;
				var _p39 = _p29._0._4;
				var _p38 = _p29._0._1;
				var newLeft = A5(_elm_lang$core$Dict$removeMax, _p29._0._0, _p38, _p40, _p29._0._3, _p39);
				var _p37 = A3(_elm_lang$core$Dict$maxWithDefault, _p38, _p40, _p39);
				var k = _p37._0;
				var v = _p37._1;
				return A5(_elm_lang$core$Dict$bubble, color, k, v, newLeft, right);
			}
		}
	});
var _elm_lang$core$Dict$map = F2(
	function (f, dict) {
		var _p41 = dict;
		if (_p41.ctor === 'RBEmpty_elm_builtin') {
			return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack);
		} else {
			var _p42 = _p41._1;
			return A5(
				_elm_lang$core$Dict$RBNode_elm_builtin,
				_p41._0,
				_p42,
				A2(f, _p42, _p41._2),
				A2(_elm_lang$core$Dict$map, f, _p41._3),
				A2(_elm_lang$core$Dict$map, f, _p41._4));
		}
	});
var _elm_lang$core$Dict$Same = {ctor: 'Same'};
var _elm_lang$core$Dict$Remove = {ctor: 'Remove'};
var _elm_lang$core$Dict$Insert = {ctor: 'Insert'};
var _elm_lang$core$Dict$update = F3(
	function (k, alter, dict) {
		var up = function (dict) {
			var _p43 = dict;
			if (_p43.ctor === 'RBEmpty_elm_builtin') {
				var _p44 = alter(_elm_lang$core$Maybe$Nothing);
				if (_p44.ctor === 'Nothing') {
					return {ctor: '_Tuple2', _0: _elm_lang$core$Dict$Same, _1: _elm_lang$core$Dict$empty};
				} else {
					return {
						ctor: '_Tuple2',
						_0: _elm_lang$core$Dict$Insert,
						_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, k, _p44._0, _elm_lang$core$Dict$empty, _elm_lang$core$Dict$empty)
					};
				}
			} else {
				var _p55 = _p43._2;
				var _p54 = _p43._4;
				var _p53 = _p43._3;
				var _p52 = _p43._1;
				var _p51 = _p43._0;
				var _p45 = A2(_elm_lang$core$Basics$compare, k, _p52);
				switch (_p45.ctor) {
					case 'EQ':
						var _p46 = alter(
							_elm_lang$core$Maybe$Just(_p55));
						if (_p46.ctor === 'Nothing') {
							return {
								ctor: '_Tuple2',
								_0: _elm_lang$core$Dict$Remove,
								_1: A3(_elm_lang$core$Dict$rem, _p51, _p53, _p54)
							};
						} else {
							return {
								ctor: '_Tuple2',
								_0: _elm_lang$core$Dict$Same,
								_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p46._0, _p53, _p54)
							};
						}
					case 'LT':
						var _p47 = up(_p53);
						var flag = _p47._0;
						var newLeft = _p47._1;
						var _p48 = flag;
						switch (_p48.ctor) {
							case 'Same':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Same,
									_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, newLeft, _p54)
								};
							case 'Insert':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Insert,
									_1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, newLeft, _p54)
								};
							default:
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Remove,
									_1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, newLeft, _p54)
								};
						}
					default:
						var _p49 = up(_p54);
						var flag = _p49._0;
						var newRight = _p49._1;
						var _p50 = flag;
						switch (_p50.ctor) {
							case 'Same':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Same,
									_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, _p53, newRight)
								};
							case 'Insert':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Insert,
									_1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, _p53, newRight)
								};
							default:
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Remove,
									_1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, _p53, newRight)
								};
						}
				}
			}
		};
		var _p56 = up(dict);
		var flag = _p56._0;
		var updatedDict = _p56._1;
		var _p57 = flag;
		switch (_p57.ctor) {
			case 'Same':
				return updatedDict;
			case 'Insert':
				return _elm_lang$core$Dict$ensureBlackRoot(updatedDict);
			default:
				return _elm_lang$core$Dict$blacken(updatedDict);
		}
	});
var _elm_lang$core$Dict$insert = F3(
	function (key, value, dict) {
		return A3(
			_elm_lang$core$Dict$update,
			key,
			_elm_lang$core$Basics$always(
				_elm_lang$core$Maybe$Just(value)),
			dict);
	});
var _elm_lang$core$Dict$singleton = F2(
	function (key, value) {
		return A3(_elm_lang$core$Dict$insert, key, value, _elm_lang$core$Dict$empty);
	});
var _elm_lang$core$Dict$union = F2(
	function (t1, t2) {
		return A3(_elm_lang$core$Dict$foldl, _elm_lang$core$Dict$insert, t2, t1);
	});
var _elm_lang$core$Dict$filter = F2(
	function (predicate, dictionary) {
		var add = F3(
			function (key, value, dict) {
				return A2(predicate, key, value) ? A3(_elm_lang$core$Dict$insert, key, value, dict) : dict;
			});
		return A3(_elm_lang$core$Dict$foldl, add, _elm_lang$core$Dict$empty, dictionary);
	});
var _elm_lang$core$Dict$intersect = F2(
	function (t1, t2) {
		return A2(
			_elm_lang$core$Dict$filter,
			F2(
				function (k, _p58) {
					return A2(_elm_lang$core$Dict$member, k, t2);
				}),
			t1);
	});
var _elm_lang$core$Dict$partition = F2(
	function (predicate, dict) {
		var add = F3(
			function (key, value, _p59) {
				var _p60 = _p59;
				var _p62 = _p60._1;
				var _p61 = _p60._0;
				return A2(predicate, key, value) ? {
					ctor: '_Tuple2',
					_0: A3(_elm_lang$core$Dict$insert, key, value, _p61),
					_1: _p62
				} : {
					ctor: '_Tuple2',
					_0: _p61,
					_1: A3(_elm_lang$core$Dict$insert, key, value, _p62)
				};
			});
		return A3(
			_elm_lang$core$Dict$foldl,
			add,
			{ctor: '_Tuple2', _0: _elm_lang$core$Dict$empty, _1: _elm_lang$core$Dict$empty},
			dict);
	});
var _elm_lang$core$Dict$fromList = function (assocs) {
	return A3(
		_elm_lang$core$List$foldl,
		F2(
			function (_p63, dict) {
				var _p64 = _p63;
				return A3(_elm_lang$core$Dict$insert, _p64._0, _p64._1, dict);
			}),
		_elm_lang$core$Dict$empty,
		assocs);
};
var _elm_lang$core$Dict$remove = F2(
	function (key, dict) {
		return A3(
			_elm_lang$core$Dict$update,
			key,
			_elm_lang$core$Basics$always(_elm_lang$core$Maybe$Nothing),
			dict);
	});
var _elm_lang$core$Dict$diff = F2(
	function (t1, t2) {
		return A3(
			_elm_lang$core$Dict$foldl,
			F3(
				function (k, v, t) {
					return A2(_elm_lang$core$Dict$remove, k, t);
				}),
			t1,
			t2);
	});

var _elm_lang$core$Debug$crash = _elm_lang$core$Native_Debug.crash;
var _elm_lang$core$Debug$log = _elm_lang$core$Native_Debug.log;

//import Maybe, Native.Array, Native.List, Native.Utils, Result //

var _elm_lang$core$Native_Json = function() {


// CORE DECODERS

function succeed(msg)
{
	return {
		ctor: '<decoder>',
		tag: 'succeed',
		msg: msg
	};
}

function fail(msg)
{
	return {
		ctor: '<decoder>',
		tag: 'fail',
		msg: msg
	};
}

function decodePrimitive(tag)
{
	return {
		ctor: '<decoder>',
		tag: tag
	};
}

function decodeContainer(tag, decoder)
{
	return {
		ctor: '<decoder>',
		tag: tag,
		decoder: decoder
	};
}

function decodeNull(value)
{
	return {
		ctor: '<decoder>',
		tag: 'null',
		value: value
	};
}

function decodeField(field, decoder)
{
	return {
		ctor: '<decoder>',
		tag: 'field',
		field: field,
		decoder: decoder
	};
}

function decodeIndex(index, decoder)
{
	return {
		ctor: '<decoder>',
		tag: 'index',
		index: index,
		decoder: decoder
	};
}

function decodeKeyValuePairs(decoder)
{
	return {
		ctor: '<decoder>',
		tag: 'key-value',
		decoder: decoder
	};
}

function mapMany(f, decoders)
{
	return {
		ctor: '<decoder>',
		tag: 'map-many',
		func: f,
		decoders: decoders
	};
}

function andThen(callback, decoder)
{
	return {
		ctor: '<decoder>',
		tag: 'andThen',
		decoder: decoder,
		callback: callback
	};
}

function oneOf(decoders)
{
	return {
		ctor: '<decoder>',
		tag: 'oneOf',
		decoders: decoders
	};
}


// DECODING OBJECTS

function map1(f, d1)
{
	return mapMany(f, [d1]);
}

function map2(f, d1, d2)
{
	return mapMany(f, [d1, d2]);
}

function map3(f, d1, d2, d3)
{
	return mapMany(f, [d1, d2, d3]);
}

function map4(f, d1, d2, d3, d4)
{
	return mapMany(f, [d1, d2, d3, d4]);
}

function map5(f, d1, d2, d3, d4, d5)
{
	return mapMany(f, [d1, d2, d3, d4, d5]);
}

function map6(f, d1, d2, d3, d4, d5, d6)
{
	return mapMany(f, [d1, d2, d3, d4, d5, d6]);
}

function map7(f, d1, d2, d3, d4, d5, d6, d7)
{
	return mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
}

function map8(f, d1, d2, d3, d4, d5, d6, d7, d8)
{
	return mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
}


// DECODE HELPERS

function ok(value)
{
	return { tag: 'ok', value: value };
}

function badPrimitive(type, value)
{
	return { tag: 'primitive', type: type, value: value };
}

function badIndex(index, nestedProblems)
{
	return { tag: 'index', index: index, rest: nestedProblems };
}

function badField(field, nestedProblems)
{
	return { tag: 'field', field: field, rest: nestedProblems };
}

function badIndex(index, nestedProblems)
{
	return { tag: 'index', index: index, rest: nestedProblems };
}

function badOneOf(problems)
{
	return { tag: 'oneOf', problems: problems };
}

function bad(msg)
{
	return { tag: 'fail', msg: msg };
}

function badToString(problem)
{
	var context = '_';
	while (problem)
	{
		switch (problem.tag)
		{
			case 'primitive':
				return 'Expecting ' + problem.type
					+ (context === '_' ? '' : ' at ' + context)
					+ ' but instead got: ' + jsToString(problem.value);

			case 'index':
				context += '[' + problem.index + ']';
				problem = problem.rest;
				break;

			case 'field':
				context += '.' + problem.field;
				problem = problem.rest;
				break;

			case 'oneOf':
				var problems = problem.problems;
				for (var i = 0; i < problems.length; i++)
				{
					problems[i] = badToString(problems[i]);
				}
				return 'I ran into the following problems'
					+ (context === '_' ? '' : ' at ' + context)
					+ ':\n\n' + problems.join('\n');

			case 'fail':
				return 'I ran into a `fail` decoder'
					+ (context === '_' ? '' : ' at ' + context)
					+ ': ' + problem.msg;
		}
	}
}

function jsToString(value)
{
	return value === undefined
		? 'undefined'
		: JSON.stringify(value);
}


// DECODE

function runOnString(decoder, string)
{
	var json;
	try
	{
		json = JSON.parse(string);
	}
	catch (e)
	{
		return _elm_lang$core$Result$Err('Given an invalid JSON: ' + e.message);
	}
	return run(decoder, json);
}

function run(decoder, value)
{
	var result = runHelp(decoder, value);
	return (result.tag === 'ok')
		? _elm_lang$core$Result$Ok(result.value)
		: _elm_lang$core$Result$Err(badToString(result));
}

function runHelp(decoder, value)
{
	switch (decoder.tag)
	{
		case 'bool':
			return (typeof value === 'boolean')
				? ok(value)
				: badPrimitive('a Bool', value);

		case 'int':
			if (typeof value !== 'number') {
				return badPrimitive('an Int', value);
			}

			if (-2147483647 < value && value < 2147483647 && (value | 0) === value) {
				return ok(value);
			}

			if (isFinite(value) && !(value % 1)) {
				return ok(value);
			}

			return badPrimitive('an Int', value);

		case 'float':
			return (typeof value === 'number')
				? ok(value)
				: badPrimitive('a Float', value);

		case 'string':
			return (typeof value === 'string')
				? ok(value)
				: (value instanceof String)
					? ok(value + '')
					: badPrimitive('a String', value);

		case 'null':
			return (value === null)
				? ok(decoder.value)
				: badPrimitive('null', value);

		case 'value':
			return ok(value);

		case 'list':
			if (!(value instanceof Array))
			{
				return badPrimitive('a List', value);
			}

			var list = _elm_lang$core$Native_List.Nil;
			for (var i = value.length; i--; )
			{
				var result = runHelp(decoder.decoder, value[i]);
				if (result.tag !== 'ok')
				{
					return badIndex(i, result)
				}
				list = _elm_lang$core$Native_List.Cons(result.value, list);
			}
			return ok(list);

		case 'array':
			if (!(value instanceof Array))
			{
				return badPrimitive('an Array', value);
			}

			var len = value.length;
			var array = new Array(len);
			for (var i = len; i--; )
			{
				var result = runHelp(decoder.decoder, value[i]);
				if (result.tag !== 'ok')
				{
					return badIndex(i, result);
				}
				array[i] = result.value;
			}
			return ok(_elm_lang$core$Native_Array.fromJSArray(array));

		case 'maybe':
			var result = runHelp(decoder.decoder, value);
			return (result.tag === 'ok')
				? ok(_elm_lang$core$Maybe$Just(result.value))
				: ok(_elm_lang$core$Maybe$Nothing);

		case 'field':
			var field = decoder.field;
			if (typeof value !== 'object' || value === null || !(field in value))
			{
				return badPrimitive('an object with a field named `' + field + '`', value);
			}

			var result = runHelp(decoder.decoder, value[field]);
			return (result.tag === 'ok') ? result : badField(field, result);

		case 'index':
			var index = decoder.index;
			if (!(value instanceof Array))
			{
				return badPrimitive('an array', value);
			}
			if (index >= value.length)
			{
				return badPrimitive('a longer array. Need index ' + index + ' but there are only ' + value.length + ' entries', value);
			}

			var result = runHelp(decoder.decoder, value[index]);
			return (result.tag === 'ok') ? result : badIndex(index, result);

		case 'key-value':
			if (typeof value !== 'object' || value === null || value instanceof Array)
			{
				return badPrimitive('an object', value);
			}

			var keyValuePairs = _elm_lang$core$Native_List.Nil;
			for (var key in value)
			{
				var result = runHelp(decoder.decoder, value[key]);
				if (result.tag !== 'ok')
				{
					return badField(key, result);
				}
				var pair = _elm_lang$core$Native_Utils.Tuple2(key, result.value);
				keyValuePairs = _elm_lang$core$Native_List.Cons(pair, keyValuePairs);
			}
			return ok(keyValuePairs);

		case 'map-many':
			var answer = decoder.func;
			var decoders = decoder.decoders;
			for (var i = 0; i < decoders.length; i++)
			{
				var result = runHelp(decoders[i], value);
				if (result.tag !== 'ok')
				{
					return result;
				}
				answer = answer(result.value);
			}
			return ok(answer);

		case 'andThen':
			var result = runHelp(decoder.decoder, value);
			return (result.tag !== 'ok')
				? result
				: runHelp(decoder.callback(result.value), value);

		case 'oneOf':
			var errors = [];
			var temp = decoder.decoders;
			while (temp.ctor !== '[]')
			{
				var result = runHelp(temp._0, value);

				if (result.tag === 'ok')
				{
					return result;
				}

				errors.push(result);

				temp = temp._1;
			}
			return badOneOf(errors);

		case 'fail':
			return bad(decoder.msg);

		case 'succeed':
			return ok(decoder.msg);
	}
}


// EQUALITY

function equality(a, b)
{
	if (a === b)
	{
		return true;
	}

	if (a.tag !== b.tag)
	{
		return false;
	}

	switch (a.tag)
	{
		case 'succeed':
		case 'fail':
			return a.msg === b.msg;

		case 'bool':
		case 'int':
		case 'float':
		case 'string':
		case 'value':
			return true;

		case 'null':
			return a.value === b.value;

		case 'list':
		case 'array':
		case 'maybe':
		case 'key-value':
			return equality(a.decoder, b.decoder);

		case 'field':
			return a.field === b.field && equality(a.decoder, b.decoder);

		case 'index':
			return a.index === b.index && equality(a.decoder, b.decoder);

		case 'map-many':
			if (a.func !== b.func)
			{
				return false;
			}
			return listEquality(a.decoders, b.decoders);

		case 'andThen':
			return a.callback === b.callback && equality(a.decoder, b.decoder);

		case 'oneOf':
			return listEquality(a.decoders, b.decoders);
	}
}

function listEquality(aDecoders, bDecoders)
{
	var len = aDecoders.length;
	if (len !== bDecoders.length)
	{
		return false;
	}
	for (var i = 0; i < len; i++)
	{
		if (!equality(aDecoders[i], bDecoders[i]))
		{
			return false;
		}
	}
	return true;
}


// ENCODE

function encode(indentLevel, value)
{
	return JSON.stringify(value, null, indentLevel);
}

function identity(value)
{
	return value;
}

function encodeObject(keyValuePairs)
{
	var obj = {};
	while (keyValuePairs.ctor !== '[]')
	{
		var pair = keyValuePairs._0;
		obj[pair._0] = pair._1;
		keyValuePairs = keyValuePairs._1;
	}
	return obj;
}

return {
	encode: F2(encode),
	runOnString: F2(runOnString),
	run: F2(run),

	decodeNull: decodeNull,
	decodePrimitive: decodePrimitive,
	decodeContainer: F2(decodeContainer),

	decodeField: F2(decodeField),
	decodeIndex: F2(decodeIndex),

	map1: F2(map1),
	map2: F3(map2),
	map3: F4(map3),
	map4: F5(map4),
	map5: F6(map5),
	map6: F7(map6),
	map7: F8(map7),
	map8: F9(map8),
	decodeKeyValuePairs: decodeKeyValuePairs,

	andThen: F2(andThen),
	fail: fail,
	succeed: succeed,
	oneOf: oneOf,

	identity: identity,
	encodeNull: null,
	encodeArray: _elm_lang$core$Native_Array.toJSArray,
	encodeList: _elm_lang$core$Native_List.toArray,
	encodeObject: encodeObject,

	equality: equality
};

}();

var _elm_lang$core$Json_Encode$list = _elm_lang$core$Native_Json.encodeList;
var _elm_lang$core$Json_Encode$array = _elm_lang$core$Native_Json.encodeArray;
var _elm_lang$core$Json_Encode$object = _elm_lang$core$Native_Json.encodeObject;
var _elm_lang$core$Json_Encode$null = _elm_lang$core$Native_Json.encodeNull;
var _elm_lang$core$Json_Encode$bool = _elm_lang$core$Native_Json.identity;
var _elm_lang$core$Json_Encode$float = _elm_lang$core$Native_Json.identity;
var _elm_lang$core$Json_Encode$int = _elm_lang$core$Native_Json.identity;
var _elm_lang$core$Json_Encode$string = _elm_lang$core$Native_Json.identity;
var _elm_lang$core$Json_Encode$encode = _elm_lang$core$Native_Json.encode;
var _elm_lang$core$Json_Encode$Value = {ctor: 'Value'};

var _elm_lang$core$Json_Decode$null = _elm_lang$core$Native_Json.decodeNull;
var _elm_lang$core$Json_Decode$value = _elm_lang$core$Native_Json.decodePrimitive('value');
var _elm_lang$core$Json_Decode$andThen = _elm_lang$core$Native_Json.andThen;
var _elm_lang$core$Json_Decode$fail = _elm_lang$core$Native_Json.fail;
var _elm_lang$core$Json_Decode$succeed = _elm_lang$core$Native_Json.succeed;
var _elm_lang$core$Json_Decode$lazy = function (thunk) {
	return A2(
		_elm_lang$core$Json_Decode$andThen,
		thunk,
		_elm_lang$core$Json_Decode$succeed(
			{ctor: '_Tuple0'}));
};
var _elm_lang$core$Json_Decode$decodeValue = _elm_lang$core$Native_Json.run;
var _elm_lang$core$Json_Decode$decodeString = _elm_lang$core$Native_Json.runOnString;
var _elm_lang$core$Json_Decode$map8 = _elm_lang$core$Native_Json.map8;
var _elm_lang$core$Json_Decode$map7 = _elm_lang$core$Native_Json.map7;
var _elm_lang$core$Json_Decode$map6 = _elm_lang$core$Native_Json.map6;
var _elm_lang$core$Json_Decode$map5 = _elm_lang$core$Native_Json.map5;
var _elm_lang$core$Json_Decode$map4 = _elm_lang$core$Native_Json.map4;
var _elm_lang$core$Json_Decode$map3 = _elm_lang$core$Native_Json.map3;
var _elm_lang$core$Json_Decode$map2 = _elm_lang$core$Native_Json.map2;
var _elm_lang$core$Json_Decode$map = _elm_lang$core$Native_Json.map1;
var _elm_lang$core$Json_Decode$oneOf = _elm_lang$core$Native_Json.oneOf;
var _elm_lang$core$Json_Decode$maybe = function (decoder) {
	return A2(_elm_lang$core$Native_Json.decodeContainer, 'maybe', decoder);
};
var _elm_lang$core$Json_Decode$index = _elm_lang$core$Native_Json.decodeIndex;
var _elm_lang$core$Json_Decode$field = _elm_lang$core$Native_Json.decodeField;
var _elm_lang$core$Json_Decode$at = F2(
	function (fields, decoder) {
		return A3(_elm_lang$core$List$foldr, _elm_lang$core$Json_Decode$field, decoder, fields);
	});
var _elm_lang$core$Json_Decode$keyValuePairs = _elm_lang$core$Native_Json.decodeKeyValuePairs;
var _elm_lang$core$Json_Decode$dict = function (decoder) {
	return A2(
		_elm_lang$core$Json_Decode$map,
		_elm_lang$core$Dict$fromList,
		_elm_lang$core$Json_Decode$keyValuePairs(decoder));
};
var _elm_lang$core$Json_Decode$array = function (decoder) {
	return A2(_elm_lang$core$Native_Json.decodeContainer, 'array', decoder);
};
var _elm_lang$core$Json_Decode$list = function (decoder) {
	return A2(_elm_lang$core$Native_Json.decodeContainer, 'list', decoder);
};
var _elm_lang$core$Json_Decode$nullable = function (decoder) {
	return _elm_lang$core$Json_Decode$oneOf(
		{
			ctor: '::',
			_0: _elm_lang$core$Json_Decode$null(_elm_lang$core$Maybe$Nothing),
			_1: {
				ctor: '::',
				_0: A2(_elm_lang$core$Json_Decode$map, _elm_lang$core$Maybe$Just, decoder),
				_1: {ctor: '[]'}
			}
		});
};
var _elm_lang$core$Json_Decode$float = _elm_lang$core$Native_Json.decodePrimitive('float');
var _elm_lang$core$Json_Decode$int = _elm_lang$core$Native_Json.decodePrimitive('int');
var _elm_lang$core$Json_Decode$bool = _elm_lang$core$Native_Json.decodePrimitive('bool');
var _elm_lang$core$Json_Decode$string = _elm_lang$core$Native_Json.decodePrimitive('string');
var _elm_lang$core$Json_Decode$Decoder = {ctor: 'Decoder'};

var _elm_lang$core$Tuple$mapSecond = F2(
	function (func, _p0) {
		var _p1 = _p0;
		return {
			ctor: '_Tuple2',
			_0: _p1._0,
			_1: func(_p1._1)
		};
	});
var _elm_lang$core$Tuple$mapFirst = F2(
	function (func, _p2) {
		var _p3 = _p2;
		return {
			ctor: '_Tuple2',
			_0: func(_p3._0),
			_1: _p3._1
		};
	});
var _elm_lang$core$Tuple$second = function (_p4) {
	var _p5 = _p4;
	return _p5._1;
};
var _elm_lang$core$Tuple$first = function (_p6) {
	var _p7 = _p6;
	return _p7._0;
};

var _elm_lang$dom$Native_Dom = function() {

var fakeNode = {
	addEventListener: function() {},
	removeEventListener: function() {}
};

var onDocument = on(typeof document !== 'undefined' ? document : fakeNode);
var onWindow = on(typeof window !== 'undefined' ? window : fakeNode);

function on(node)
{
	return function(eventName, decoder, toTask)
	{
		return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) {

			function performTask(event)
			{
				var result = A2(_elm_lang$core$Json_Decode$decodeValue, decoder, event);
				if (result.ctor === 'Ok')
				{
					_elm_lang$core$Native_Scheduler.rawSpawn(toTask(result._0));
				}
			}

			node.addEventListener(eventName, performTask);

			return function()
			{
				node.removeEventListener(eventName, performTask);
			};
		});
	};
}

var rAF = typeof requestAnimationFrame !== 'undefined'
	? requestAnimationFrame
	: function(callback) { callback(); };

function withNode(id, doStuff)
{
	return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback)
	{
		rAF(function()
		{
			var node = document.getElementById(id);
			if (node === null)
			{
				callback(_elm_lang$core$Native_Scheduler.fail({ ctor: 'NotFound', _0: id }));
				return;
			}
			callback(_elm_lang$core$Native_Scheduler.succeed(doStuff(node)));
		});
	});
}


// FOCUS

function focus(id)
{
	return withNode(id, function(node) {
		node.focus();
		return _elm_lang$core$Native_Utils.Tuple0;
	});
}

function blur(id)
{
	return withNode(id, function(node) {
		node.blur();
		return _elm_lang$core$Native_Utils.Tuple0;
	});
}


// SCROLLING

function getScrollTop(id)
{
	return withNode(id, function(node) {
		return node.scrollTop;
	});
}

function setScrollTop(id, desiredScrollTop)
{
	return withNode(id, function(node) {
		node.scrollTop = desiredScrollTop;
		return _elm_lang$core$Native_Utils.Tuple0;
	});
}

function toBottom(id)
{
	return withNode(id, function(node) {
		node.scrollTop = node.scrollHeight;
		return _elm_lang$core$Native_Utils.Tuple0;
	});
}

function getScrollLeft(id)
{
	return withNode(id, function(node) {
		return node.scrollLeft;
	});
}

function setScrollLeft(id, desiredScrollLeft)
{
	return withNode(id, function(node) {
		node.scrollLeft = desiredScrollLeft;
		return _elm_lang$core$Native_Utils.Tuple0;
	});
}

function toRight(id)
{
	return withNode(id, function(node) {
		node.scrollLeft = node.scrollWidth;
		return _elm_lang$core$Native_Utils.Tuple0;
	});
}


// SIZE

function width(options, id)
{
	return withNode(id, function(node) {
		switch (options.ctor)
		{
			case 'Content':
				return node.scrollWidth;
			case 'VisibleContent':
				return node.clientWidth;
			case 'VisibleContentWithBorders':
				return node.offsetWidth;
			case 'VisibleContentWithBordersAndMargins':
				var rect = node.getBoundingClientRect();
				return rect.right - rect.left;
		}
	});
}

function height(options, id)
{
	return withNode(id, function(node) {
		switch (options.ctor)
		{
			case 'Content':
				return node.scrollHeight;
			case 'VisibleContent':
				return node.clientHeight;
			case 'VisibleContentWithBorders':
				return node.offsetHeight;
			case 'VisibleContentWithBordersAndMargins':
				var rect = node.getBoundingClientRect();
				return rect.bottom - rect.top;
		}
	});
}

return {
	onDocument: F3(onDocument),
	onWindow: F3(onWindow),

	focus: focus,
	blur: blur,

	getScrollTop: getScrollTop,
	setScrollTop: F2(setScrollTop),
	getScrollLeft: getScrollLeft,
	setScrollLeft: F2(setScrollLeft),
	toBottom: toBottom,
	toRight: toRight,

	height: F2(height),
	width: F2(width)
};

}();

var _elm_lang$dom$Dom$blur = _elm_lang$dom$Native_Dom.blur;
var _elm_lang$dom$Dom$focus = _elm_lang$dom$Native_Dom.focus;
var _elm_lang$dom$Dom$NotFound = function (a) {
	return {ctor: 'NotFound', _0: a};
};

var _elm_lang$virtual_dom$VirtualDom_Debug$wrap;
var _elm_lang$virtual_dom$VirtualDom_Debug$wrapWithFlags;

var _elm_lang$virtual_dom$Native_VirtualDom = function() {

var STYLE_KEY = 'STYLE';
var EVENT_KEY = 'EVENT';
var ATTR_KEY = 'ATTR';
var ATTR_NS_KEY = 'ATTR_NS';

var localDoc = typeof document !== 'undefined' ? document : {};


////////////  VIRTUAL DOM NODES  ////////////


function text(string)
{
	return {
		type: 'text',
		text: string
	};
}


function node(tag)
{
	return F2(function(factList, kidList) {
		return nodeHelp(tag, factList, kidList);
	});
}


function nodeHelp(tag, factList, kidList)
{
	var organized = organizeFacts(factList);
	var namespace = organized.namespace;
	var facts = organized.facts;

	var children = [];
	var descendantsCount = 0;
	while (kidList.ctor !== '[]')
	{
		var kid = kidList._0;
		descendantsCount += (kid.descendantsCount || 0);
		children.push(kid);
		kidList = kidList._1;
	}
	descendantsCount += children.length;

	return {
		type: 'node',
		tag: tag,
		facts: facts,
		children: children,
		namespace: namespace,
		descendantsCount: descendantsCount
	};
}


function keyedNode(tag, factList, kidList)
{
	var organized = organizeFacts(factList);
	var namespace = organized.namespace;
	var facts = organized.facts;

	var children = [];
	var descendantsCount = 0;
	while (kidList.ctor !== '[]')
	{
		var kid = kidList._0;
		descendantsCount += (kid._1.descendantsCount || 0);
		children.push(kid);
		kidList = kidList._1;
	}
	descendantsCount += children.length;

	return {
		type: 'keyed-node',
		tag: tag,
		facts: facts,
		children: children,
		namespace: namespace,
		descendantsCount: descendantsCount
	};
}


function custom(factList, model, impl)
{
	var facts = organizeFacts(factList).facts;

	return {
		type: 'custom',
		facts: facts,
		model: model,
		impl: impl
	};
}


function map(tagger, node)
{
	return {
		type: 'tagger',
		tagger: tagger,
		node: node,
		descendantsCount: 1 + (node.descendantsCount || 0)
	};
}


function thunk(func, args, thunk)
{
	return {
		type: 'thunk',
		func: func,
		args: args,
		thunk: thunk,
		node: undefined
	};
}

function lazy(fn, a)
{
	return thunk(fn, [a], function() {
		return fn(a);
	});
}

function lazy2(fn, a, b)
{
	return thunk(fn, [a,b], function() {
		return A2(fn, a, b);
	});
}

function lazy3(fn, a, b, c)
{
	return thunk(fn, [a,b,c], function() {
		return A3(fn, a, b, c);
	});
}



// FACTS


function organizeFacts(factList)
{
	var namespace, facts = {};

	while (factList.ctor !== '[]')
	{
		var entry = factList._0;
		var key = entry.key;

		if (key === ATTR_KEY || key === ATTR_NS_KEY || key === EVENT_KEY)
		{
			var subFacts = facts[key] || {};
			subFacts[entry.realKey] = entry.value;
			facts[key] = subFacts;
		}
		else if (key === STYLE_KEY)
		{
			var styles = facts[key] || {};
			var styleList = entry.value;
			while (styleList.ctor !== '[]')
			{
				var style = styleList._0;
				styles[style._0] = style._1;
				styleList = styleList._1;
			}
			facts[key] = styles;
		}
		else if (key === 'namespace')
		{
			namespace = entry.value;
		}
		else if (key === 'className')
		{
			var classes = facts[key];
			facts[key] = typeof classes === 'undefined'
				? entry.value
				: classes + ' ' + entry.value;
		}
 		else
		{
			facts[key] = entry.value;
		}
		factList = factList._1;
	}

	return {
		facts: facts,
		namespace: namespace
	};
}



////////////  PROPERTIES AND ATTRIBUTES  ////////////


function style(value)
{
	return {
		key: STYLE_KEY,
		value: value
	};
}


function property(key, value)
{
	return {
		key: key,
		value: value
	};
}


function attribute(key, value)
{
	return {
		key: ATTR_KEY,
		realKey: key,
		value: value
	};
}


function attributeNS(namespace, key, value)
{
	return {
		key: ATTR_NS_KEY,
		realKey: key,
		value: {
			value: value,
			namespace: namespace
		}
	};
}


function on(name, options, decoder)
{
	return {
		key: EVENT_KEY,
		realKey: name,
		value: {
			options: options,
			decoder: decoder
		}
	};
}


function equalEvents(a, b)
{
	if (a.options !== b.options)
	{
		if (a.options.stopPropagation !== b.options.stopPropagation || a.options.preventDefault !== b.options.preventDefault)
		{
			return false;
		}
	}
	return _elm_lang$core$Native_Json.equality(a.decoder, b.decoder);
}


function mapProperty(func, property)
{
	if (property.key !== EVENT_KEY)
	{
		return property;
	}
	return on(
		property.realKey,
		property.value.options,
		A2(_elm_lang$core$Json_Decode$map, func, property.value.decoder)
	);
}


////////////  RENDER  ////////////


function render(vNode, eventNode)
{
	switch (vNode.type)
	{
		case 'thunk':
			if (!vNode.node)
			{
				vNode.node = vNode.thunk();
			}
			return render(vNode.node, eventNode);

		case 'tagger':
			var subNode = vNode.node;
			var tagger = vNode.tagger;

			while (subNode.type === 'tagger')
			{
				typeof tagger !== 'object'
					? tagger = [tagger, subNode.tagger]
					: tagger.push(subNode.tagger);

				subNode = subNode.node;
			}

			var subEventRoot = { tagger: tagger, parent: eventNode };
			var domNode = render(subNode, subEventRoot);
			domNode.elm_event_node_ref = subEventRoot;
			return domNode;

		case 'text':
			return localDoc.createTextNode(vNode.text);

		case 'node':
			var domNode = vNode.namespace
				? localDoc.createElementNS(vNode.namespace, vNode.tag)
				: localDoc.createElement(vNode.tag);

			applyFacts(domNode, eventNode, vNode.facts);

			var children = vNode.children;

			for (var i = 0; i < children.length; i++)
			{
				domNode.appendChild(render(children[i], eventNode));
			}

			return domNode;

		case 'keyed-node':
			var domNode = vNode.namespace
				? localDoc.createElementNS(vNode.namespace, vNode.tag)
				: localDoc.createElement(vNode.tag);

			applyFacts(domNode, eventNode, vNode.facts);

			var children = vNode.children;

			for (var i = 0; i < children.length; i++)
			{
				domNode.appendChild(render(children[i]._1, eventNode));
			}

			return domNode;

		case 'custom':
			var domNode = vNode.impl.render(vNode.model);
			applyFacts(domNode, eventNode, vNode.facts);
			return domNode;
	}
}



////////////  APPLY FACTS  ////////////


function applyFacts(domNode, eventNode, facts)
{
	for (var key in facts)
	{
		var value = facts[key];

		switch (key)
		{
			case STYLE_KEY:
				applyStyles(domNode, value);
				break;

			case EVENT_KEY:
				applyEvents(domNode, eventNode, value);
				break;

			case ATTR_KEY:
				applyAttrs(domNode, value);
				break;

			case ATTR_NS_KEY:
				applyAttrsNS(domNode, value);
				break;

			case 'value':
				if (domNode[key] !== value)
				{
					domNode[key] = value;
				}
				break;

			default:
				domNode[key] = value;
				break;
		}
	}
}

function applyStyles(domNode, styles)
{
	var domNodeStyle = domNode.style;

	for (var key in styles)
	{
		domNodeStyle[key] = styles[key];
	}
}

function applyEvents(domNode, eventNode, events)
{
	var allHandlers = domNode.elm_handlers || {};

	for (var key in events)
	{
		var handler = allHandlers[key];
		var value = events[key];

		if (typeof value === 'undefined')
		{
			domNode.removeEventListener(key, handler);
			allHandlers[key] = undefined;
		}
		else if (typeof handler === 'undefined')
		{
			var handler = makeEventHandler(eventNode, value);
			domNode.addEventListener(key, handler);
			allHandlers[key] = handler;
		}
		else
		{
			handler.info = value;
		}
	}

	domNode.elm_handlers = allHandlers;
}

function makeEventHandler(eventNode, info)
{
	function eventHandler(event)
	{
		var info = eventHandler.info;

		var value = A2(_elm_lang$core$Native_Json.run, info.decoder, event);

		if (value.ctor === 'Ok')
		{
			var options = info.options;
			if (options.stopPropagation)
			{
				event.stopPropagation();
			}
			if (options.preventDefault)
			{
				event.preventDefault();
			}

			var message = value._0;

			var currentEventNode = eventNode;
			while (currentEventNode)
			{
				var tagger = currentEventNode.tagger;
				if (typeof tagger === 'function')
				{
					message = tagger(message);
				}
				else
				{
					for (var i = tagger.length; i--; )
					{
						message = tagger[i](message);
					}
				}
				currentEventNode = currentEventNode.parent;
			}
		}
	};

	eventHandler.info = info;

	return eventHandler;
}

function applyAttrs(domNode, attrs)
{
	for (var key in attrs)
	{
		var value = attrs[key];
		if (typeof value === 'undefined')
		{
			domNode.removeAttribute(key);
		}
		else
		{
			domNode.setAttribute(key, value);
		}
	}
}

function applyAttrsNS(domNode, nsAttrs)
{
	for (var key in nsAttrs)
	{
		var pair = nsAttrs[key];
		var namespace = pair.namespace;
		var value = pair.value;

		if (typeof value === 'undefined')
		{
			domNode.removeAttributeNS(namespace, key);
		}
		else
		{
			domNode.setAttributeNS(namespace, key, value);
		}
	}
}



////////////  DIFF  ////////////


function diff(a, b)
{
	var patches = [];
	diffHelp(a, b, patches, 0);
	return patches;
}


function makePatch(type, index, data)
{
	return {
		index: index,
		type: type,
		data: data,
		domNode: undefined,
		eventNode: undefined
	};
}


function diffHelp(a, b, patches, index)
{
	if (a === b)
	{
		return;
	}

	var aType = a.type;
	var bType = b.type;

	// Bail if you run into different types of nodes. Implies that the
	// structure has changed significantly and it's not worth a diff.
	if (aType !== bType)
	{
		patches.push(makePatch('p-redraw', index, b));
		return;
	}

	// Now we know that both nodes are the same type.
	switch (bType)
	{
		case 'thunk':
			var aArgs = a.args;
			var bArgs = b.args;
			var i = aArgs.length;
			var same = a.func === b.func && i === bArgs.length;
			while (same && i--)
			{
				same = aArgs[i] === bArgs[i];
			}
			if (same)
			{
				b.node = a.node;
				return;
			}
			b.node = b.thunk();
			var subPatches = [];
			diffHelp(a.node, b.node, subPatches, 0);
			if (subPatches.length > 0)
			{
				patches.push(makePatch('p-thunk', index, subPatches));
			}
			return;

		case 'tagger':
			// gather nested taggers
			var aTaggers = a.tagger;
			var bTaggers = b.tagger;
			var nesting = false;

			var aSubNode = a.node;
			while (aSubNode.type === 'tagger')
			{
				nesting = true;

				typeof aTaggers !== 'object'
					? aTaggers = [aTaggers, aSubNode.tagger]
					: aTaggers.push(aSubNode.tagger);

				aSubNode = aSubNode.node;
			}

			var bSubNode = b.node;
			while (bSubNode.type === 'tagger')
			{
				nesting = true;

				typeof bTaggers !== 'object'
					? bTaggers = [bTaggers, bSubNode.tagger]
					: bTaggers.push(bSubNode.tagger);

				bSubNode = bSubNode.node;
			}

			// Just bail if different numbers of taggers. This implies the
			// structure of the virtual DOM has changed.
			if (nesting && aTaggers.length !== bTaggers.length)
			{
				patches.push(makePatch('p-redraw', index, b));
				return;
			}

			// check if taggers are "the same"
			if (nesting ? !pairwiseRefEqual(aTaggers, bTaggers) : aTaggers !== bTaggers)
			{
				patches.push(makePatch('p-tagger', index, bTaggers));
			}

			// diff everything below the taggers
			diffHelp(aSubNode, bSubNode, patches, index + 1);
			return;

		case 'text':
			if (a.text !== b.text)
			{
				patches.push(makePatch('p-text', index, b.text));
				return;
			}

			return;

		case 'node':
			// Bail if obvious indicators have changed. Implies more serious
			// structural changes such that it's not worth it to diff.
			if (a.tag !== b.tag || a.namespace !== b.namespace)
			{
				patches.push(makePatch('p-redraw', index, b));
				return;
			}

			var factsDiff = diffFacts(a.facts, b.facts);

			if (typeof factsDiff !== 'undefined')
			{
				patches.push(makePatch('p-facts', index, factsDiff));
			}

			diffChildren(a, b, patches, index);
			return;

		case 'keyed-node':
			// Bail if obvious indicators have changed. Implies more serious
			// structural changes such that it's not worth it to diff.
			if (a.tag !== b.tag || a.namespace !== b.namespace)
			{
				patches.push(makePatch('p-redraw', index, b));
				return;
			}

			var factsDiff = diffFacts(a.facts, b.facts);

			if (typeof factsDiff !== 'undefined')
			{
				patches.push(makePatch('p-facts', index, factsDiff));
			}

			diffKeyedChildren(a, b, patches, index);
			return;

		case 'custom':
			if (a.impl !== b.impl)
			{
				patches.push(makePatch('p-redraw', index, b));
				return;
			}

			var factsDiff = diffFacts(a.facts, b.facts);
			if (typeof factsDiff !== 'undefined')
			{
				patches.push(makePatch('p-facts', index, factsDiff));
			}

			var patch = b.impl.diff(a,b);
			if (patch)
			{
				patches.push(makePatch('p-custom', index, patch));
				return;
			}

			return;
	}
}


// assumes the incoming arrays are the same length
function pairwiseRefEqual(as, bs)
{
	for (var i = 0; i < as.length; i++)
	{
		if (as[i] !== bs[i])
		{
			return false;
		}
	}

	return true;
}


// TODO Instead of creating a new diff object, it's possible to just test if
// there *is* a diff. During the actual patch, do the diff again and make the
// modifications directly. This way, there's no new allocations. Worth it?
function diffFacts(a, b, category)
{
	var diff;

	// look for changes and removals
	for (var aKey in a)
	{
		if (aKey === STYLE_KEY || aKey === EVENT_KEY || aKey === ATTR_KEY || aKey === ATTR_NS_KEY)
		{
			var subDiff = diffFacts(a[aKey], b[aKey] || {}, aKey);
			if (subDiff)
			{
				diff = diff || {};
				diff[aKey] = subDiff;
			}
			continue;
		}

		// remove if not in the new facts
		if (!(aKey in b))
		{
			diff = diff || {};
			diff[aKey] =
				(typeof category === 'undefined')
					? (typeof a[aKey] === 'string' ? '' : null)
					:
				(category === STYLE_KEY)
					? ''
					:
				(category === EVENT_KEY || category === ATTR_KEY)
					? undefined
					:
				{ namespace: a[aKey].namespace, value: undefined };

			continue;
		}

		var aValue = a[aKey];
		var bValue = b[aKey];

		// reference equal, so don't worry about it
		if (aValue === bValue && aKey !== 'value'
			|| category === EVENT_KEY && equalEvents(aValue, bValue))
		{
			continue;
		}

		diff = diff || {};
		diff[aKey] = bValue;
	}

	// add new stuff
	for (var bKey in b)
	{
		if (!(bKey in a))
		{
			diff = diff || {};
			diff[bKey] = b[bKey];
		}
	}

	return diff;
}


function diffChildren(aParent, bParent, patches, rootIndex)
{
	var aChildren = aParent.children;
	var bChildren = bParent.children;

	var aLen = aChildren.length;
	var bLen = bChildren.length;

	// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS

	if (aLen > bLen)
	{
		patches.push(makePatch('p-remove-last', rootIndex, aLen - bLen));
	}
	else if (aLen < bLen)
	{
		patches.push(makePatch('p-append', rootIndex, bChildren.slice(aLen)));
	}

	// PAIRWISE DIFF EVERYTHING ELSE

	var index = rootIndex;
	var minLen = aLen < bLen ? aLen : bLen;
	for (var i = 0; i < minLen; i++)
	{
		index++;
		var aChild = aChildren[i];
		diffHelp(aChild, bChildren[i], patches, index);
		index += aChild.descendantsCount || 0;
	}
}



////////////  KEYED DIFF  ////////////


function diffKeyedChildren(aParent, bParent, patches, rootIndex)
{
	var localPatches = [];

	var changes = {}; // Dict String Entry
	var inserts = []; // Array { index : Int, entry : Entry }
	// type Entry = { tag : String, vnode : VNode, index : Int, data : _ }

	var aChildren = aParent.children;
	var bChildren = bParent.children;
	var aLen = aChildren.length;
	var bLen = bChildren.length;
	var aIndex = 0;
	var bIndex = 0;

	var index = rootIndex;

	while (aIndex < aLen && bIndex < bLen)
	{
		var a = aChildren[aIndex];
		var b = bChildren[bIndex];

		var aKey = a._0;
		var bKey = b._0;
		var aNode = a._1;
		var bNode = b._1;

		// check if keys match

		if (aKey === bKey)
		{
			index++;
			diffHelp(aNode, bNode, localPatches, index);
			index += aNode.descendantsCount || 0;

			aIndex++;
			bIndex++;
			continue;
		}

		// look ahead 1 to detect insertions and removals.

		var aLookAhead = aIndex + 1 < aLen;
		var bLookAhead = bIndex + 1 < bLen;

		if (aLookAhead)
		{
			var aNext = aChildren[aIndex + 1];
			var aNextKey = aNext._0;
			var aNextNode = aNext._1;
			var oldMatch = bKey === aNextKey;
		}

		if (bLookAhead)
		{
			var bNext = bChildren[bIndex + 1];
			var bNextKey = bNext._0;
			var bNextNode = bNext._1;
			var newMatch = aKey === bNextKey;
		}


		// swap a and b
		if (aLookAhead && bLookAhead && newMatch && oldMatch)
		{
			index++;
			diffHelp(aNode, bNextNode, localPatches, index);
			insertNode(changes, localPatches, aKey, bNode, bIndex, inserts);
			index += aNode.descendantsCount || 0;

			index++;
			removeNode(changes, localPatches, aKey, aNextNode, index);
			index += aNextNode.descendantsCount || 0;

			aIndex += 2;
			bIndex += 2;
			continue;
		}

		// insert b
		if (bLookAhead && newMatch)
		{
			index++;
			insertNode(changes, localPatches, bKey, bNode, bIndex, inserts);
			diffHelp(aNode, bNextNode, localPatches, index);
			index += aNode.descendantsCount || 0;

			aIndex += 1;
			bIndex += 2;
			continue;
		}

		// remove a
		if (aLookAhead && oldMatch)
		{
			index++;
			removeNode(changes, localPatches, aKey, aNode, index);
			index += aNode.descendantsCount || 0;

			index++;
			diffHelp(aNextNode, bNode, localPatches, index);
			index += aNextNode.descendantsCount || 0;

			aIndex += 2;
			bIndex += 1;
			continue;
		}

		// remove a, insert b
		if (aLookAhead && bLookAhead && aNextKey === bNextKey)
		{
			index++;
			removeNode(changes, localPatches, aKey, aNode, index);
			insertNode(changes, localPatches, bKey, bNode, bIndex, inserts);
			index += aNode.descendantsCount || 0;

			index++;
			diffHelp(aNextNode, bNextNode, localPatches, index);
			index += aNextNode.descendantsCount || 0;

			aIndex += 2;
			bIndex += 2;
			continue;
		}

		break;
	}

	// eat up any remaining nodes with removeNode and insertNode

	while (aIndex < aLen)
	{
		index++;
		var a = aChildren[aIndex];
		var aNode = a._1;
		removeNode(changes, localPatches, a._0, aNode, index);
		index += aNode.descendantsCount || 0;
		aIndex++;
	}

	var endInserts;
	while (bIndex < bLen)
	{
		endInserts = endInserts || [];
		var b = bChildren[bIndex];
		insertNode(changes, localPatches, b._0, b._1, undefined, endInserts);
		bIndex++;
	}

	if (localPatches.length > 0 || inserts.length > 0 || typeof endInserts !== 'undefined')
	{
		patches.push(makePatch('p-reorder', rootIndex, {
			patches: localPatches,
			inserts: inserts,
			endInserts: endInserts
		}));
	}
}



////////////  CHANGES FROM KEYED DIFF  ////////////


var POSTFIX = '_elmW6BL';


function insertNode(changes, localPatches, key, vnode, bIndex, inserts)
{
	var entry = changes[key];

	// never seen this key before
	if (typeof entry === 'undefined')
	{
		entry = {
			tag: 'insert',
			vnode: vnode,
			index: bIndex,
			data: undefined
		};

		inserts.push({ index: bIndex, entry: entry });
		changes[key] = entry;

		return;
	}

	// this key was removed earlier, a match!
	if (entry.tag === 'remove')
	{
		inserts.push({ index: bIndex, entry: entry });

		entry.tag = 'move';
		var subPatches = [];
		diffHelp(entry.vnode, vnode, subPatches, entry.index);
		entry.index = bIndex;
		entry.data.data = {
			patches: subPatches,
			entry: entry
		};

		return;
	}

	// this key has already been inserted or moved, a duplicate!
	insertNode(changes, localPatches, key + POSTFIX, vnode, bIndex, inserts);
}


function removeNode(changes, localPatches, key, vnode, index)
{
	var entry = changes[key];

	// never seen this key before
	if (typeof entry === 'undefined')
	{
		var patch = makePatch('p-remove', index, undefined);
		localPatches.push(patch);

		changes[key] = {
			tag: 'remove',
			vnode: vnode,
			index: index,
			data: patch
		};

		return;
	}

	// this key was inserted earlier, a match!
	if (entry.tag === 'insert')
	{
		entry.tag = 'move';
		var subPatches = [];
		diffHelp(vnode, entry.vnode, subPatches, index);

		var patch = makePatch('p-remove', index, {
			patches: subPatches,
			entry: entry
		});
		localPatches.push(patch);

		return;
	}

	// this key has already been removed or moved, a duplicate!
	removeNode(changes, localPatches, key + POSTFIX, vnode, index);
}



////////////  ADD DOM NODES  ////////////
//
// Each DOM node has an "index" assigned in order of traversal. It is important
// to minimize our crawl over the actual DOM, so these indexes (along with the
// descendantsCount of virtual nodes) let us skip touching entire subtrees of
// the DOM if we know there are no patches there.


function addDomNodes(domNode, vNode, patches, eventNode)
{
	addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.descendantsCount, eventNode);
}


// assumes `patches` is non-empty and indexes increase monotonically.
function addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
{
	var patch = patches[i];
	var index = patch.index;

	while (index === low)
	{
		var patchType = patch.type;

		if (patchType === 'p-thunk')
		{
			addDomNodes(domNode, vNode.node, patch.data, eventNode);
		}
		else if (patchType === 'p-reorder')
		{
			patch.domNode = domNode;
			patch.eventNode = eventNode;

			var subPatches = patch.data.patches;
			if (subPatches.length > 0)
			{
				addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
			}
		}
		else if (patchType === 'p-remove')
		{
			patch.domNode = domNode;
			patch.eventNode = eventNode;

			var data = patch.data;
			if (typeof data !== 'undefined')
			{
				data.entry.data = domNode;
				var subPatches = data.patches;
				if (subPatches.length > 0)
				{
					addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
				}
			}
		}
		else
		{
			patch.domNode = domNode;
			patch.eventNode = eventNode;
		}

		i++;

		if (!(patch = patches[i]) || (index = patch.index) > high)
		{
			return i;
		}
	}

	switch (vNode.type)
	{
		case 'tagger':
			var subNode = vNode.node;

			while (subNode.type === "tagger")
			{
				subNode = subNode.node;
			}

			return addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);

		case 'node':
			var vChildren = vNode.children;
			var childNodes = domNode.childNodes;
			for (var j = 0; j < vChildren.length; j++)
			{
				low++;
				var vChild = vChildren[j];
				var nextLow = low + (vChild.descendantsCount || 0);
				if (low <= index && index <= nextLow)
				{
					i = addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode);
					if (!(patch = patches[i]) || (index = patch.index) > high)
					{
						return i;
					}
				}
				low = nextLow;
			}
			return i;

		case 'keyed-node':
			var vChildren = vNode.children;
			var childNodes = domNode.childNodes;
			for (var j = 0; j < vChildren.length; j++)
			{
				low++;
				var vChild = vChildren[j]._1;
				var nextLow = low + (vChild.descendantsCount || 0);
				if (low <= index && index <= nextLow)
				{
					i = addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode);
					if (!(patch = patches[i]) || (index = patch.index) > high)
					{
						return i;
					}
				}
				low = nextLow;
			}
			return i;

		case 'text':
		case 'thunk':
			throw new Error('should never traverse `text` or `thunk` nodes like this');
	}
}



////////////  APPLY PATCHES  ////////////


function applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
{
	if (patches.length === 0)
	{
		return rootDomNode;
	}

	addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
	return applyPatchesHelp(rootDomNode, patches);
}

function applyPatchesHelp(rootDomNode, patches)
{
	for (var i = 0; i < patches.length; i++)
	{
		var patch = patches[i];
		var localDomNode = patch.domNode
		var newNode = applyPatch(localDomNode, patch);
		if (localDomNode === rootDomNode)
		{
			rootDomNode = newNode;
		}
	}
	return rootDomNode;
}

function applyPatch(domNode, patch)
{
	switch (patch.type)
	{
		case 'p-redraw':
			return applyPatchRedraw(domNode, patch.data, patch.eventNode);

		case 'p-facts':
			applyFacts(domNode, patch.eventNode, patch.data);
			return domNode;

		case 'p-text':
			domNode.replaceData(0, domNode.length, patch.data);
			return domNode;

		case 'p-thunk':
			return applyPatchesHelp(domNode, patch.data);

		case 'p-tagger':
			if (typeof domNode.elm_event_node_ref !== 'undefined')
			{
				domNode.elm_event_node_ref.tagger = patch.data;
			}
			else
			{
				domNode.elm_event_node_ref = { tagger: patch.data, parent: patch.eventNode };
			}
			return domNode;

		case 'p-remove-last':
			var i = patch.data;
			while (i--)
			{
				domNode.removeChild(domNode.lastChild);
			}
			return domNode;

		case 'p-append':
			var newNodes = patch.data;
			for (var i = 0; i < newNodes.length; i++)
			{
				domNode.appendChild(render(newNodes[i], patch.eventNode));
			}
			return domNode;

		case 'p-remove':
			var data = patch.data;
			if (typeof data === 'undefined')
			{
				domNode.parentNode.removeChild(domNode);
				return domNode;
			}
			var entry = data.entry;
			if (typeof entry.index !== 'undefined')
			{
				domNode.parentNode.removeChild(domNode);
			}
			entry.data = applyPatchesHelp(domNode, data.patches);
			return domNode;

		case 'p-reorder':
			return applyPatchReorder(domNode, patch);

		case 'p-custom':
			var impl = patch.data;
			return impl.applyPatch(domNode, impl.data);

		default:
			throw new Error('Ran into an unknown patch!');
	}
}


function applyPatchRedraw(domNode, vNode, eventNode)
{
	var parentNode = domNode.parentNode;
	var newNode = render(vNode, eventNode);

	if (typeof newNode.elm_event_node_ref === 'undefined')
	{
		newNode.elm_event_node_ref = domNode.elm_event_node_ref;
	}

	if (parentNode && newNode !== domNode)
	{
		parentNode.replaceChild(newNode, domNode);
	}
	return newNode;
}


function applyPatchReorder(domNode, patch)
{
	var data = patch.data;

	// remove end inserts
	var frag = applyPatchReorderEndInsertsHelp(data.endInserts, patch);

	// removals
	domNode = applyPatchesHelp(domNode, data.patches);

	// inserts
	var inserts = data.inserts;
	for (var i = 0; i < inserts.length; i++)
	{
		var insert = inserts[i];
		var entry = insert.entry;
		var node = entry.tag === 'move'
			? entry.data
			: render(entry.vnode, patch.eventNode);
		domNode.insertBefore(node, domNode.childNodes[insert.index]);
	}

	// add end inserts
	if (typeof frag !== 'undefined')
	{
		domNode.appendChild(frag);
	}

	return domNode;
}


function applyPatchReorderEndInsertsHelp(endInserts, patch)
{
	if (typeof endInserts === 'undefined')
	{
		return;
	}

	var frag = localDoc.createDocumentFragment();
	for (var i = 0; i < endInserts.length; i++)
	{
		var insert = endInserts[i];
		var entry = insert.entry;
		frag.appendChild(entry.tag === 'move'
			? entry.data
			: render(entry.vnode, patch.eventNode)
		);
	}
	return frag;
}


// PROGRAMS

var program = makeProgram(checkNoFlags);
var programWithFlags = makeProgram(checkYesFlags);

function makeProgram(flagChecker)
{
	return F2(function(debugWrap, impl)
	{
		return function(flagDecoder)
		{
			return function(object, moduleName, debugMetadata)
			{
				var checker = flagChecker(flagDecoder, moduleName);
				if (typeof debugMetadata === 'undefined')
				{
					normalSetup(impl, object, moduleName, checker);
				}
				else
				{
					debugSetup(A2(debugWrap, debugMetadata, impl), object, moduleName, checker);
				}
			};
		};
	});
}

function staticProgram(vNode)
{
	var nothing = _elm_lang$core$Native_Utils.Tuple2(
		_elm_lang$core$Native_Utils.Tuple0,
		_elm_lang$core$Platform_Cmd$none
	);
	return A2(program, _elm_lang$virtual_dom$VirtualDom_Debug$wrap, {
		init: nothing,
		view: function() { return vNode; },
		update: F2(function() { return nothing; }),
		subscriptions: function() { return _elm_lang$core$Platform_Sub$none; }
	})();
}


// FLAG CHECKERS

function checkNoFlags(flagDecoder, moduleName)
{
	return function(init, flags, domNode)
	{
		if (typeof flags === 'undefined')
		{
			return init;
		}

		var errorMessage =
			'The `' + moduleName + '` module does not need flags.\n'
			+ 'Initialize it with no arguments and you should be all set!';

		crash(errorMessage, domNode);
	};
}

function checkYesFlags(flagDecoder, moduleName)
{
	return function(init, flags, domNode)
	{
		if (typeof flagDecoder === 'undefined')
		{
			var errorMessage =
				'Are you trying to sneak a Never value into Elm? Trickster!\n'
				+ 'It looks like ' + moduleName + '.main is defined with `programWithFlags` but has type `Program Never`.\n'
				+ 'Use `program` instead if you do not want flags.'

			crash(errorMessage, domNode);
		}

		var result = A2(_elm_lang$core$Native_Json.run, flagDecoder, flags);
		if (result.ctor === 'Ok')
		{
			return init(result._0);
		}

		var errorMessage =
			'Trying to initialize the `' + moduleName + '` module with an unexpected flag.\n'
			+ 'I tried to convert it to an Elm value, but ran into this problem:\n\n'
			+ result._0;

		crash(errorMessage, domNode);
	};
}

function crash(errorMessage, domNode)
{
	if (domNode)
	{
		domNode.innerHTML =
			'<div style="padding-left:1em;">'
			+ '<h2 style="font-weight:normal;"><b>Oops!</b> Something went wrong when starting your Elm program.</h2>'
			+ '<pre style="padding-left:1em;">' + errorMessage + '</pre>'
			+ '</div>';
	}

	throw new Error(errorMessage);
}


//  NORMAL SETUP

function normalSetup(impl, object, moduleName, flagChecker)
{
	object['embed'] = function embed(node, flags)
	{
		while (node.lastChild)
		{
			node.removeChild(node.lastChild);
		}

		return _elm_lang$core$Native_Platform.initialize(
			flagChecker(impl.init, flags, node),
			impl.update,
			impl.subscriptions,
			normalRenderer(node, impl.view)
		);
	};

	object['fullscreen'] = function fullscreen(flags)
	{
		return _elm_lang$core$Native_Platform.initialize(
			flagChecker(impl.init, flags, document.body),
			impl.update,
			impl.subscriptions,
			normalRenderer(document.body, impl.view)
		);
	};
}

function normalRenderer(parentNode, view)
{
	return function(tagger, initialModel)
	{
		var eventNode = { tagger: tagger, parent: undefined };
		var initialVirtualNode = view(initialModel);
		var domNode = render(initialVirtualNode, eventNode);
		parentNode.appendChild(domNode);
		return makeStepper(domNode, view, initialVirtualNode, eventNode);
	};
}


// STEPPER

var rAF =
	typeof requestAnimationFrame !== 'undefined'
		? requestAnimationFrame
		: function(callback) { setTimeout(callback, 1000 / 60); };

function makeStepper(domNode, view, initialVirtualNode, eventNode)
{
	var state = 'NO_REQUEST';
	var currNode = initialVirtualNode;
	var nextModel;

	function updateIfNeeded()
	{
		switch (state)
		{
			case 'NO_REQUEST':
				throw new Error(
					'Unexpected draw callback.\n' +
					'Please report this to <https://github.com/elm-lang/virtual-dom/issues>.'
				);

			case 'PENDING_REQUEST':
				rAF(updateIfNeeded);
				state = 'EXTRA_REQUEST';

				var nextNode = view(nextModel);
				var patches = diff(currNode, nextNode);
				domNode = applyPatches(domNode, currNode, patches, eventNode);
				currNode = nextNode;

				return;

			case 'EXTRA_REQUEST':
				state = 'NO_REQUEST';
				return;
		}
	}

	return function stepper(model)
	{
		if (state === 'NO_REQUEST')
		{
			rAF(updateIfNeeded);
		}
		state = 'PENDING_REQUEST';
		nextModel = model;
	};
}


// DEBUG SETUP

function debugSetup(impl, object, moduleName, flagChecker)
{
	object['fullscreen'] = function fullscreen(flags)
	{
		var popoutRef = { doc: undefined };
		return _elm_lang$core$Native_Platform.initialize(
			flagChecker(impl.init, flags, document.body),
			impl.update(scrollTask(popoutRef)),
			impl.subscriptions,
			debugRenderer(moduleName, document.body, popoutRef, impl.view, impl.viewIn, impl.viewOut)
		);
	};

	object['embed'] = function fullscreen(node, flags)
	{
		var popoutRef = { doc: undefined };
		return _elm_lang$core$Native_Platform.initialize(
			flagChecker(impl.init, flags, node),
			impl.update(scrollTask(popoutRef)),
			impl.subscriptions,
			debugRenderer(moduleName, node, popoutRef, impl.view, impl.viewIn, impl.viewOut)
		);
	};
}

function scrollTask(popoutRef)
{
	return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback)
	{
		var doc = popoutRef.doc;
		if (doc)
		{
			var msgs = doc.getElementsByClassName('debugger-sidebar-messages')[0];
			if (msgs)
			{
				msgs.scrollTop = msgs.scrollHeight;
			}
		}
		callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0));
	});
}


function debugRenderer(moduleName, parentNode, popoutRef, view, viewIn, viewOut)
{
	return function(tagger, initialModel)
	{
		var appEventNode = { tagger: tagger, parent: undefined };
		var eventNode = { tagger: tagger, parent: undefined };

		// make normal stepper
		var appVirtualNode = view(initialModel);
		var appNode = render(appVirtualNode, appEventNode);
		parentNode.appendChild(appNode);
		var appStepper = makeStepper(appNode, view, appVirtualNode, appEventNode);

		// make overlay stepper
		var overVirtualNode = viewIn(initialModel)._1;
		var overNode = render(overVirtualNode, eventNode);
		parentNode.appendChild(overNode);
		var wrappedViewIn = wrapViewIn(appEventNode, overNode, viewIn);
		var overStepper = makeStepper(overNode, wrappedViewIn, overVirtualNode, eventNode);

		// make debugger stepper
		var debugStepper = makeDebugStepper(initialModel, viewOut, eventNode, parentNode, moduleName, popoutRef);

		return function stepper(model)
		{
			appStepper(model);
			overStepper(model);
			debugStepper(model);
		}
	};
}

function makeDebugStepper(initialModel, view, eventNode, parentNode, moduleName, popoutRef)
{
	var curr;
	var domNode;

	return function stepper(model)
	{
		if (!model.isDebuggerOpen)
		{
			return;
		}

		if (!popoutRef.doc)
		{
			curr = view(model);
			domNode = openDebugWindow(moduleName, popoutRef, curr, eventNode);
			return;
		}

		// switch to document of popout
		localDoc = popoutRef.doc;

		var next = view(model);
		var patches = diff(curr, next);
		domNode = applyPatches(domNode, curr, patches, eventNode);
		curr = next;

		// switch back to normal document
		localDoc = document;
	};
}

function openDebugWindow(moduleName, popoutRef, virtualNode, eventNode)
{
	var w = 900;
	var h = 360;
	var x = screen.width - w;
	var y = screen.height - h;
	var debugWindow = window.open('', '', 'width=' + w + ',height=' + h + ',left=' + x + ',top=' + y);

	// switch to window document
	localDoc = debugWindow.document;

	popoutRef.doc = localDoc;
	localDoc.title = 'Debugger - ' + moduleName;
	localDoc.body.style.margin = '0';
	localDoc.body.style.padding = '0';
	var domNode = render(virtualNode, eventNode);
	localDoc.body.appendChild(domNode);

	localDoc.addEventListener('keydown', function(event) {
		if (event.metaKey && event.which === 82)
		{
			window.location.reload();
		}
		if (event.which === 38)
		{
			eventNode.tagger({ ctor: 'Up' });
			event.preventDefault();
		}
		if (event.which === 40)
		{
			eventNode.tagger({ ctor: 'Down' });
			event.preventDefault();
		}
	});

	function close()
	{
		popoutRef.doc = undefined;
		debugWindow.close();
	}
	window.addEventListener('unload', close);
	debugWindow.addEventListener('unload', function() {
		popoutRef.doc = undefined;
		window.removeEventListener('unload', close);
		eventNode.tagger({ ctor: 'Close' });
	});

	// switch back to the normal document
	localDoc = document;

	return domNode;
}


// BLOCK EVENTS

function wrapViewIn(appEventNode, overlayNode, viewIn)
{
	var ignorer = makeIgnorer(overlayNode);
	var blocking = 'Normal';
	var overflow;

	var normalTagger = appEventNode.tagger;
	var blockTagger = function() {};

	return function(model)
	{
		var tuple = viewIn(model);
		var newBlocking = tuple._0.ctor;
		appEventNode.tagger = newBlocking === 'Normal' ? normalTagger : blockTagger;
		if (blocking !== newBlocking)
		{
			traverse('removeEventListener', ignorer, blocking);
			traverse('addEventListener', ignorer, newBlocking);

			if (blocking === 'Normal')
			{
				overflow = document.body.style.overflow;
				document.body.style.overflow = 'hidden';
			}

			if (newBlocking === 'Normal')
			{
				document.body.style.overflow = overflow;
			}

			blocking = newBlocking;
		}
		return tuple._1;
	}
}

function traverse(verbEventListener, ignorer, blocking)
{
	switch(blocking)
	{
		case 'Normal':
			return;

		case 'Pause':
			return traverseHelp(verbEventListener, ignorer, mostEvents);

		case 'Message':
			return traverseHelp(verbEventListener, ignorer, allEvents);
	}
}

function traverseHelp(verbEventListener, handler, eventNames)
{
	for (var i = 0; i < eventNames.length; i++)
	{
		document.body[verbEventListener](eventNames[i], handler, true);
	}
}

function makeIgnorer(overlayNode)
{
	return function(event)
	{
		if (event.type === 'keydown' && event.metaKey && event.which === 82)
		{
			return;
		}

		var isScroll = event.type === 'scroll' || event.type === 'wheel';

		var node = event.target;
		while (node !== null)
		{
			if (node.className === 'elm-overlay-message-details' && isScroll)
			{
				return;
			}

			if (node === overlayNode && !isScroll)
			{
				return;
			}
			node = node.parentNode;
		}

		event.stopPropagation();
		event.preventDefault();
	}
}

var mostEvents = [
	'click', 'dblclick', 'mousemove',
	'mouseup', 'mousedown', 'mouseenter', 'mouseleave',
	'touchstart', 'touchend', 'touchcancel', 'touchmove',
	'pointerdown', 'pointerup', 'pointerover', 'pointerout',
	'pointerenter', 'pointerleave', 'pointermove', 'pointercancel',
	'dragstart', 'drag', 'dragend', 'dragenter', 'dragover', 'dragleave', 'drop',
	'keyup', 'keydown', 'keypress',
	'input', 'change',
	'focus', 'blur'
];

var allEvents = mostEvents.concat('wheel', 'scroll');


return {
	node: node,
	text: text,
	custom: custom,
	map: F2(map),

	on: F3(on),
	style: style,
	property: F2(property),
	attribute: F2(attribute),
	attributeNS: F3(attributeNS),
	mapProperty: F2(mapProperty),

	lazy: F2(lazy),
	lazy2: F3(lazy2),
	lazy3: F4(lazy3),
	keyedNode: F3(keyedNode),

	program: program,
	programWithFlags: programWithFlags,
	staticProgram: staticProgram
};

}();

var _elm_lang$virtual_dom$VirtualDom$programWithFlags = function (impl) {
	return A2(_elm_lang$virtual_dom$Native_VirtualDom.programWithFlags, _elm_lang$virtual_dom$VirtualDom_Debug$wrapWithFlags, impl);
};
var _elm_lang$virtual_dom$VirtualDom$program = function (impl) {
	return A2(_elm_lang$virtual_dom$Native_VirtualDom.program, _elm_lang$virtual_dom$VirtualDom_Debug$wrap, impl);
};
var _elm_lang$virtual_dom$VirtualDom$keyedNode = _elm_lang$virtual_dom$Native_VirtualDom.keyedNode;
var _elm_lang$virtual_dom$VirtualDom$lazy3 = _elm_lang$virtual_dom$Native_VirtualDom.lazy3;
var _elm_lang$virtual_dom$VirtualDom$lazy2 = _elm_lang$virtual_dom$Native_VirtualDom.lazy2;
var _elm_lang$virtual_dom$VirtualDom$lazy = _elm_lang$virtual_dom$Native_VirtualDom.lazy;
var _elm_lang$virtual_dom$VirtualDom$defaultOptions = {stopPropagation: false, preventDefault: false};
var _elm_lang$virtual_dom$VirtualDom$onWithOptions = _elm_lang$virtual_dom$Native_VirtualDom.on;
var _elm_lang$virtual_dom$VirtualDom$on = F2(
	function (eventName, decoder) {
		return A3(_elm_lang$virtual_dom$VirtualDom$onWithOptions, eventName, _elm_lang$virtual_dom$VirtualDom$defaultOptions, decoder);
	});
var _elm_lang$virtual_dom$VirtualDom$style = _elm_lang$virtual_dom$Native_VirtualDom.style;
var _elm_lang$virtual_dom$VirtualDom$mapProperty = _elm_lang$virtual_dom$Native_VirtualDom.mapProperty;
var _elm_lang$virtual_dom$VirtualDom$attributeNS = _elm_lang$virtual_dom$Native_VirtualDom.attributeNS;
var _elm_lang$virtual_dom$VirtualDom$attribute = _elm_lang$virtual_dom$Native_VirtualDom.attribute;
var _elm_lang$virtual_dom$VirtualDom$property = _elm_lang$virtual_dom$Native_VirtualDom.property;
var _elm_lang$virtual_dom$VirtualDom$map = _elm_lang$virtual_dom$Native_VirtualDom.map;
var _elm_lang$virtual_dom$VirtualDom$text = _elm_lang$virtual_dom$Native_VirtualDom.text;
var _elm_lang$virtual_dom$VirtualDom$node = _elm_lang$virtual_dom$Native_VirtualDom.node;
var _elm_lang$virtual_dom$VirtualDom$Options = F2(
	function (a, b) {
		return {stopPropagation: a, preventDefault: b};
	});
var _elm_lang$virtual_dom$VirtualDom$Node = {ctor: 'Node'};
var _elm_lang$virtual_dom$VirtualDom$Property = {ctor: 'Property'};

var _elm_lang$html$Html$programWithFlags = _elm_lang$virtual_dom$VirtualDom$programWithFlags;
var _elm_lang$html$Html$program = _elm_lang$virtual_dom$VirtualDom$program;
var _elm_lang$html$Html$beginnerProgram = function (_p0) {
	var _p1 = _p0;
	return _elm_lang$html$Html$program(
		{
			init: A2(
				_elm_lang$core$Platform_Cmd_ops['!'],
				_p1.model,
				{ctor: '[]'}),
			update: F2(
				function (msg, model) {
					return A2(
						_elm_lang$core$Platform_Cmd_ops['!'],
						A2(_p1.update, msg, model),
						{ctor: '[]'});
				}),
			view: _p1.view,
			subscriptions: function (_p2) {
				return _elm_lang$core$Platform_Sub$none;
			}
		});
};
var _elm_lang$html$Html$map = _elm_lang$virtual_dom$VirtualDom$map;
var _elm_lang$html$Html$text = _elm_lang$virtual_dom$VirtualDom$text;
var _elm_lang$html$Html$node = _elm_lang$virtual_dom$VirtualDom$node;
var _elm_lang$html$Html$body = _elm_lang$html$Html$node('body');
var _elm_lang$html$Html$section = _elm_lang$html$Html$node('section');
var _elm_lang$html$Html$nav = _elm_lang$html$Html$node('nav');
var _elm_lang$html$Html$article = _elm_lang$html$Html$node('article');
var _elm_lang$html$Html$aside = _elm_lang$html$Html$node('aside');
var _elm_lang$html$Html$h1 = _elm_lang$html$Html$node('h1');
var _elm_lang$html$Html$h2 = _elm_lang$html$Html$node('h2');
var _elm_lang$html$Html$h3 = _elm_lang$html$Html$node('h3');
var _elm_lang$html$Html$h4 = _elm_lang$html$Html$node('h4');
var _elm_lang$html$Html$h5 = _elm_lang$html$Html$node('h5');
var _elm_lang$html$Html$h6 = _elm_lang$html$Html$node('h6');
var _elm_lang$html$Html$header = _elm_lang$html$Html$node('header');
var _elm_lang$html$Html$footer = _elm_lang$html$Html$node('footer');
var _elm_lang$html$Html$address = _elm_lang$html$Html$node('address');
var _elm_lang$html$Html$main_ = _elm_lang$html$Html$node('main');
var _elm_lang$html$Html$p = _elm_lang$html$Html$node('p');
var _elm_lang$html$Html$hr = _elm_lang$html$Html$node('hr');
var _elm_lang$html$Html$pre = _elm_lang$html$Html$node('pre');
var _elm_lang$html$Html$blockquote = _elm_lang$html$Html$node('blockquote');
var _elm_lang$html$Html$ol = _elm_lang$html$Html$node('ol');
var _elm_lang$html$Html$ul = _elm_lang$html$Html$node('ul');
var _elm_lang$html$Html$li = _elm_lang$html$Html$node('li');
var _elm_lang$html$Html$dl = _elm_lang$html$Html$node('dl');
var _elm_lang$html$Html$dt = _elm_lang$html$Html$node('dt');
var _elm_lang$html$Html$dd = _elm_lang$html$Html$node('dd');
var _elm_lang$html$Html$figure = _elm_lang$html$Html$node('figure');
var _elm_lang$html$Html$figcaption = _elm_lang$html$Html$node('figcaption');
var _elm_lang$html$Html$div = _elm_lang$html$Html$node('div');
var _elm_lang$html$Html$a = _elm_lang$html$Html$node('a');
var _elm_lang$html$Html$em = _elm_lang$html$Html$node('em');
var _elm_lang$html$Html$strong = _elm_lang$html$Html$node('strong');
var _elm_lang$html$Html$small = _elm_lang$html$Html$node('small');
var _elm_lang$html$Html$s = _elm_lang$html$Html$node('s');
var _elm_lang$html$Html$cite = _elm_lang$html$Html$node('cite');
var _elm_lang$html$Html$q = _elm_lang$html$Html$node('q');
var _elm_lang$html$Html$dfn = _elm_lang$html$Html$node('dfn');
var _elm_lang$html$Html$abbr = _elm_lang$html$Html$node('abbr');
var _elm_lang$html$Html$time = _elm_lang$html$Html$node('time');
var _elm_lang$html$Html$code = _elm_lang$html$Html$node('code');
var _elm_lang$html$Html$var = _elm_lang$html$Html$node('var');
var _elm_lang$html$Html$samp = _elm_lang$html$Html$node('samp');
var _elm_lang$html$Html$kbd = _elm_lang$html$Html$node('kbd');
var _elm_lang$html$Html$sub = _elm_lang$html$Html$node('sub');
var _elm_lang$html$Html$sup = _elm_lang$html$Html$node('sup');
var _elm_lang$html$Html$i = _elm_lang$html$Html$node('i');
var _elm_lang$html$Html$b = _elm_lang$html$Html$node('b');
var _elm_lang$html$Html$u = _elm_lang$html$Html$node('u');
var _elm_lang$html$Html$mark = _elm_lang$html$Html$node('mark');
var _elm_lang$html$Html$ruby = _elm_lang$html$Html$node('ruby');
var _elm_lang$html$Html$rt = _elm_lang$html$Html$node('rt');
var _elm_lang$html$Html$rp = _elm_lang$html$Html$node('rp');
var _elm_lang$html$Html$bdi = _elm_lang$html$Html$node('bdi');
var _elm_lang$html$Html$bdo = _elm_lang$html$Html$node('bdo');
var _elm_lang$html$Html$span = _elm_lang$html$Html$node('span');
var _elm_lang$html$Html$br = _elm_lang$html$Html$node('br');
var _elm_lang$html$Html$wbr = _elm_lang$html$Html$node('wbr');
var _elm_lang$html$Html$ins = _elm_lang$html$Html$node('ins');
var _elm_lang$html$Html$del = _elm_lang$html$Html$node('del');
var _elm_lang$html$Html$img = _elm_lang$html$Html$node('img');
var _elm_lang$html$Html$iframe = _elm_lang$html$Html$node('iframe');
var _elm_lang$html$Html$embed = _elm_lang$html$Html$node('embed');
var _elm_lang$html$Html$object = _elm_lang$html$Html$node('object');
var _elm_lang$html$Html$param = _elm_lang$html$Html$node('param');
var _elm_lang$html$Html$video = _elm_lang$html$Html$node('video');
var _elm_lang$html$Html$audio = _elm_lang$html$Html$node('audio');
var _elm_lang$html$Html$source = _elm_lang$html$Html$node('source');
var _elm_lang$html$Html$track = _elm_lang$html$Html$node('track');
var _elm_lang$html$Html$canvas = _elm_lang$html$Html$node('canvas');
var _elm_lang$html$Html$math = _elm_lang$html$Html$node('math');
var _elm_lang$html$Html$table = _elm_lang$html$Html$node('table');
var _elm_lang$html$Html$caption = _elm_lang$html$Html$node('caption');
var _elm_lang$html$Html$colgroup = _elm_lang$html$Html$node('colgroup');
var _elm_lang$html$Html$col = _elm_lang$html$Html$node('col');
var _elm_lang$html$Html$tbody = _elm_lang$html$Html$node('tbody');
var _elm_lang$html$Html$thead = _elm_lang$html$Html$node('thead');
var _elm_lang$html$Html$tfoot = _elm_lang$html$Html$node('tfoot');
var _elm_lang$html$Html$tr = _elm_lang$html$Html$node('tr');
var _elm_lang$html$Html$td = _elm_lang$html$Html$node('td');
var _elm_lang$html$Html$th = _elm_lang$html$Html$node('th');
var _elm_lang$html$Html$form = _elm_lang$html$Html$node('form');
var _elm_lang$html$Html$fieldset = _elm_lang$html$Html$node('fieldset');
var _elm_lang$html$Html$legend = _elm_lang$html$Html$node('legend');
var _elm_lang$html$Html$label = _elm_lang$html$Html$node('label');
var _elm_lang$html$Html$input = _elm_lang$html$Html$node('input');
var _elm_lang$html$Html$button = _elm_lang$html$Html$node('button');
var _elm_lang$html$Html$select = _elm_lang$html$Html$node('select');
var _elm_lang$html$Html$datalist = _elm_lang$html$Html$node('datalist');
var _elm_lang$html$Html$optgroup = _elm_lang$html$Html$node('optgroup');
var _elm_lang$html$Html$option = _elm_lang$html$Html$node('option');
var _elm_lang$html$Html$textarea = _elm_lang$html$Html$node('textarea');
var _elm_lang$html$Html$keygen = _elm_lang$html$Html$node('keygen');
var _elm_lang$html$Html$output = _elm_lang$html$Html$node('output');
var _elm_lang$html$Html$progress = _elm_lang$html$Html$node('progress');
var _elm_lang$html$Html$meter = _elm_lang$html$Html$node('meter');
var _elm_lang$html$Html$details = _elm_lang$html$Html$node('details');
var _elm_lang$html$Html$summary = _elm_lang$html$Html$node('summary');
var _elm_lang$html$Html$menuitem = _elm_lang$html$Html$node('menuitem');
var _elm_lang$html$Html$menu = _elm_lang$html$Html$node('menu');

var _elm_lang$html$Html_Attributes$map = _elm_lang$virtual_dom$VirtualDom$mapProperty;
var _elm_lang$html$Html_Attributes$attribute = _elm_lang$virtual_dom$VirtualDom$attribute;
var _elm_lang$html$Html_Attributes$contextmenu = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'contextmenu', value);
};
var _elm_lang$html$Html_Attributes$draggable = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'draggable', value);
};
var _elm_lang$html$Html_Attributes$itemprop = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'itemprop', value);
};
var _elm_lang$html$Html_Attributes$tabindex = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'tabIndex',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$charset = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'charset', value);
};
var _elm_lang$html$Html_Attributes$height = function (value) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'height',
		_elm_lang$core$Basics$toString(value));
};
var _elm_lang$html$Html_Attributes$width = function (value) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'width',
		_elm_lang$core$Basics$toString(value));
};
var _elm_lang$html$Html_Attributes$formaction = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'formAction', value);
};
var _elm_lang$html$Html_Attributes$list = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'list', value);
};
var _elm_lang$html$Html_Attributes$minlength = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'minLength',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$maxlength = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'maxlength',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$size = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'size',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$form = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'form', value);
};
var _elm_lang$html$Html_Attributes$cols = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'cols',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$rows = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'rows',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$challenge = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'challenge', value);
};
var _elm_lang$html$Html_Attributes$media = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'media', value);
};
var _elm_lang$html$Html_Attributes$rel = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'rel', value);
};
var _elm_lang$html$Html_Attributes$datetime = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'datetime', value);
};
var _elm_lang$html$Html_Attributes$pubdate = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'pubdate', value);
};
var _elm_lang$html$Html_Attributes$colspan = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'colspan',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$rowspan = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$attribute,
		'rowspan',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$manifest = function (value) {
	return A2(_elm_lang$html$Html_Attributes$attribute, 'manifest', value);
};
var _elm_lang$html$Html_Attributes$property = _elm_lang$virtual_dom$VirtualDom$property;
var _elm_lang$html$Html_Attributes$stringProperty = F2(
	function (name, string) {
		return A2(
			_elm_lang$html$Html_Attributes$property,
			name,
			_elm_lang$core$Json_Encode$string(string));
	});
var _elm_lang$html$Html_Attributes$class = function (name) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'className', name);
};
var _elm_lang$html$Html_Attributes$id = function (name) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'id', name);
};
var _elm_lang$html$Html_Attributes$title = function (name) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'title', name);
};
var _elm_lang$html$Html_Attributes$accesskey = function ($char) {
	return A2(
		_elm_lang$html$Html_Attributes$stringProperty,
		'accessKey',
		_elm_lang$core$String$fromChar($char));
};
var _elm_lang$html$Html_Attributes$dir = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'dir', value);
};
var _elm_lang$html$Html_Attributes$dropzone = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'dropzone', value);
};
var _elm_lang$html$Html_Attributes$lang = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'lang', value);
};
var _elm_lang$html$Html_Attributes$content = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'content', value);
};
var _elm_lang$html$Html_Attributes$httpEquiv = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'httpEquiv', value);
};
var _elm_lang$html$Html_Attributes$language = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'language', value);
};
var _elm_lang$html$Html_Attributes$src = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'src', value);
};
var _elm_lang$html$Html_Attributes$alt = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'alt', value);
};
var _elm_lang$html$Html_Attributes$preload = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'preload', value);
};
var _elm_lang$html$Html_Attributes$poster = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'poster', value);
};
var _elm_lang$html$Html_Attributes$kind = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'kind', value);
};
var _elm_lang$html$Html_Attributes$srclang = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'srclang', value);
};
var _elm_lang$html$Html_Attributes$sandbox = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'sandbox', value);
};
var _elm_lang$html$Html_Attributes$srcdoc = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'srcdoc', value);
};
var _elm_lang$html$Html_Attributes$type_ = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'type', value);
};
var _elm_lang$html$Html_Attributes$value = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'value', value);
};
var _elm_lang$html$Html_Attributes$defaultValue = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'defaultValue', value);
};
var _elm_lang$html$Html_Attributes$placeholder = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'placeholder', value);
};
var _elm_lang$html$Html_Attributes$accept = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'accept', value);
};
var _elm_lang$html$Html_Attributes$acceptCharset = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'acceptCharset', value);
};
var _elm_lang$html$Html_Attributes$action = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'action', value);
};
var _elm_lang$html$Html_Attributes$autocomplete = function (bool) {
	return A2(
		_elm_lang$html$Html_Attributes$stringProperty,
		'autocomplete',
		bool ? 'on' : 'off');
};
var _elm_lang$html$Html_Attributes$enctype = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'enctype', value);
};
var _elm_lang$html$Html_Attributes$method = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'method', value);
};
var _elm_lang$html$Html_Attributes$name = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'name', value);
};
var _elm_lang$html$Html_Attributes$pattern = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'pattern', value);
};
var _elm_lang$html$Html_Attributes$for = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'htmlFor', value);
};
var _elm_lang$html$Html_Attributes$max = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'max', value);
};
var _elm_lang$html$Html_Attributes$min = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'min', value);
};
var _elm_lang$html$Html_Attributes$step = function (n) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'step', n);
};
var _elm_lang$html$Html_Attributes$wrap = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'wrap', value);
};
var _elm_lang$html$Html_Attributes$usemap = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'useMap', value);
};
var _elm_lang$html$Html_Attributes$shape = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'shape', value);
};
var _elm_lang$html$Html_Attributes$coords = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'coords', value);
};
var _elm_lang$html$Html_Attributes$keytype = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'keytype', value);
};
var _elm_lang$html$Html_Attributes$align = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'align', value);
};
var _elm_lang$html$Html_Attributes$cite = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'cite', value);
};
var _elm_lang$html$Html_Attributes$href = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'href', value);
};
var _elm_lang$html$Html_Attributes$target = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'target', value);
};
var _elm_lang$html$Html_Attributes$downloadAs = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'download', value);
};
var _elm_lang$html$Html_Attributes$hreflang = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'hreflang', value);
};
var _elm_lang$html$Html_Attributes$ping = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'ping', value);
};
var _elm_lang$html$Html_Attributes$start = function (n) {
	return A2(
		_elm_lang$html$Html_Attributes$stringProperty,
		'start',
		_elm_lang$core$Basics$toString(n));
};
var _elm_lang$html$Html_Attributes$headers = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'headers', value);
};
var _elm_lang$html$Html_Attributes$scope = function (value) {
	return A2(_elm_lang$html$Html_Attributes$stringProperty, 'scope', value);
};
var _elm_lang$html$Html_Attributes$boolProperty = F2(
	function (name, bool) {
		return A2(
			_elm_lang$html$Html_Attributes$property,
			name,
			_elm_lang$core$Json_Encode$bool(bool));
	});
var _elm_lang$html$Html_Attributes$hidden = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'hidden', bool);
};
var _elm_lang$html$Html_Attributes$contenteditable = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'contentEditable', bool);
};
var _elm_lang$html$Html_Attributes$spellcheck = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'spellcheck', bool);
};
var _elm_lang$html$Html_Attributes$async = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'async', bool);
};
var _elm_lang$html$Html_Attributes$defer = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'defer', bool);
};
var _elm_lang$html$Html_Attributes$scoped = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'scoped', bool);
};
var _elm_lang$html$Html_Attributes$autoplay = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'autoplay', bool);
};
var _elm_lang$html$Html_Attributes$controls = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'controls', bool);
};
var _elm_lang$html$Html_Attributes$loop = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'loop', bool);
};
var _elm_lang$html$Html_Attributes$default = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'default', bool);
};
var _elm_lang$html$Html_Attributes$seamless = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'seamless', bool);
};
var _elm_lang$html$Html_Attributes$checked = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'checked', bool);
};
var _elm_lang$html$Html_Attributes$selected = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'selected', bool);
};
var _elm_lang$html$Html_Attributes$autofocus = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'autofocus', bool);
};
var _elm_lang$html$Html_Attributes$disabled = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'disabled', bool);
};
var _elm_lang$html$Html_Attributes$multiple = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'multiple', bool);
};
var _elm_lang$html$Html_Attributes$novalidate = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'noValidate', bool);
};
var _elm_lang$html$Html_Attributes$readonly = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'readOnly', bool);
};
var _elm_lang$html$Html_Attributes$required = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'required', bool);
};
var _elm_lang$html$Html_Attributes$ismap = function (value) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'isMap', value);
};
var _elm_lang$html$Html_Attributes$download = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'download', bool);
};
var _elm_lang$html$Html_Attributes$reversed = function (bool) {
	return A2(_elm_lang$html$Html_Attributes$boolProperty, 'reversed', bool);
};
var _elm_lang$html$Html_Attributes$classList = function (list) {
	return _elm_lang$html$Html_Attributes$class(
		A2(
			_elm_lang$core$String$join,
			' ',
			A2(
				_elm_lang$core$List$map,
				_elm_lang$core$Tuple$first,
				A2(_elm_lang$core$List$filter, _elm_lang$core$Tuple$second, list))));
};
var _elm_lang$html$Html_Attributes$style = _elm_lang$virtual_dom$VirtualDom$style;

var _elm_lang$html$Html_Events$keyCode = A2(_elm_lang$core$Json_Decode$field, 'keyCode', _elm_lang$core$Json_Decode$int);
var _elm_lang$html$Html_Events$targetChecked = A2(
	_elm_lang$core$Json_Decode$at,
	{
		ctor: '::',
		_0: 'target',
		_1: {
			ctor: '::',
			_0: 'checked',
			_1: {ctor: '[]'}
		}
	},
	_elm_lang$core$Json_Decode$bool);
var _elm_lang$html$Html_Events$targetValue = A2(
	_elm_lang$core$Json_Decode$at,
	{
		ctor: '::',
		_0: 'target',
		_1: {
			ctor: '::',
			_0: 'value',
			_1: {ctor: '[]'}
		}
	},
	_elm_lang$core$Json_Decode$string);
var _elm_lang$html$Html_Events$defaultOptions = _elm_lang$virtual_dom$VirtualDom$defaultOptions;
var _elm_lang$html$Html_Events$onWithOptions = _elm_lang$virtual_dom$VirtualDom$onWithOptions;
var _elm_lang$html$Html_Events$on = _elm_lang$virtual_dom$VirtualDom$on;
var _elm_lang$html$Html_Events$onFocus = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'focus',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onBlur = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'blur',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onSubmitOptions = _elm_lang$core$Native_Utils.update(
	_elm_lang$html$Html_Events$defaultOptions,
	{preventDefault: true});
var _elm_lang$html$Html_Events$onSubmit = function (msg) {
	return A3(
		_elm_lang$html$Html_Events$onWithOptions,
		'submit',
		_elm_lang$html$Html_Events$onSubmitOptions,
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onCheck = function (tagger) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'change',
		A2(_elm_lang$core$Json_Decode$map, tagger, _elm_lang$html$Html_Events$targetChecked));
};
var _elm_lang$html$Html_Events$onInput = function (tagger) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'input',
		A2(_elm_lang$core$Json_Decode$map, tagger, _elm_lang$html$Html_Events$targetValue));
};
var _elm_lang$html$Html_Events$onMouseOut = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'mouseout',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onMouseOver = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'mouseover',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onMouseLeave = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'mouseleave',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onMouseEnter = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'mouseenter',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onMouseUp = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'mouseup',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onMouseDown = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'mousedown',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onDoubleClick = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'dblclick',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$onClick = function (msg) {
	return A2(
		_elm_lang$html$Html_Events$on,
		'click',
		_elm_lang$core$Json_Decode$succeed(msg));
};
var _elm_lang$html$Html_Events$Options = F2(
	function (a, b) {
		return {stopPropagation: a, preventDefault: b};
	});

var _elm_lang$html$Html_Keyed$node = _elm_lang$virtual_dom$VirtualDom$keyedNode;
var _elm_lang$html$Html_Keyed$ol = _elm_lang$html$Html_Keyed$node('ol');
var _elm_lang$html$Html_Keyed$ul = _elm_lang$html$Html_Keyed$node('ul');

var _elm_lang$html$Html_Lazy$lazy3 = _elm_lang$virtual_dom$VirtualDom$lazy3;
var _elm_lang$html$Html_Lazy$lazy2 = _elm_lang$virtual_dom$VirtualDom$lazy2;
var _elm_lang$html$Html_Lazy$lazy = _elm_lang$virtual_dom$VirtualDom$lazy;

var _evancz$elm_todomvc$Todo$infoFooter = A2(
	_elm_lang$html$Html$footer,
	{
		ctor: '::',
		_0: _elm_lang$html$Html_Attributes$class('info'),
		_1: {ctor: '[]'}
	},
	{
		ctor: '::',
		_0: A2(
			_elm_lang$html$Html$p,
			{ctor: '[]'},
			{
				ctor: '::',
				_0: _elm_lang$html$Html$text('Double-click to edit a todo'),
				_1: {ctor: '[]'}
			}),
		_1: {
			ctor: '::',
			_0: A2(
				_elm_lang$html$Html$p,
				{ctor: '[]'},
				{
					ctor: '::',
					_0: _elm_lang$html$Html$text('Written by '),
					_1: {
						ctor: '::',
						_0: A2(
							_elm_lang$html$Html$a,
							{
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$href('https://github.com/evancz'),
								_1: {ctor: '[]'}
							},
							{
								ctor: '::',
								_0: _elm_lang$html$Html$text('Evan Czaplicki'),
								_1: {ctor: '[]'}
							}),
						_1: {ctor: '[]'}
					}
				}),
			_1: {
				ctor: '::',
				_0: A2(
					_elm_lang$html$Html$p,
					{ctor: '[]'},
					{
						ctor: '::',
						_0: _elm_lang$html$Html$text('Part of '),
						_1: {
							ctor: '::',
							_0: A2(
								_elm_lang$html$Html$a,
								{
									ctor: '::',
									_0: _elm_lang$html$Html_Attributes$href('http://todomvc.com'),
									_1: {ctor: '[]'}
								},
								{
									ctor: '::',
									_0: _elm_lang$html$Html$text('TodoMVC'),
									_1: {ctor: '[]'}
								}),
							_1: {ctor: '[]'}
						}
					}),
				_1: {ctor: '[]'}
			}
		}
	});
var _evancz$elm_todomvc$Todo$viewControlsCount = function (entriesLeft) {
	var item_ = _elm_lang$core$Native_Utils.eq(entriesLeft, 1) ? ' item' : ' items';
	return A2(
		_elm_lang$html$Html$span,
		{
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('todo-count'),
			_1: {ctor: '[]'}
		},
		{
			ctor: '::',
			_0: A2(
				_elm_lang$html$Html$strong,
				{ctor: '[]'},
				{
					ctor: '::',
					_0: _elm_lang$html$Html$text(
						_elm_lang$core$Basics$toString(entriesLeft)),
					_1: {ctor: '[]'}
				}),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html$text(
					A2(_elm_lang$core$Basics_ops['++'], item_, ' left')),
				_1: {ctor: '[]'}
			}
		});
};
var _evancz$elm_todomvc$Todo$onEnter = function (msg) {
	var isEnter = function (code) {
		return _elm_lang$core$Native_Utils.eq(code, 13) ? _elm_lang$core$Json_Decode$succeed(msg) : _elm_lang$core$Json_Decode$fail('not ENTER');
	};
	return A2(
		_elm_lang$html$Html_Events$on,
		'keydown',
		A2(_elm_lang$core$Json_Decode$andThen, isEnter, _elm_lang$html$Html_Events$keyCode));
};
var _evancz$elm_todomvc$Todo$newEntry = F2(
	function (desc, id) {
		return {description: desc, completed: false, editing: false, id: id};
	});
var _evancz$elm_todomvc$Todo$emptyModel = {
	entries: {ctor: '[]'},
	visibility: 'All',
	field: '',
	uid: 0
};
var _evancz$elm_todomvc$Todo$init = function (savedModel) {
	return A2(
		_elm_lang$core$Platform_Cmd_ops['!'],
		A2(_elm_lang$core$Maybe$withDefault, _evancz$elm_todomvc$Todo$emptyModel, savedModel),
		{ctor: '[]'});
};
var _evancz$elm_todomvc$Todo$setStorage = _elm_lang$core$Native_Platform.outgoingPort(
	'setStorage',
	function (v) {
		return {
			entries: _elm_lang$core$Native_List.toArray(v.entries).map(
				function (v) {
					return {description: v.description, completed: v.completed, editing: v.editing, id: v.id};
				}),
			field: v.field,
			uid: v.uid,
			visibility: v.visibility
		};
	});
var _evancz$elm_todomvc$Todo$Model = F4(
	function (a, b, c, d) {
		return {entries: a, field: b, uid: c, visibility: d};
	});
var _evancz$elm_todomvc$Todo$Entry = F4(
	function (a, b, c, d) {
		return {description: a, completed: b, editing: c, id: d};
	});
var _evancz$elm_todomvc$Todo$ChangeVisibility = function (a) {
	return {ctor: 'ChangeVisibility', _0: a};
};
var _evancz$elm_todomvc$Todo$visibilitySwap = F3(
	function (uri, visibility, actualVisibility) {
		return A2(
			_elm_lang$html$Html$li,
			{
				ctor: '::',
				_0: _elm_lang$html$Html_Events$onClick(
					_evancz$elm_todomvc$Todo$ChangeVisibility(visibility)),
				_1: {ctor: '[]'}
			},
			{
				ctor: '::',
				_0: A2(
					_elm_lang$html$Html$a,
					{
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$href(uri),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$classList(
								{
									ctor: '::',
									_0: {
										ctor: '_Tuple2',
										_0: 'selected',
										_1: _elm_lang$core$Native_Utils.eq(visibility, actualVisibility)
									},
									_1: {ctor: '[]'}
								}),
							_1: {ctor: '[]'}
						}
					},
					{
						ctor: '::',
						_0: _elm_lang$html$Html$text(visibility),
						_1: {ctor: '[]'}
					}),
				_1: {ctor: '[]'}
			});
	});
var _evancz$elm_todomvc$Todo$viewControlsFilters = function (visibility) {
	return A2(
		_elm_lang$html$Html$ul,
		{
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('filters'),
			_1: {ctor: '[]'}
		},
		{
			ctor: '::',
			_0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, '#/', 'All', visibility),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html$text(' '),
				_1: {
					ctor: '::',
					_0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, '#/active', 'Active', visibility),
					_1: {
						ctor: '::',
						_0: _elm_lang$html$Html$text(' '),
						_1: {
							ctor: '::',
							_0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, '#/completed', 'Completed', visibility),
							_1: {ctor: '[]'}
						}
					}
				}
			}
		});
};
var _evancz$elm_todomvc$Todo$CheckAll = function (a) {
	return {ctor: 'CheckAll', _0: a};
};
var _evancz$elm_todomvc$Todo$Check = F2(
	function (a, b) {
		return {ctor: 'Check', _0: a, _1: b};
	});
var _evancz$elm_todomvc$Todo$DeleteComplete = {ctor: 'DeleteComplete'};
var _evancz$elm_todomvc$Todo$viewControlsClear = function (entriesCompleted) {
	return A2(
		_elm_lang$html$Html$button,
		{
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('clear-completed'),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$hidden(
					_elm_lang$core$Native_Utils.eq(entriesCompleted, 0)),
				_1: {
					ctor: '::',
					_0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$DeleteComplete),
					_1: {ctor: '[]'}
				}
			}
		},
		{
			ctor: '::',
			_0: _elm_lang$html$Html$text(
				A2(
					_elm_lang$core$Basics_ops['++'],
					'Clear completed (',
					A2(
						_elm_lang$core$Basics_ops['++'],
						_elm_lang$core$Basics$toString(entriesCompleted),
						')'))),
			_1: {ctor: '[]'}
		});
};
var _evancz$elm_todomvc$Todo$viewControls = F2(
	function (visibility, entries) {
		var entriesCompleted = _elm_lang$core$List$length(
			A2(
				_elm_lang$core$List$filter,
				function (_) {
					return _.completed;
				},
				entries));
		var entriesLeft = _elm_lang$core$List$length(entries) - entriesCompleted;
		return A2(
			_elm_lang$html$Html$footer,
			{
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$class('footer'),
				_1: {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$hidden(
						_elm_lang$core$List$isEmpty(entries)),
					_1: {ctor: '[]'}
				}
			},
			{
				ctor: '::',
				_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsCount, entriesLeft),
				_1: {
					ctor: '::',
					_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsFilters, visibility),
					_1: {
						ctor: '::',
						_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsClear, entriesCompleted),
						_1: {ctor: '[]'}
					}
				}
			});
	});
var _evancz$elm_todomvc$Todo$Delete = function (a) {
	return {ctor: 'Delete', _0: a};
};
var _evancz$elm_todomvc$Todo$Add = {ctor: 'Add'};
var _evancz$elm_todomvc$Todo$UpdateEntry = F2(
	function (a, b) {
		return {ctor: 'UpdateEntry', _0: a, _1: b};
	});
var _evancz$elm_todomvc$Todo$EditingEntry = F2(
	function (a, b) {
		return {ctor: 'EditingEntry', _0: a, _1: b};
	});
var _evancz$elm_todomvc$Todo$viewEntry = function (todo) {
	return A2(
		_elm_lang$html$Html$li,
		{
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$classList(
				{
					ctor: '::',
					_0: {ctor: '_Tuple2', _0: 'completed', _1: todo.completed},
					_1: {
						ctor: '::',
						_0: {ctor: '_Tuple2', _0: 'editing', _1: todo.editing},
						_1: {ctor: '[]'}
					}
				}),
			_1: {ctor: '[]'}
		},
		{
			ctor: '::',
			_0: A2(
				_elm_lang$html$Html$div,
				{
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$class('view'),
					_1: {ctor: '[]'}
				},
				{
					ctor: '::',
					_0: A2(
						_elm_lang$html$Html$input,
						{
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$class('toggle'),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$type_('checkbox'),
								_1: {
									ctor: '::',
									_0: _elm_lang$html$Html_Attributes$checked(todo.completed),
									_1: {
										ctor: '::',
										_0: _elm_lang$html$Html_Events$onClick(
											A2(_evancz$elm_todomvc$Todo$Check, todo.id, !todo.completed)),
										_1: {ctor: '[]'}
									}
								}
							}
						},
						{ctor: '[]'}),
					_1: {
						ctor: '::',
						_0: A2(
							_elm_lang$html$Html$label,
							{
								ctor: '::',
								_0: _elm_lang$html$Html_Events$onDoubleClick(
									A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, true)),
								_1: {ctor: '[]'}
							},
							{
								ctor: '::',
								_0: _elm_lang$html$Html$text(todo.description),
								_1: {ctor: '[]'}
							}),
						_1: {
							ctor: '::',
							_0: A2(
								_elm_lang$html$Html$button,
								{
									ctor: '::',
									_0: _elm_lang$html$Html_Attributes$class('destroy'),
									_1: {
										ctor: '::',
										_0: _elm_lang$html$Html_Events$onClick(
											_evancz$elm_todomvc$Todo$Delete(todo.id)),
										_1: {ctor: '[]'}
									}
								},
								{ctor: '[]'}),
							_1: {ctor: '[]'}
						}
					}
				}),
			_1: {
				ctor: '::',
				_0: A2(
					_elm_lang$html$Html$input,
					{
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$class('edit'),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$value(todo.description),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$name('title'),
								_1: {
									ctor: '::',
									_0: _elm_lang$html$Html_Attributes$id(
										A2(
											_elm_lang$core$Basics_ops['++'],
											'todo-',
											_elm_lang$core$Basics$toString(todo.id))),
									_1: {
										ctor: '::',
										_0: _elm_lang$html$Html_Events$onInput(
											_evancz$elm_todomvc$Todo$UpdateEntry(todo.id)),
										_1: {
											ctor: '::',
											_0: _elm_lang$html$Html_Events$onBlur(
												A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, false)),
											_1: {
												ctor: '::',
												_0: _evancz$elm_todomvc$Todo$onEnter(
													A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, false)),
												_1: {ctor: '[]'}
											}
										}
									}
								}
							}
						}
					},
					{ctor: '[]'}),
				_1: {ctor: '[]'}
			}
		});
};
var _evancz$elm_todomvc$Todo$viewKeyedEntry = function (todo) {
	return {
		ctor: '_Tuple2',
		_0: _elm_lang$core$Basics$toString(todo.id),
		_1: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewEntry, todo)
	};
};
var _evancz$elm_todomvc$Todo$viewEntries = F2(
	function (visibility, entries) {
		var cssVisibility = _elm_lang$core$List$isEmpty(entries) ? 'hidden' : 'visible';
		var allCompleted = A2(
			_elm_lang$core$List$all,
			function (_) {
				return _.completed;
			},
			entries);
		var isVisible = function (todo) {
			var _p0 = visibility;
			switch (_p0) {
				case 'Completed':
					return todo.completed;
				case 'Active':
					return !todo.completed;
				default:
					return true;
			}
		};
		return A2(
			_elm_lang$html$Html$section,
			{
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$class('main'),
				_1: {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$style(
						{
							ctor: '::',
							_0: {ctor: '_Tuple2', _0: 'visibility', _1: cssVisibility},
							_1: {ctor: '[]'}
						}),
					_1: {ctor: '[]'}
				}
			},
			{
				ctor: '::',
				_0: A2(
					_elm_lang$html$Html$input,
					{
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$class('toggle-all'),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$type_('checkbox'),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$name('toggle'),
								_1: {
									ctor: '::',
									_0: _elm_lang$html$Html_Attributes$checked(allCompleted),
									_1: {
										ctor: '::',
										_0: _elm_lang$html$Html_Events$onClick(
											_evancz$elm_todomvc$Todo$CheckAll(!allCompleted)),
										_1: {ctor: '[]'}
									}
								}
							}
						}
					},
					{ctor: '[]'}),
				_1: {
					ctor: '::',
					_0: A2(
						_elm_lang$html$Html$label,
						{
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$for('toggle-all'),
							_1: {ctor: '[]'}
						},
						{
							ctor: '::',
							_0: _elm_lang$html$Html$text('Mark all as complete'),
							_1: {ctor: '[]'}
						}),
					_1: {
						ctor: '::',
						_0: A2(
							_elm_lang$html$Html_Keyed$ul,
							{
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$class('todo-list'),
								_1: {ctor: '[]'}
							},
							A2(
								_elm_lang$core$List$map,
								_evancz$elm_todomvc$Todo$viewKeyedEntry,
								A2(_elm_lang$core$List$filter, isVisible, entries))),
						_1: {ctor: '[]'}
					}
				}
			});
	});
var _evancz$elm_todomvc$Todo$UpdateField = function (a) {
	return {ctor: 'UpdateField', _0: a};
};
var _evancz$elm_todomvc$Todo$viewInput = function (task) {
	return A2(
		_elm_lang$html$Html$header,
		{
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('header'),
			_1: {ctor: '[]'}
		},
		{
			ctor: '::',
			_0: A2(
				_elm_lang$html$Html$h1,
				{ctor: '[]'},
				{
					ctor: '::',
					_0: _elm_lang$html$Html$text('todos'),
					_1: {ctor: '[]'}
				}),
			_1: {
				ctor: '::',
				_0: A2(
					_elm_lang$html$Html$input,
					{
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$class('new-todo'),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$placeholder('What needs to be done?'),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$autofocus(true),
								_1: {
									ctor: '::',
									_0: _elm_lang$html$Html_Attributes$value(task),
									_1: {
										ctor: '::',
										_0: _elm_lang$html$Html_Attributes$name('newTodo'),
										_1: {
											ctor: '::',
											_0: _elm_lang$html$Html_Events$onInput(_evancz$elm_todomvc$Todo$UpdateField),
											_1: {
												ctor: '::',
												_0: _evancz$elm_todomvc$Todo$onEnter(_evancz$elm_todomvc$Todo$Add),
												_1: {ctor: '[]'}
											}
										}
									}
								}
							}
						}
					},
					{ctor: '[]'}),
				_1: {ctor: '[]'}
			}
		});
};
var _evancz$elm_todomvc$Todo$view = function (model) {
	return A2(
		_elm_lang$html$Html$div,
		{
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('todomvc-wrapper'),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$style(
					{
						ctor: '::',
						_0: {ctor: '_Tuple2', _0: 'visibility', _1: 'hidden'},
						_1: {ctor: '[]'}
					}),
				_1: {ctor: '[]'}
			}
		},
		{
			ctor: '::',
			_0: A2(
				_elm_lang$html$Html$section,
				{
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$class('todoapp'),
					_1: {ctor: '[]'}
				},
				{
					ctor: '::',
					_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewInput, model.field),
					_1: {
						ctor: '::',
						_0: A3(_elm_lang$html$Html_Lazy$lazy2, _evancz$elm_todomvc$Todo$viewEntries, model.visibility, model.entries),
						_1: {
							ctor: '::',
							_0: A3(_elm_lang$html$Html_Lazy$lazy2, _evancz$elm_todomvc$Todo$viewControls, model.visibility, model.entries),
							_1: {ctor: '[]'}
						}
					}
				}),
			_1: {
				ctor: '::',
				_0: _evancz$elm_todomvc$Todo$infoFooter,
				_1: {ctor: '[]'}
			}
		});
};
var _evancz$elm_todomvc$Todo$NoOp = {ctor: 'NoOp'};
var _evancz$elm_todomvc$Todo$update = F2(
	function (msg, model) {
		var _p1 = msg;
		switch (_p1.ctor) {
			case 'NoOp':
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					model,
					{ctor: '[]'});
			case 'Add':
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{
							uid: model.uid + 1,
							field: '',
							entries: _elm_lang$core$String$isEmpty(model.field) ? model.entries : A2(
								_elm_lang$core$Basics_ops['++'],
								model.entries,
								{
									ctor: '::',
									_0: A2(_evancz$elm_todomvc$Todo$newEntry, model.field, model.uid),
									_1: {ctor: '[]'}
								})
						}),
					{ctor: '[]'});
			case 'UpdateField':
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{field: _p1._0}),
					{ctor: '[]'});
			case 'EditingEntry':
				var _p3 = _p1._0;
				var focus = _elm_lang$dom$Dom$focus(
					A2(
						_elm_lang$core$Basics_ops['++'],
						'todo-',
						_elm_lang$core$Basics$toString(_p3)));
				var updateEntry = function (t) {
					return _elm_lang$core$Native_Utils.eq(t.id, _p3) ? _elm_lang$core$Native_Utils.update(
						t,
						{editing: _p1._1}) : t;
				};
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{
							entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
						}),
					{
						ctor: '::',
						_0: A2(
							_elm_lang$core$Task$attempt,
							function (_p2) {
								return _evancz$elm_todomvc$Todo$NoOp;
							},
							focus),
						_1: {ctor: '[]'}
					});
			case 'UpdateEntry':
				var updateEntry = function (t) {
					return _elm_lang$core$Native_Utils.eq(t.id, _p1._0) ? _elm_lang$core$Native_Utils.update(
						t,
						{description: _p1._1}) : t;
				};
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{
							entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
						}),
					{ctor: '[]'});
			case 'Delete':
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{
							entries: A2(
								_elm_lang$core$List$filter,
								function (t) {
									return !_elm_lang$core$Native_Utils.eq(t.id, _p1._0);
								},
								model.entries)
						}),
					{ctor: '[]'});
			case 'DeleteComplete':
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{
							entries: A2(
								_elm_lang$core$List$filter,
								function (_p4) {
									return !function (_) {
										return _.completed;
									}(_p4);
								},
								model.entries)
						}),
					{ctor: '[]'});
			case 'Check':
				var updateEntry = function (t) {
					return _elm_lang$core$Native_Utils.eq(t.id, _p1._0) ? _elm_lang$core$Native_Utils.update(
						t,
						{completed: _p1._1}) : t;
				};
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{
							entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
						}),
					{ctor: '[]'});
			case 'CheckAll':
				var updateEntry = function (t) {
					return _elm_lang$core$Native_Utils.update(
						t,
						{completed: _p1._0});
				};
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{
							entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
						}),
					{ctor: '[]'});
			default:
				return A2(
					_elm_lang$core$Platform_Cmd_ops['!'],
					_elm_lang$core$Native_Utils.update(
						model,
						{visibility: _p1._0}),
					{ctor: '[]'});
		}
	});
var _evancz$elm_todomvc$Todo$updateWithStorage = F2(
	function (msg, model) {
		var _p5 = A2(_evancz$elm_todomvc$Todo$update, msg, model);
		var newModel = _p5._0;
		var cmds = _p5._1;
		return {
			ctor: '_Tuple2',
			_0: newModel,
			_1: _elm_lang$core$Platform_Cmd$batch(
				{
					ctor: '::',
					_0: _evancz$elm_todomvc$Todo$setStorage(newModel),
					_1: {
						ctor: '::',
						_0: cmds,
						_1: {ctor: '[]'}
					}
				})
		};
	});
var _evancz$elm_todomvc$Todo$main = _elm_lang$html$Html$programWithFlags(
	{
		init: _evancz$elm_todomvc$Todo$init,
		view: _evancz$elm_todomvc$Todo$view,
		update: _evancz$elm_todomvc$Todo$updateWithStorage,
		subscriptions: function (_p6) {
			return _elm_lang$core$Platform_Sub$none;
		}
	})(
	_elm_lang$core$Json_Decode$oneOf(
		{
			ctor: '::',
			_0: _elm_lang$core$Json_Decode$null(_elm_lang$core$Maybe$Nothing),
			_1: {
				ctor: '::',
				_0: A2(
					_elm_lang$core$Json_Decode$map,
					_elm_lang$core$Maybe$Just,
					A2(
						_elm_lang$core$Json_Decode$andThen,
						function (entries) {
							return A2(
								_elm_lang$core$Json_Decode$andThen,
								function (field) {
									return A2(
										_elm_lang$core$Json_Decode$andThen,
										function (uid) {
											return A2(
												_elm_lang$core$Json_Decode$andThen,
												function (visibility) {
													return _elm_lang$core$Json_Decode$succeed(
														{entries: entries, field: field, uid: uid, visibility: visibility});
												},
												A2(_elm_lang$core$Json_Decode$field, 'visibility', _elm_lang$core$Json_Decode$string));
										},
										A2(_elm_lang$core$Json_Decode$field, 'uid', _elm_lang$core$Json_Decode$int));
								},
								A2(_elm_lang$core$Json_Decode$field, 'field', _elm_lang$core$Json_Decode$string));
						},
						A2(
							_elm_lang$core$Json_Decode$field,
							'entries',
							_elm_lang$core$Json_Decode$list(
								A2(
									_elm_lang$core$Json_Decode$andThen,
									function (completed) {
										return A2(
											_elm_lang$core$Json_Decode$andThen,
											function (description) {
												return A2(
													_elm_lang$core$Json_Decode$andThen,
													function (editing) {
														return A2(
															_elm_lang$core$Json_Decode$andThen,
															function (id) {
																return _elm_lang$core$Json_Decode$succeed(
																	{completed: completed, description: description, editing: editing, id: id});
															},
															A2(_elm_lang$core$Json_Decode$field, 'id', _elm_lang$core$Json_Decode$int));
													},
													A2(_elm_lang$core$Json_Decode$field, 'editing', _elm_lang$core$Json_Decode$bool));
											},
											A2(_elm_lang$core$Json_Decode$field, 'description', _elm_lang$core$Json_Decode$string));
									},
									A2(_elm_lang$core$Json_Decode$field, 'completed', _elm_lang$core$Json_Decode$bool)))))),
				_1: {ctor: '[]'}
			}
		}));

var Elm = {};
Elm['Todo'] = Elm['Todo'] || {};
if (typeof _evancz$elm_todomvc$Todo$main !== 'undefined') {
    _evancz$elm_todomvc$Todo$main(Elm['Todo'], 'Todo', undefined);
}

if (typeof define === "function" && define['amd'])
{
  define([], function() { return Elm; });
  return;
}

if (typeof module === "object")
{
  module['exports'] = Elm;
  return;
}

var globalElm = this['Elm'];
if (typeof globalElm === "undefined")
{
  this['Elm'] = Elm;
  return;
}

for (var publicModule in Elm)
{
  if (publicModule in globalElm)
  {
    throw new Error('There are two Elm modules called `' + publicModule + '` on this page! Rename one of them.');
  }
  globalElm[publicModule] = Elm[publicModule];
}

}).call(this);

prepared.js

(function () {
	'use strict';

	function F2(fun) {
		function wrapper(a) {
			return function (b) {
				return fun(a, b);
			};
		}
		wrapper.arity = 2;
		wrapper.func = fun;
		return wrapper;
	}

	function F3(fun) {
		function wrapper(a) {
			return function (b) {
				return function (c) {
					return fun(a, b, c);
				};
			};
		}
		wrapper.arity = 3;
		wrapper.func = fun;
		return wrapper;
	}

	function F4(fun) {
		function wrapper(a) {
			return function (b) {
				return function (c) {
					return function (d) {
						return fun(a, b, c, d);
					};
				};
			};
		}
		wrapper.arity = 4;
		wrapper.func = fun;
		return wrapper;
	}

	function F5(fun) {
		function wrapper(a) {
			return function (b) {
				return function (c) {
					return function (d) {
						return function (e) {
							return fun(a, b, c, d, e);
						};
					};
				};
			};
		}
		wrapper.arity = 5;
		wrapper.func = fun;
		return wrapper;
	}

	function F6(fun) {
		function wrapper(a) {
			return function (b) {
				return function (c) {
					return function (d) {
						return function (e) {
							return function (f) {
								return fun(a, b, c, d, e, f);
							};
						};
					};
				};
			};
		}
		wrapper.arity = 6;
		wrapper.func = fun;
		return wrapper;
	}

	function F7(fun) {
		function wrapper(a) {
			return function (b) {
				return function (c) {
					return function (d) {
						return function (e) {
							return function (f) {
								return function (g) {
									return fun(a, b, c, d, e, f, g);
								};
							};
						};
					};
				};
			};
		}
		wrapper.arity = 7;
		wrapper.func = fun;
		return wrapper;
	}

	function F8(fun) {
		function wrapper(a) {
			return function (b) {
				return function (c) {
					return function (d) {
						return function (e) {
							return function (f) {
								return function (g) {
									return function (h) {
										return fun(a, b, c, d, e, f, g, h);
									};
								};
							};
						};
					};
				};
			};
		}
		wrapper.arity = 8;
		wrapper.func = fun;
		return wrapper;
	}

	function F9(fun) {
		function wrapper(a) {
			return function (b) {
				return function (c) {
					return function (d) {
						return function (e) {
							return function (f) {
								return function (g) {
									return function (h) {
										return function (i) {
											return fun(a, b, c, d, e, f, g, h, i);
										};
									};
								};
							};
						};
					};
				};
			};
		}
		wrapper.arity = 9;
		wrapper.func = fun;
		return wrapper;
	}

	function A2(fun, a, b) {
		return fun.arity === 2 ? fun.func(a, b) : fun(a)(b);
	}
	function A3(fun, a, b, c) {
		return fun.arity === 3 ? fun.func(a, b, c) : fun(a)(b)(c);
	}
	function A4(fun, a, b, c, d) {
		return fun.arity === 4 ? fun.func(a, b, c, d) : fun(a)(b)(c)(d);
	}
	function A5(fun, a, b, c, d, e) {
		return fun.arity === 5 ? fun.func(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
	}
	function A6(fun, a, b, c, d, e, f) {
		return fun.arity === 6 ? fun.func(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
	}
	function A7(fun, a, b, c, d, e, f, g) {
		return fun.arity === 7 ? fun.func(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
	}
	function A8(fun, a, b, c, d, e, f, g, h) {
		return fun.arity === 8 ? fun.func(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
	}
	function A9(fun, a, b, c, d, e, f, g, h, i) {
		return fun.arity === 9 ? fun.func(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
	}

	//import Native.List //

	var _elm_lang$core$Native_Array = {},
	    _elm_lang$core$Native_Array$iife_private$M = 32,
	    _elm_lang$core$Native_Array$iife_private$E = 2,
	    _elm_lang$core$Native_Array$iife_private$empty = {
		ctor: '_Array',
		height: 0,
		table: []
	},
	    _elm_lang$core$Native_Array$iife_public$empty = _elm_lang$core$Native_Array$iife_private$empty,
	    _elm_lang$core$Native_Array$iife_public$fromList = _elm_lang$core$Native_Array$iife_private$fromList,
	    _elm_lang$core$Native_Array$iife_public$toList = _elm_lang$core$Native_Array$iife_private$toList,
	    _elm_lang$core$Native_Array$iife_public$initialize = /*#__PURE__*/F2(_elm_lang$core$Native_Array$iife_private$initialize),
	    _elm_lang$core$Native_Array$iife_public$append = /*#__PURE__*/F2(_elm_lang$core$Native_Array$iife_private$append),
	    _elm_lang$core$Native_Array$iife_public$push = /*#__PURE__*/F2(_elm_lang$core$Native_Array$iife_private$push),
	    _elm_lang$core$Native_Array$iife_public$slice = /*#__PURE__*/F3(_elm_lang$core$Native_Array$iife_private$slice),
	    _elm_lang$core$Native_Array$iife_public$get = /*#__PURE__*/F2(_elm_lang$core$Native_Array$iife_private$get),
	    _elm_lang$core$Native_Array$iife_public$set = /*#__PURE__*/F3(_elm_lang$core$Native_Array$iife_private$set),
	    _elm_lang$core$Native_Array$iife_public$map = /*#__PURE__*/F2(_elm_lang$core$Native_Array$iife_private$map),
	    _elm_lang$core$Native_Array$iife_public$indexedMap = /*#__PURE__*/F2(_elm_lang$core$Native_Array$iife_private$indexedMap),
	    _elm_lang$core$Native_Array$iife_public$foldl = /*#__PURE__*/F3(_elm_lang$core$Native_Array$iife_private$foldl),
	    _elm_lang$core$Native_Array$iife_public$foldr = /*#__PURE__*/F3(_elm_lang$core$Native_Array$iife_private$foldr),
	    _elm_lang$core$Native_Array$iife_public$length = _elm_lang$core$Native_Array$iife_private$length,
	    _elm_lang$core$Native_Array$iife_public$toJSArray = _elm_lang$core$Native_Array$iife_private$toJSArray,
	    _elm_lang$core$Native_Array$iife_public$fromJSArray = _elm_lang$core$Native_Array$iife_private$fromJSArray;
	//import Native.Utils //

	function _elm_lang$core$Native_Array$iife_private$fromJSArray_(jsArray, h, from, to) {
		if (h === 0) {
			return {
				ctor: '_Array',
				height: 0,
				table: jsArray.slice(from, to)
			};
		}

		var step = Math.pow(_elm_lang$core$Native_Array$iife_private$M, h);
		var table = new Array(Math.ceil((to - from) / step));
		var lengths = new Array(table.length);
		for (var i = 0; i < table.length; i++) {
			table[i] = _elm_lang$core$Native_Array$iife_private$fromJSArray_(jsArray, h - 1, from + i * step, Math.min(from + (i + 1) * step, to));
			lengths[i] = _elm_lang$core$Native_Array$iife_private$length(table[i]) + (i > 0 ? lengths[i - 1] : 0);
		}
		return {
			ctor: '_Array',
			height: h,
			table: table,
			lengths: lengths
		};
	}

	function _elm_lang$core$Native_Array$iife_private$fromJSArray(jsArray) {
		if (jsArray.length === 0) {
			return _elm_lang$core$Native_Array$iife_private$empty;
		}
		var h = Math.floor(Math.log(jsArray.length) / Math.log(_elm_lang$core$Native_Array$iife_private$M));
		return _elm_lang$core$Native_Array$iife_private$fromJSArray_(jsArray, h, 0, jsArray.length);
	}

	function _elm_lang$core$Native_Array$iife_private$toJSArray_(jsArray, i, a) {
		for (var t = 0; t < a.table.length; t++) {
			if (a.height === 0) {
				jsArray[i + t] = a.table[t];
			} else {
				var inc = t === 0 ? 0 : a.lengths[t - 1];
				_elm_lang$core$Native_Array$iife_private$toJSArray_(jsArray, i + inc, a.table[t]);
			}
		}
	}

	function _elm_lang$core$Native_Array$iife_private$toJSArray(a) {
		var jsArray = new Array(_elm_lang$core$Native_Array$iife_private$length(a));
		_elm_lang$core$Native_Array$iife_private$toJSArray_(jsArray, 0, a);
		return jsArray;
	}

	// Emphasizes blood brotherhood beneath two trees.
	function _elm_lang$core$Native_Array$iife_private$siblise(a, b) {
		return {
			ctor: '_Array',
			height: a.height + 1,
			table: [a, b],
			lengths: [_elm_lang$core$Native_Array$iife_private$length(a), _elm_lang$core$Native_Array$iife_private$length(a) + _elm_lang$core$Native_Array$iife_private$length(b)]
		};
	}

	// Recursively creates a tree that contains the given tree.
	function _elm_lang$core$Native_Array$iife_private$parentise(tree, h) {
		if (h === tree.height) {
			return tree;
		}

		return {
			ctor: '_Array',
			height: h,
			table: [_elm_lang$core$Native_Array$iife_private$parentise(tree, h - 1)],
			lengths: [_elm_lang$core$Native_Array$iife_private$length(tree)]
		};
	}

	// Recursively creates a tree with a given height containing
	// only the given item.
	function _elm_lang$core$Native_Array$iife_private$create(item, h) {
		if (h === 0) {
			return {
				ctor: '_Array',
				height: 0,
				table: [item]
			};
		}
		return {
			ctor: '_Array',
			height: h,
			table: [_elm_lang$core$Native_Array$iife_private$create(item, h - 1)],
			lengths: [1]
		};
	}

	// Calculates in which slot of "table" the item probably is, then
	// find the exact slot via forward searching in  "lengths". Returns the index.
	function _elm_lang$core$Native_Array$iife_private$getSlot(i, a) {
		var slot = i >> 5 * a.height;
		while (a.lengths[slot] <= i) {
			slot++;
		}
		return slot;
	}

	// Returns how many items are in the tree.
	function _elm_lang$core$Native_Array$iife_private$length(array) {
		if (array.height === 0) {
			return array.table.length;
		} else {
			return array.lengths[array.lengths.length - 1];
		}
	}

	// Copies a node for updating. Note that you should not use this if
	// only updating only one of "table" or "lengths" for performance reasons.
	function _elm_lang$core$Native_Array$iife_private$nodeCopy(a) {
		var newA = {
			ctor: '_Array',
			height: a.height,
			table: a.table.slice()
		};
		if (a.height > 0) {
			newA.lengths = a.lengths.slice();
		}
		return newA;
	}
	function _elm_lang$core$Native_Array$iife_private$botLeft(a) {
		return a.table[0];
	}

	// Navigation functions
	function _elm_lang$core$Native_Array$iife_private$botRight(a) {
		return a.table[a.table.length - 1];
	}

	// Returns an array of two balanced nodes.
	function _elm_lang$core$Native_Array$iife_private$shuffle(a, b, toRemove) {
		var newA = _elm_lang$core$Native_Array$iife_private$createNode(a.height, Math.min(_elm_lang$core$Native_Array$iife_private$M, a.table.length + b.table.length - toRemove));
		var newB = _elm_lang$core$Native_Array$iife_private$createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove));

		// Skip the slots with size M. More precise: copy the slot references
		// to the new node
		var read = 0;
		while (_elm_lang$core$Native_Array$iife_private$get2(a.table, b.table, read).table.length % _elm_lang$core$Native_Array$iife_private$M === 0) {
			_elm_lang$core$Native_Array$iife_private$set2(newA.table, newB.table, read, _elm_lang$core$Native_Array$iife_private$get2(a.table, b.table, read));
			_elm_lang$core$Native_Array$iife_private$set2(newA.lengths, newB.lengths, read, _elm_lang$core$Native_Array$iife_private$get2(a.lengths, b.lengths, read));
			read++;
		}

		// Pulling items from left to right, caching in a slot before writing
		// it into the new nodes.
		var write = read;
		var slot = new _elm_lang$core$Native_Array$iife_private$createNode(a.height - 1, 0);
		var from = 0;

		// If the current slot is still containing data, then there will be at
		// least one more write, so we do not break this loop yet.
		while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove) {
			// Find out the max possible items for copying.
			var source = _elm_lang$core$Native_Array$iife_private$get2(a.table, b.table, read);
			var to = Math.min(_elm_lang$core$Native_Array$iife_private$M - slot.table.length, source.table.length);

			// Copy and adjust size table.
			slot.table = slot.table.concat(source.table.slice(from, to));
			if (slot.height > 0) {
				var len = slot.lengths.length;
				for (var i = len; i < len + to - from; i++) {
					slot.lengths[i] = _elm_lang$core$Native_Array$iife_private$length(slot.table[i]);
					slot.lengths[i] += i > 0 ? slot.lengths[i - 1] : 0;
				}
			}

			from += to;

			// Only proceed to next slots[i] if the current one was
			// fully copied.
			if (source.table.length <= to) {
				read++;from = 0;
			}

			// Only create a new slot if the current one is filled up.
			if (slot.table.length === _elm_lang$core$Native_Array$iife_private$M) {
				_elm_lang$core$Native_Array$iife_private$saveSlot(newA, newB, write, slot);
				slot = _elm_lang$core$Native_Array$iife_private$createNode(a.height - 1, 0);
				write++;
			}
		}

		// Cleanup after the loop. Copy the last slot into the new nodes.
		if (slot.table.length > 0) {
			_elm_lang$core$Native_Array$iife_private$saveSlot(newA, newB, write, slot);
			write++;
		}

		// Shift the untouched slots to the left
		while (read < a.table.length + b.table.length) {
			_elm_lang$core$Native_Array$iife_private$saveSlot(newA, newB, write, _elm_lang$core$Native_Array$iife_private$get2(a.table, b.table, read));
			read++;
			write++;
		}

		return [newA, newB];
	}

	// Creates a node or leaf with a given length at their arrays for perfomance.
	// Is only used by shuffle.
	function _elm_lang$core$Native_Array$iife_private$createNode(h, length) {
		if (length < 0) {
			length = 0;
		}
		var a = {
			ctor: '_Array',
			height: h,
			table: new Array(length)
		};
		if (h > 0) {
			a.lengths = new Array(length);
		}
		return a;
	}

	function _elm_lang$core$Native_Array$iife_private$saveSlot(a, b, index, slot) {
		_elm_lang$core$Native_Array$iife_private$set2(a.table, b.table, index, slot);

		var l = index === 0 || index === a.lengths.length ? 0 : _elm_lang$core$Native_Array$iife_private$get2(a.lengths, a.lengths, index - 1);

		_elm_lang$core$Native_Array$iife_private$set2(a.lengths, b.lengths, index, l + _elm_lang$core$Native_Array$iife_private$length(slot));
	}

	function _elm_lang$core$Native_Array$iife_private$set2(a, b, index, value) {
		if (index < a.length) {
			a[index] = value;
		} else {
			b[index - a.length] = value;
		}
	}

	// get2, set2 and saveSlot are helpers for accessing elements over two arrays.
	function _elm_lang$core$Native_Array$iife_private$get2(a, b, index) {
		return index < a.length ? a[index] : b[index - a.length];
	}

	// Returns the extra search steps for E. Refer to the paper.
	function _elm_lang$core$Native_Array$iife_private$calcToRemove(a, b) {
		var subLengths = 0;
		for (var i = 0; i < a.table.length; i++) {
			subLengths += a.table[i].table.length;
		}
		for (var i = 0; i < b.table.length; i++) {
			subLengths += b.table[i].table.length;
		}

		var toRemove = a.table.length + b.table.length;
		return toRemove - (Math.floor((subLengths - 1) / _elm_lang$core$Native_Array$iife_private$M) + 1);
	}

	function _elm_lang$core$Native_Array$iife_private$insertLeft(parent, node) {
		if (node.table.length > 0) {
			parent.table[0] = node;
			parent.lengths[0] = _elm_lang$core$Native_Array$iife_private$length(node);

			var len = _elm_lang$core$Native_Array$iife_private$length(parent.table[0]);
			for (var i = 1; i < parent.lengths.length; i++) {
				len += _elm_lang$core$Native_Array$iife_private$length(parent.table[i]);
				parent.lengths[i] = len;
			}
		} else {
			parent.table.shift();
			for (var i = 1; i < parent.lengths.length; i++) {
				parent.lengths[i] = parent.lengths[i] - parent.lengths[0];
			}
			parent.lengths.shift();
		}
	}

	// Helperfunctions for append_. Replaces a child node at the side of the parent.
	function _elm_lang$core$Native_Array$iife_private$insertRight(parent, node) {
		var index = parent.table.length - 1;
		parent.table[index] = node;
		parent.lengths[index] = _elm_lang$core$Native_Array$iife_private$length(node);
		parent.lengths[index] += index > 0 ? parent.lengths[index - 1] : 0;
	}

	// Returns an array of two nodes; right and left. One node _may_ be empty.
	function _elm_lang$core$Native_Array$iife_private$append_(a, b) {
		if (a.height === 0 && b.height === 0) {
			return [a, b];
		}

		if (a.height !== 1 || b.height !== 1) {
			if (a.height === b.height) {
				a = _elm_lang$core$Native_Array$iife_private$nodeCopy(a);
				b = _elm_lang$core$Native_Array$iife_private$nodeCopy(b);
				var appended = _elm_lang$core$Native_Array$iife_private$append_(_elm_lang$core$Native_Array$iife_private$botRight(a), _elm_lang$core$Native_Array$iife_private$botLeft(b));

				_elm_lang$core$Native_Array$iife_private$insertRight(a, appended[1]);
				_elm_lang$core$Native_Array$iife_private$insertLeft(b, appended[0]);
			} else if (a.height > b.height) {
				a = _elm_lang$core$Native_Array$iife_private$nodeCopy(a);
				var appended = _elm_lang$core$Native_Array$iife_private$append_(_elm_lang$core$Native_Array$iife_private$botRight(a), b);

				_elm_lang$core$Native_Array$iife_private$insertRight(a, appended[0]);
				b = _elm_lang$core$Native_Array$iife_private$parentise(appended[1], appended[1].height + 1);
			} else {
				b = _elm_lang$core$Native_Array$iife_private$nodeCopy(b);
				var appended = _elm_lang$core$Native_Array$iife_private$append_(a, _elm_lang$core$Native_Array$iife_private$botLeft(b));

				var left = appended[0].table.length === 0 ? 0 : 1;
				var right = left === 0 ? 1 : 0;
				_elm_lang$core$Native_Array$iife_private$insertLeft(b, appended[left]);
				a = _elm_lang$core$Native_Array$iife_private$parentise(appended[right], appended[right].height + 1);
			}
		}

		// Check if balancing is needed and return based on that.
		if (a.table.length === 0 || b.table.length === 0) {
			return [a, b];
		}

		var toRemove = _elm_lang$core$Native_Array$iife_private$calcToRemove(a, b);
		if (toRemove <= _elm_lang$core$Native_Array$iife_private$E) {
			return [a, b];
		}
		return _elm_lang$core$Native_Array$iife_private$shuffle(a, b, toRemove);
	}

	// Appends two trees.
	function _elm_lang$core$Native_Array$iife_private$append(a, b) {
		if (a.table.length === 0) {
			return b;
		}
		if (b.table.length === 0) {
			return a;
		}

		var c = _elm_lang$core$Native_Array$iife_private$append_(a, b);

		// Check if both nodes can be crunshed together.
		if (c[0].table.length + c[1].table.length <= _elm_lang$core$Native_Array$iife_private$M) {
			if (c[0].table.length === 0) {
				return c[1];
			}
			if (c[1].table.length === 0) {
				return c[0];
			}

			// Adjust .table and .lengths
			c[0].table = c[0].table.concat(c[1].table);
			if (c[0].height > 0) {
				var len = _elm_lang$core$Native_Array$iife_private$length(c[0]);
				for (var i = 0; i < c[1].lengths.length; i++) {
					c[1].lengths[i] += len;
				}
				c[0].lengths = c[0].lengths.concat(c[1].lengths);
			}

			return c[0];
		}

		if (c[0].height > 0) {
			var toRemove = _elm_lang$core$Native_Array$iife_private$calcToRemove(a, b);
			if (toRemove > _elm_lang$core$Native_Array$iife_private$E) {
				c = _elm_lang$core$Native_Array$iife_private$shuffle(c[0], c[1], toRemove);
			}
		}

		return _elm_lang$core$Native_Array$iife_private$siblise(c[0], c[1]);
	}

	function _elm_lang$core$Native_Array$iife_private$sliceLeft(from, a) {
		if (from === 0) {
			return a;
		}

		// Handle leaf level.
		if (a.height === 0) {
			var newA = { ctor: '_Array', height: 0 };
			newA.table = a.table.slice(from, a.table.length + 1);
			return newA;
		}

		// Slice the left recursively.
		var left = _elm_lang$core$Native_Array$iife_private$getSlot(from, a);
		var sliced = _elm_lang$core$Native_Array$iife_private$sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]);

		// Maybe the a node is not even needed, as sliced contains the whole slice.
		if (left === a.table.length - 1) {
			return sliced;
		}

		// Create new node.
		var newA = {
			ctor: '_Array',
			height: a.height,
			table: a.table.slice(left, a.table.length + 1),
			lengths: new Array(a.table.length - left)
		};
		newA.table[0] = sliced;
		var len = 0;
		for (var i = 0; i < newA.table.length; i++) {
			len += _elm_lang$core$Native_Array$iife_private$length(newA.table[i]);
			newA.lengths[i] = len;
		}

		return newA;
	}

	function _elm_lang$core$Native_Array$iife_private$sliceRight(to, a) {
		if (to === _elm_lang$core$Native_Array$iife_private$length(a)) {
			return a;
		}

		// Handle leaf level.
		if (a.height === 0) {
			var newA = { ctor: '_Array', height: 0 };
			newA.table = a.table.slice(0, to);
			return newA;
		}

		// Slice the right recursively.
		var right = _elm_lang$core$Native_Array$iife_private$getSlot(to, a);
		var sliced = _elm_lang$core$Native_Array$iife_private$sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]);

		// Maybe the a node is not even needed, as sliced contains the whole slice.
		if (right === 0) {
			return sliced;
		}

		// Create new node.
		var newA = {
			ctor: '_Array',
			height: a.height,
			table: a.table.slice(0, right),
			lengths: a.lengths.slice(0, right)
		};
		if (sliced.table.length > 0) {
			newA.table[right] = sliced;
			newA.lengths[right] = _elm_lang$core$Native_Array$iife_private$length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0);
		}
		return newA;
	}

	// TODO: currently, it slices the right, then the left. This can be
	// optimized.
	function _elm_lang$core$Native_Array$iife_private$slice(from, to, a) {
		if (from < 0) {
			from += _elm_lang$core$Native_Array$iife_private$length(a);
		}
		if (to < 0) {
			to += _elm_lang$core$Native_Array$iife_private$length(a);
		}
		return _elm_lang$core$Native_Array$iife_private$sliceLeft(from, _elm_lang$core$Native_Array$iife_private$sliceRight(to, a));
	}

	function _elm_lang$core$Native_Array$iife_private$foldr(f, b, a) {
		if (a.height === 0) {
			for (var i = a.table.length; i--;) {
				b = A2(f, a.table[i], b);
			}
		} else {
			for (var i = a.table.length; i--;) {
				b = _elm_lang$core$Native_Array$iife_private$foldr(f, b, a.table[i]);
			}
		}
		return b;
	}

	function _elm_lang$core$Native_Array$iife_private$foldl(f, b, a) {
		if (a.height === 0) {
			for (var i = 0; i < a.table.length; i++) {
				b = A2(f, a.table[i], b);
			}
		} else {
			for (var i = 0; i < a.table.length; i++) {
				b = _elm_lang$core$Native_Array$iife_private$foldl(f, b, a.table[i]);
			}
		}
		return b;
	}

	function _elm_lang$core$Native_Array$iife_private$indexedMap_(f, a, from) {
		var newA = {
			ctor: '_Array',
			height: a.height,
			table: new Array(a.table.length)
		};
		if (a.height > 0) {
			newA.lengths = a.lengths;
		}
		for (var i = 0; i < a.table.length; i++) {
			newA.table[i] = a.height === 0 ? A2(f, from + i, a.table[i]) : _elm_lang$core$Native_Array$iife_private$indexedMap_(f, a.table[i], i == 0 ? from : from + a.lengths[i - 1]);
		}
		return newA;
	}

	// Maps a function over the elements with their index as first argument.
	function _elm_lang$core$Native_Array$iife_private$indexedMap(f, a) {
		return _elm_lang$core$Native_Array$iife_private$indexedMap_(f, a, 0);
	}

	// Maps a function over the elements of an array.
	function _elm_lang$core$Native_Array$iife_private$map(f, a) {
		var newA = {
			ctor: '_Array',
			height: a.height,
			table: new Array(a.table.length)
		};
		if (a.height > 0) {
			newA.lengths = a.lengths;
		}
		for (var i = 0; i < a.table.length; i++) {
			newA.table[i] = a.height === 0 ? f(a.table[i]) : _elm_lang$core$Native_Array$iife_private$map(f, a.table[i]);
		}
		return newA;
	}

	function _elm_lang$core$Native_Array$iife_private$toList_(list, a) {
		for (var i = a.table.length - 1; i >= 0; i--) {
			list = a.height === 0 ? _elm_lang$core$Native_List$iife_public$Cons(a.table[i], list) : _elm_lang$core$Native_Array$iife_private$toList_(list, a.table[i]);
		}
		return list;
	}

	// Converts an array into a list of elements.
	function _elm_lang$core$Native_Array$iife_private$toList(a) {
		return _elm_lang$core$Native_Array$iife_private$toList_(_elm_lang$core$Native_List$iife_public$Nil, a);
	}

	// Recursively tries to push an item to the bottom-right most
	// tree possible. If there is no space left for the item,
	// null will be returned.
	function _elm_lang$core$Native_Array$iife_private$push_(item, a) {
		// Handle resursion stop at leaf level.
		if (a.height === 0) {
			if (a.table.length < _elm_lang$core$Native_Array$iife_private$M) {
				var newA = {
					ctor: '_Array',
					height: 0,
					table: a.table.slice()
				};
				newA.table.push(item);
				return newA;
			} else {
				return null;
			}
		}

		// Recursively push
		var pushed = _elm_lang$core$Native_Array$iife_private$push_(item, _elm_lang$core$Native_Array$iife_private$botRight(a));

		// There was space in the bottom right tree, so the slot will
		// be updated.
		if (pushed !== null) {
			var newA = _elm_lang$core$Native_Array$iife_private$nodeCopy(a);
			newA.table[newA.table.length - 1] = pushed;
			newA.lengths[newA.lengths.length - 1]++;
			return newA;
		}

		// When there was no space left, check if there is space left
		// for a new slot with a tree which contains only the item
		// at the bottom.
		if (a.table.length < _elm_lang$core$Native_Array$iife_private$M) {
			var newSlot = _elm_lang$core$Native_Array$iife_private$create(item, a.height - 1);
			var newA = _elm_lang$core$Native_Array$iife_private$nodeCopy(a);
			newA.table.push(newSlot);
			newA.lengths.push(newA.lengths[newA.lengths.length - 1] + _elm_lang$core$Native_Array$iife_private$length(newSlot));
			return newA;
		} else {
			return null;
		}
	}

	// Pushes an item via push_ to the bottom right of a tree.
	function _elm_lang$core$Native_Array$iife_private$push(item, a) {
		var pushed = _elm_lang$core$Native_Array$iife_private$push_(item, a);
		if (pushed !== null) {
			return pushed;
		}

		var newTree = _elm_lang$core$Native_Array$iife_private$create(item, a.height);
		return _elm_lang$core$Native_Array$iife_private$siblise(a, newTree);
	}

	// Push a node into a higher node as a child.
	function _elm_lang$core$Native_Array$iife_private$fromListPush(toPush, nodes) {
		var h = toPush.height;

		// Maybe the node on this height does not exist.
		if (nodes.length === h) {
			var node = {
				ctor: '_Array',
				height: h + 1,
				table: [],
				lengths: []
			};
			nodes.push(node);
		}

		nodes[h].table.push(toPush);
		var len = _elm_lang$core$Native_Array$iife_private$length(toPush);
		if (nodes[h].lengths.length > 0) {
			len += nodes[h].lengths[nodes[h].lengths.length - 1];
		}
		nodes[h].lengths.push(len);

		if (nodes[h].table.length === _elm_lang$core$Native_Array$iife_private$M) {
			_elm_lang$core$Native_Array$iife_private$fromListPush(nodes[h], nodes);
			nodes[h] = {
				ctor: '_Array',
				height: h + 1,
				table: [],
				lengths: []
			};
		}
	}

	function _elm_lang$core$Native_Array$iife_private$fromList(list) {
		if (list.ctor === '[]') {
			return _elm_lang$core$Native_Array$iife_private$empty;
		}

		// Allocate M sized blocks (table) and write list elements to it.
		var table = new Array(_elm_lang$core$Native_Array$iife_private$M);
		var nodes = [];
		var i = 0;

		while (list.ctor !== '[]') {
			table[i] = list._0;
			list = list._1;
			i++;

			// table is full, so we can push a leaf containing it into the
			// next node.
			if (i === _elm_lang$core$Native_Array$iife_private$M) {
				var leaf = {
					ctor: '_Array',
					height: 0,
					table: table
				};
				_elm_lang$core$Native_Array$iife_private$fromListPush(leaf, nodes);
				table = new Array(_elm_lang$core$Native_Array$iife_private$M);
				i = 0;
			}
		}

		// Maybe there is something left on the table.
		if (i > 0) {
			var leaf = {
				ctor: '_Array',
				height: 0,
				table: table.splice(0, i)
			};
			_elm_lang$core$Native_Array$iife_private$fromListPush(leaf, nodes);
		}

		// Go through all of the nodes and eventually push them into higher nodes.
		for (var h = 0; h < nodes.length - 1; h++) {
			if (nodes[h].table.length > 0) {
				_elm_lang$core$Native_Array$iife_private$fromListPush(nodes[h], nodes);
			}
		}

		var head = nodes[nodes.length - 1];
		if (head.height > 0 && head.table.length === 1) {
			return head.table[0];
		} else {
			return head;
		}
	}

	function _elm_lang$core$Native_Array$iife_private$initialize_(f, h, from, to) {
		if (h === 0) {
			var table = new Array((to - from) % (_elm_lang$core$Native_Array$iife_private$M + 1));
			for (var i = 0; i < table.length; i++) {
				table[i] = f(from + i);
			}
			return {
				ctor: '_Array',
				height: 0,
				table: table
			};
		}

		var step = Math.pow(_elm_lang$core$Native_Array$iife_private$M, h);
		var table = new Array(Math.ceil((to - from) / step));
		var lengths = new Array(table.length);
		for (var i = 0; i < table.length; i++) {
			table[i] = _elm_lang$core$Native_Array$iife_private$initialize_(f, h - 1, from + i * step, Math.min(from + (i + 1) * step, to));
			lengths[i] = _elm_lang$core$Native_Array$iife_private$length(table[i]) + (i > 0 ? lengths[i - 1] : 0);
		}
		return {
			ctor: '_Array',
			height: h,
			table: table,
			lengths: lengths
		};
	}

	function _elm_lang$core$Native_Array$iife_private$initialize(len, f) {
		if (len <= 0) {
			return _elm_lang$core$Native_Array$iife_private$empty;
		}
		var h = Math.floor(Math.log(len) / Math.log(_elm_lang$core$Native_Array$iife_private$M));
		return _elm_lang$core$Native_Array$iife_private$initialize_(f, h, 0, len);
	}

	function _elm_lang$core$Native_Array$iife_private$unsafeSet(i, item, array) {
		array = _elm_lang$core$Native_Array$iife_private$nodeCopy(array);

		if (array.height === 0) {
			array.table[i] = item;
		} else {
			var slot = _elm_lang$core$Native_Array$iife_private$getSlot(i, array);
			if (slot > 0) {
				i -= array.lengths[slot - 1];
			}
			array.table[slot] = _elm_lang$core$Native_Array$iife_private$unsafeSet(i, item, array.table[slot]);
		}
		return array;
	}

	// Sets the value at the index i. Only the nodes leading to i will get
	// copied and updated.
	function _elm_lang$core$Native_Array$iife_private$set(i, item, array) {
		if (i < 0 || _elm_lang$core$Native_Array$iife_private$length(array) <= i) {
			return array;
		}
		return _elm_lang$core$Native_Array$iife_private$unsafeSet(i, item, array);
	}

	function _elm_lang$core$Native_Array$iife_private$unsafeGet(i, array) {
		for (var x = array.height; x > 0; x--) {
			var slot = i >> x * 5;
			while (array.lengths[slot] <= i) {
				slot++;
			}
			if (slot > 0) {
				i -= array.lengths[slot - 1];
			}
			array = array.table[slot];
		}
		return array.table[i];
	}

	function _elm_lang$core$Native_Array$iife_private$get(i, array) {
		if (i < 0 || i >= _elm_lang$core$Native_Array$iife_private$length(array)) {
			throw new Error('Index ' + i + ' is out of range. Check the length of ' + 'your array first or use getMaybe or getWithDefault.');
		}
		return _elm_lang$core$Native_Array$iife_private$unsafeGet(i, array);
	}var _elm_lang$core$Native_Basics = {},
	    _elm_lang$core$Native_Basics$iife_private$ord = ['LT', 'EQ', 'GT'],
	    _elm_lang$core$Native_Basics$iife_public$div = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$div),
	    _elm_lang$core$Native_Basics$iife_public$rem = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$rem),
	    _elm_lang$core$Native_Basics$iife_public$mod = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$mod),
	    _elm_lang$core$Native_Basics$iife_public$pi = Math.PI,
	    _elm_lang$core$Native_Basics$iife_public$e = Math.E,
	    _elm_lang$core$Native_Basics$iife_public$cos = Math.cos,
	    _elm_lang$core$Native_Basics$iife_public$sin = Math.sin,
	    _elm_lang$core$Native_Basics$iife_public$tan = Math.tan,
	    _elm_lang$core$Native_Basics$iife_public$acos = Math.acos,
	    _elm_lang$core$Native_Basics$iife_public$asin = Math.asin,
	    _elm_lang$core$Native_Basics$iife_public$atan = Math.atan,
	    _elm_lang$core$Native_Basics$iife_public$atan2 = /*#__PURE__*/F2(Math.atan2),
	    _elm_lang$core$Native_Basics$iife_public$degrees = _elm_lang$core$Native_Basics$iife_private$degrees,
	    _elm_lang$core$Native_Basics$iife_public$turns = _elm_lang$core$Native_Basics$iife_private$turns,
	    _elm_lang$core$Native_Basics$iife_public$fromPolar = _elm_lang$core$Native_Basics$iife_private$fromPolar,
	    _elm_lang$core$Native_Basics$iife_public$toPolar = _elm_lang$core$Native_Basics$iife_private$toPolar,
	    _elm_lang$core$Native_Basics$iife_public$sqrt = Math.sqrt,
	    _elm_lang$core$Native_Basics$iife_public$logBase = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$logBase),
	    _elm_lang$core$Native_Basics$iife_public$negate = _elm_lang$core$Native_Basics$iife_private$negate,
	    _elm_lang$core$Native_Basics$iife_public$abs = _elm_lang$core$Native_Basics$iife_private$abs,
	    _elm_lang$core$Native_Basics$iife_public$min = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$min),
	    _elm_lang$core$Native_Basics$iife_public$max = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$max),
	    _elm_lang$core$Native_Basics$iife_public$clamp = /*#__PURE__*/F3(_elm_lang$core$Native_Basics$iife_private$clamp),
	    _elm_lang$core$Native_Basics$iife_public$compare = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$compare),
	    _elm_lang$core$Native_Basics$iife_public$xor = /*#__PURE__*/F2(_elm_lang$core$Native_Basics$iife_private$xor),
	    _elm_lang$core$Native_Basics$iife_public$not = _elm_lang$core$Native_Basics$iife_private$not,
	    _elm_lang$core$Native_Basics$iife_public$truncate = _elm_lang$core$Native_Basics$iife_private$truncate,
	    _elm_lang$core$Native_Basics$iife_public$ceiling = Math.ceil,
	    _elm_lang$core$Native_Basics$iife_public$floor = Math.floor,
	    _elm_lang$core$Native_Basics$iife_public$round = Math.round,
	    _elm_lang$core$Native_Basics$iife_public$toFloat = function (x) {
		return x;
	},
	    _elm_lang$core$Native_Basics$iife_public$isNaN = isNaN,
	    _elm_lang$core$Native_Basics$iife_public$isInfinite = _elm_lang$core$Native_Basics$iife_private$isInfinite;
	//import //

	function _elm_lang$core$Native_Basics$iife_private$toPolar(point) {
		var x = point._0;
		var y = point._1;
		return _elm_lang$core$Native_Utils$iife_public$Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y, x));
	}

	function _elm_lang$core$Native_Basics$iife_private$fromPolar(point) {
		var r = point._0;
		var t = point._1;
		return _elm_lang$core$Native_Utils$iife_public$Tuple2(r * Math.cos(t), r * Math.sin(t));
	}
	function _elm_lang$core$Native_Basics$iife_private$turns(t) {
		return 2 * Math.PI * t;
	}

	function _elm_lang$core$Native_Basics$iife_private$degrees(d) {
		return d * Math.PI / 180;
	}

	function _elm_lang$core$Native_Basics$iife_private$truncate(n) {
		return n | 0;
	}
	function _elm_lang$core$Native_Basics$iife_private$isInfinite(n) {
		return n === Infinity || n === -Infinity;
	}
	function _elm_lang$core$Native_Basics$iife_private$not(b) {
		return !b;
	}

	function _elm_lang$core$Native_Basics$iife_private$xor(a, b) {
		return a !== b;
	}

	function _elm_lang$core$Native_Basics$iife_private$compare(x, y) {
		return { ctor: _elm_lang$core$Native_Basics$iife_private$ord[_elm_lang$core$Native_Utils$iife_public$cmp(x, y) + 1] };
	}
	function _elm_lang$core$Native_Basics$iife_private$clamp(lo, hi, n) {
		return _elm_lang$core$Native_Utils$iife_public$cmp(n, lo) < 0 ? lo : _elm_lang$core$Native_Utils$iife_public$cmp(n, hi) > 0 ? hi : n;
	}

	function _elm_lang$core$Native_Basics$iife_private$max(a, b) {
		return _elm_lang$core$Native_Utils$iife_public$cmp(a, b) > 0 ? a : b;
	}

	function _elm_lang$core$Native_Basics$iife_private$min(a, b) {
		return _elm_lang$core$Native_Utils$iife_public$cmp(a, b) < 0 ? a : b;
	}
	function _elm_lang$core$Native_Basics$iife_private$abs(n) {
		return n < 0 ? -n : n;
	}
	function _elm_lang$core$Native_Basics$iife_private$negate(n) {
		return -n;
	}
	function _elm_lang$core$Native_Basics$iife_private$logBase(base, n) {
		return Math.log(n) / Math.log(base);
	}
	function _elm_lang$core$Native_Basics$iife_private$mod(a, b) {
		if (b === 0) {
			throw new Error('Cannot perform mod 0. Division by zero error.');
		}
		var r = a % b;
		var m = a === 0 ? 0 : b > 0 ? a >= 0 ? r : r + b : -_elm_lang$core$Native_Basics$iife_private$mod(-a, -b);

		return m === b ? 0 : m;
	}
	function _elm_lang$core$Native_Basics$iife_private$rem(a, b) {
		return a % b;
	}

	function _elm_lang$core$Native_Basics$iife_private$div(a, b) {
		return a / b | 0;
	}var _elm_lang$core$Native_Utils = {},
	    _elm_lang$core$Native_Utils$iife_private$LT = -1,
	    _elm_lang$core$Native_Utils$iife_private$EQ = 0,
	    _elm_lang$core$Native_Utils$iife_private$GT = 1,
	    _elm_lang$core$Native_Utils$iife_private$Tuple0 = {
		ctor: '_Tuple0'
	},
	    _elm_lang$core$Native_Utils$iife_private$count = 0,
	    _elm_lang$core$Native_Utils$iife_private$Nil = { ctor: '[]' },
	    _elm_lang$core$Native_Utils$iife_public$eq = _elm_lang$core$Native_Utils$iife_private$eq,
	    _elm_lang$core$Native_Utils$iife_public$cmp = _elm_lang$core$Native_Utils$iife_private$cmp,
	    _elm_lang$core$Native_Utils$iife_public$Tuple0 = _elm_lang$core$Native_Utils$iife_private$Tuple0,
	    _elm_lang$core$Native_Utils$iife_public$Tuple2 = _elm_lang$core$Native_Utils$iife_private$Tuple2,
	    _elm_lang$core$Native_Utils$iife_public$chr = _elm_lang$core$Native_Utils$iife_private$chr,
	    _elm_lang$core$Native_Utils$iife_public$update = _elm_lang$core$Native_Utils$iife_private$update,
	    _elm_lang$core$Native_Utils$iife_public$guid = _elm_lang$core$Native_Utils$iife_private$guid,
	    _elm_lang$core$Native_Utils$iife_public$append = /*#__PURE__*/F2(_elm_lang$core$Native_Utils$iife_private$append),
	    _elm_lang$core$Native_Utils$iife_public$crash = _elm_lang$core$Native_Utils$iife_private$crash,
	    _elm_lang$core$Native_Utils$iife_public$crashCase = _elm_lang$core$Native_Utils$iife_private$crashCase,
	    _elm_lang$core$Native_Utils$iife_public$toString = _elm_lang$core$Native_Utils$iife_private$toString;


	function _elm_lang$core$Native_Utils$iife_private$addSlashes(str, isChar) {
		var s = str.replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\t/g, '\\t').replace(/\r/g, '\\r').replace(/\v/g, '\\v').replace(/\0/g, '\\0');
		if (isChar) {
			return s.replace(/\'/g, '\\\'');
		} else {
			return s.replace(/\"/g, '\\"');
		}
	}

	// TO STRING

	function _elm_lang$core$Native_Utils$iife_private$toString(v) {
		var type = typeof v;
		if (type === 'function') {
			return '<function>';
		}

		if (type === 'boolean') {
			return v ? 'True' : 'False';
		}

		if (type === 'number') {
			return v + '';
		}

		if (v instanceof String) {
			return '\'' + _elm_lang$core$Native_Utils$iife_private$addSlashes(v, true) + '\'';
		}

		if (type === 'string') {
			return '"' + _elm_lang$core$Native_Utils$iife_private$addSlashes(v, false) + '"';
		}

		if (v === null) {
			return 'null';
		}

		if (type === 'object' && 'ctor' in v) {
			var ctorStarter = v.ctor.substring(0, 5);

			if (ctorStarter === '_Tupl') {
				var output = [];
				for (var k in v) {
					if (k === 'ctor') continue;
					output.push(_elm_lang$core$Native_Utils$iife_private$toString(v[k]));
				}
				return '(' + output.join(',') + ')';
			}

			if (ctorStarter === '_Task') {
				return '<task>';
			}

			if (v.ctor === '_Array') {
				var list = _elm_lang$core$Array$toList(v);
				return 'Array.fromList ' + _elm_lang$core$Native_Utils$iife_private$toString(list);
			}

			if (v.ctor === '<decoder>') {
				return '<decoder>';
			}

			if (v.ctor === '_Process') {
				return '<process:' + v.id + '>';
			}

			if (v.ctor === '::') {
				var output = '[' + _elm_lang$core$Native_Utils$iife_private$toString(v._0);
				v = v._1;
				while (v.ctor === '::') {
					output += ',' + _elm_lang$core$Native_Utils$iife_private$toString(v._0);
					v = v._1;
				}
				return output + ']';
			}

			if (v.ctor === '[]') {
				return '[]';
			}

			if (v.ctor === 'Set_elm_builtin') {
				return 'Set.fromList ' + _elm_lang$core$Native_Utils$iife_private$toString(_elm_lang$core$Set$toList(v));
			}

			if (v.ctor === 'RBNode_elm_builtin' || v.ctor === 'RBEmpty_elm_builtin') {
				return 'Dict.fromList ' + _elm_lang$core$Native_Utils$iife_private$toString(_elm_lang$core$Dict$toList(v));
			}

			var output = '';
			for (var i in v) {
				if (i === 'ctor') continue;
				var str = _elm_lang$core$Native_Utils$iife_private$toString(v[i]);
				var c0 = str[0];
				var parenless = c0 === '{' || c0 === '(' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
				output += ' ' + (parenless ? str : '(' + str + ')');
			}
			return v.ctor + output;
		}

		if (type === 'object') {
			if (v instanceof Date) {
				return '<' + v.toString() + '>';
			}

			if (v.elm_web_socket) {
				return '<websocket>';
			}

			var output = [];
			for (var k in v) {
				output.push(k + ' = ' + _elm_lang$core$Native_Utils$iife_private$toString(v[k]));
			}
			if (output.length === 0) {
				return '{}';
			}
			return '{ ' + output.join(', ') + ' }';
		}

		return '<internal structure>';
	}

	function _elm_lang$core$Native_Utils$iife_private$regionToString(region) {
		if (region.start.line == region.end.line) {
			return 'on line ' + region.start.line;
		}
		return 'between lines ' + region.start.line + ' and ' + region.end.line;
	}

	function _elm_lang$core$Native_Utils$iife_private$crashCase(moduleName, region, value) {
		return function (message) {
			throw new Error('Ran into a `Debug.crash` in module `' + moduleName + '`\n\n' + 'This was caused by the `case` expression ' + _elm_lang$core$Native_Utils$iife_private$regionToString(region) + '.\n' + 'One of the branches ended with a crash and the following value got through:\n\n    ' + _elm_lang$core$Native_Utils$iife_private$toString(value) + '\n\n' + 'The message provided by the code author is:\n\n    ' + message);
		};
	}

	// CRASHES

	function _elm_lang$core$Native_Utils$iife_private$crash(moduleName, region) {
		return function (message) {
			throw new Error('Ran into a `Debug.crash` in module `' + moduleName + '` ' + _elm_lang$core$Native_Utils$iife_private$regionToString(region) + '\n' + 'The message provided by the code author is:\n\n    ' + message);
		};
	}

	function _elm_lang$core$Native_Utils$iife_private$append(xs, ys) {
		// append Strings
		if (typeof xs === 'string') {
			return xs + ys;
		}

		// append Lists
		if (xs.ctor === '[]') {
			return ys;
		}
		var root = _elm_lang$core$Native_Utils$iife_private$Cons(xs._0, _elm_lang$core$Native_Utils$iife_private$Nil);
		var curr = root;
		xs = xs._1;
		while (xs.ctor !== '[]') {
			curr._1 = _elm_lang$core$Native_Utils$iife_private$Cons(xs._0, _elm_lang$core$Native_Utils$iife_private$Nil);
			xs = xs._1;
			curr = curr._1;
		}
		curr._1 = ys;
		return root;
	}

	function _elm_lang$core$Native_Utils$iife_private$Cons(hd, tl) {
		return {
			ctor: '::',
			_0: hd,
			_1: tl
		};
	}

	// RECORDS

	function _elm_lang$core$Native_Utils$iife_private$update(oldRecord, updatedFields) {
		var newRecord = {};

		for (var key in oldRecord) {
			newRecord[key] = oldRecord[key];
		}

		for (var key in updatedFields) {
			newRecord[key] = updatedFields[key];
		}

		return newRecord;
	}

	//// LIST STUFF ////

	function _elm_lang$core$Native_Utils$iife_private$guid(_) {
		return _elm_lang$core$Native_Utils$iife_private$count++;
	}

	function _elm_lang$core$Native_Utils$iife_private$chr(c) {
		return new String(c);
	}

	// GUID

	function _elm_lang$core$Native_Utils$iife_private$Tuple2(x, y) {
		return {
			ctor: '_Tuple2',
			_0: x,
			_1: y
		};
	}

	function _elm_lang$core$Native_Utils$iife_private$cmp(x, y) {
		if (typeof x !== 'object') {
			return x === y ? _elm_lang$core$Native_Utils$iife_private$EQ : x < y ? _elm_lang$core$Native_Utils$iife_private$LT : _elm_lang$core$Native_Utils$iife_private$GT;
		}

		if (x instanceof String) {
			var a = x.valueOf();
			var b = y.valueOf();
			return a === b ? _elm_lang$core$Native_Utils$iife_private$EQ : a < b ? _elm_lang$core$Native_Utils$iife_private$LT : _elm_lang$core$Native_Utils$iife_private$GT;
		}

		if (x.ctor === '::' || x.ctor === '[]') {
			while (x.ctor === '::' && y.ctor === '::') {
				var ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._0, y._0);
				if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) {
					return ord;
				}
				x = x._1;
				y = y._1;
			}
			return x.ctor === y.ctor ? _elm_lang$core$Native_Utils$iife_private$EQ : x.ctor === '[]' ? _elm_lang$core$Native_Utils$iife_private$LT : _elm_lang$core$Native_Utils$iife_private$GT;
		}

		if (x.ctor.slice(0, 6) === '_Tuple') {
			var ord;
			var n = x.ctor.slice(6) - 0;
			var err = 'cannot compare tuples with more than 6 elements.';
			if (n === 0) return _elm_lang$core$Native_Utils$iife_private$EQ;
			if (n >= 1) {
				ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._0, y._0);if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
				if (n >= 2) {
					ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._1, y._1);if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
					if (n >= 3) {
						ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._2, y._2);if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
						if (n >= 4) {
							ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._3, y._3);if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
							if (n >= 5) {
								ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._4, y._4);if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
								if (n >= 6) {
									ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._5, y._5);if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
									if (n >= 7) throw new Error('Comparison error: ' + err);
								}
							}
						}
					}
				}
			}
			return _elm_lang$core$Native_Utils$iife_private$EQ;
		}

		throw new Error('Comparison error: comparison is only defined on ints, ' + 'floats, times, chars, strings, lists of comparable values, ' + 'and tuples of comparable values.');
	}

	// COMMON VALUES

	function _elm_lang$core$Native_Utils$iife_private$eqHelp(x, y, depth, stack) {
		if (depth > 100) {
			stack.push({ x: x, y: y });
			return true;
		}

		if (x === y) {
			return true;
		}

		if (typeof x !== 'object') {
			if (typeof x === 'function') {
				throw new Error('Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense.' + ' Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#==' + ' which describes why it is this way and what the better version will look like.');
			}
			return false;
		}

		if (x === null || y === null) {
			return false;
		}

		if (x instanceof Date) {
			return x.getTime() === y.getTime();
		}

		if (!('ctor' in x)) {
			for (var key in x) {
				if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(x[key], y[key], depth + 1, stack)) {
					return false;
				}
			}
			return true;
		}

		// convert Dicts and Sets to lists
		if (x.ctor === 'RBNode_elm_builtin' || x.ctor === 'RBEmpty_elm_builtin') {
			x = _elm_lang$core$Dict$toList(x);
			y = _elm_lang$core$Dict$toList(y);
		}
		if (x.ctor === 'Set_elm_builtin') {
			x = _elm_lang$core$Set$toList(x);
			y = _elm_lang$core$Set$toList(y);
		}

		// check if lists are equal without recursion
		if (x.ctor === '::') {
			var a = x;
			var b = y;
			while (a.ctor === '::' && b.ctor === '::') {
				if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(a._0, b._0, depth + 1, stack)) {
					return false;
				}
				a = a._1;
				b = b._1;
			}
			return a.ctor === b.ctor;
		}

		// check if Arrays are equal
		if (x.ctor === '_Array') {
			var xs = _elm_lang$core$Native_Array$iife_public$toJSArray(x);
			var ys = _elm_lang$core$Native_Array$iife_public$toJSArray(y);
			if (xs.length !== ys.length) {
				return false;
			}
			for (var i = 0; i < xs.length; i++) {
				if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(xs[i], ys[i], depth + 1, stack)) {
					return false;
				}
			}
			return true;
		}

		if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(x.ctor, y.ctor, depth + 1, stack)) {
			return false;
		}

		for (var key in x) {
			if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(x[key], y[key], depth + 1, stack)) {
				return false;
			}
		}
		return true;
	}

	// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
	// the particular integer values assigned to LT, EQ, and GT.

	// COMPARISONS

	function _elm_lang$core$Native_Utils$iife_private$eq(x, y) {
		var stack = [];
		var isEqual = _elm_lang$core$Native_Utils$iife_private$eqHelp(x, y, 0, stack);
		var pair;
		while (isEqual && (pair = stack.pop())) {
			isEqual = _elm_lang$core$Native_Utils$iife_private$eqHelp(pair.x, pair.y, 0, stack);
		}
		return isEqual;
	}var _elm_lang$core$Basics$never = function (_p0) {
		never: while (true) {
			var _p1 = _p0;
			var _v1 = _p1._0;
			_p0 = _v1;
			continue never;
		}
	};
	var _elm_lang$core$Basics$uncurry = /*#__PURE__*/F2(function (f, _p2) {
		var _p3 = _p2;
		return A2(f, _p3._0, _p3._1);
	});
	var _elm_lang$core$Basics$curry = /*#__PURE__*/F3(function (f, a, b) {
		return f({ ctor: '_Tuple2', _0: a, _1: b });
	});
	var _elm_lang$core$Basics$flip = /*#__PURE__*/F3(function (f, b, a) {
		return A2(f, a, b);
	});
	var _elm_lang$core$Basics$always = /*#__PURE__*/F2(function (a, _p4) {
		return a;
	});
	var _elm_lang$core$Basics$identity = function (x) {
		return x;
	};
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['<|'] = /*#__PURE__*/F2(function (f, x) {
		return f(x);
	});
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['|>'] = /*#__PURE__*/F2(function (x, f) {
		return f(x);
	});
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['>>'] = /*#__PURE__*/F3(function (f, g, x) {
		return g(f(x));
	});
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['<<'] = /*#__PURE__*/F3(function (g, f, x) {
		return g(f(x));
	});
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['++'] = _elm_lang$core$Native_Utils$iife_public$append;
	var _elm_lang$core$Basics$toString = _elm_lang$core$Native_Utils$iife_public$toString;
	var _elm_lang$core$Basics$isInfinite = _elm_lang$core$Native_Basics$iife_public$isInfinite;
	var _elm_lang$core$Basics$isNaN = _elm_lang$core$Native_Basics$iife_public$isNaN;
	var _elm_lang$core$Basics$toFloat = _elm_lang$core$Native_Basics$iife_public$toFloat;
	var _elm_lang$core$Basics$ceiling = _elm_lang$core$Native_Basics$iife_public$ceiling;
	var _elm_lang$core$Basics$floor = _elm_lang$core$Native_Basics$iife_public$floor;
	var _elm_lang$core$Basics$truncate = _elm_lang$core$Native_Basics$iife_public$truncate;
	var _elm_lang$core$Basics$round = _elm_lang$core$Native_Basics$iife_public$round;
	var _elm_lang$core$Basics$not = _elm_lang$core$Native_Basics$iife_public$not;
	var _elm_lang$core$Basics$xor = _elm_lang$core$Native_Basics$iife_public$xor;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['||'] = _elm_lang$core$Native_Basics.or;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['&&'] = _elm_lang$core$Native_Basics.and;
	var _elm_lang$core$Basics$max = _elm_lang$core$Native_Basics$iife_public$max;
	var _elm_lang$core$Basics$min = _elm_lang$core$Native_Basics$iife_public$min;
	var _elm_lang$core$Basics$compare = _elm_lang$core$Native_Basics$iife_public$compare;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['>='] = _elm_lang$core$Native_Basics.ge;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['<='] = _elm_lang$core$Native_Basics.le;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['>'] = _elm_lang$core$Native_Basics.gt;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['<'] = _elm_lang$core$Native_Basics.lt;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['/='] = _elm_lang$core$Native_Basics.neq;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['=='] = _elm_lang$core$Native_Basics.eq;
	var _elm_lang$core$Basics$e = _elm_lang$core$Native_Basics$iife_public$e;
	var _elm_lang$core$Basics$pi = _elm_lang$core$Native_Basics$iife_public$pi;
	var _elm_lang$core$Basics$clamp = _elm_lang$core$Native_Basics$iife_public$clamp;
	var _elm_lang$core$Basics$logBase = _elm_lang$core$Native_Basics$iife_public$logBase;
	var _elm_lang$core$Basics$abs = _elm_lang$core$Native_Basics$iife_public$abs;
	var _elm_lang$core$Basics$negate = _elm_lang$core$Native_Basics$iife_public$negate;
	var _elm_lang$core$Basics$sqrt = _elm_lang$core$Native_Basics$iife_public$sqrt;
	var _elm_lang$core$Basics$atan2 = _elm_lang$core$Native_Basics$iife_public$atan2;
	var _elm_lang$core$Basics$atan = _elm_lang$core$Native_Basics$iife_public$atan;
	var _elm_lang$core$Basics$asin = _elm_lang$core$Native_Basics$iife_public$asin;
	var _elm_lang$core$Basics$acos = _elm_lang$core$Native_Basics$iife_public$acos;
	var _elm_lang$core$Basics$tan = _elm_lang$core$Native_Basics$iife_public$tan;
	var _elm_lang$core$Basics$sin = _elm_lang$core$Native_Basics$iife_public$sin;
	var _elm_lang$core$Basics$cos = _elm_lang$core$Native_Basics$iife_public$cos;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['^'] = _elm_lang$core$Native_Basics.exp;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['%'] = _elm_lang$core$Native_Basics$iife_public$mod;
	var _elm_lang$core$Basics$rem = _elm_lang$core$Native_Basics$iife_public$rem;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['//'] = _elm_lang$core$Native_Basics$iife_public$div;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['/'] = _elm_lang$core$Native_Basics.floatDiv;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['*'] = _elm_lang$core$Native_Basics.mul;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['-'] = _elm_lang$core$Native_Basics.sub;
	var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
	_elm_lang$core$Basics_ops['+'] = _elm_lang$core$Native_Basics.add;
	var _elm_lang$core$Basics$toPolar = _elm_lang$core$Native_Basics$iife_public$toPolar;
	var _elm_lang$core$Basics$fromPolar = _elm_lang$core$Native_Basics$iife_public$fromPolar;
	var _elm_lang$core$Basics$turns = _elm_lang$core$Native_Basics$iife_public$turns;
	var _elm_lang$core$Basics$degrees = _elm_lang$core$Native_Basics$iife_public$degrees;
	var _elm_lang$core$Basics$radians = function (t) {
		return t;
	};
	var _elm_lang$core$Basics$GT = { ctor: 'GT' };
	var _elm_lang$core$Basics$EQ = { ctor: 'EQ' };
	var _elm_lang$core$Basics$LT = { ctor: 'LT' };
	var _elm_lang$core$Basics$JustOneMore = function (a) {
		return { ctor: 'JustOneMore', _0: a };
	};

	var _elm_lang$core$Maybe$withDefault = /*#__PURE__*/F2(function ($default, maybe) {
		var _p0 = maybe;
		if (_p0.ctor === 'Just') {
			return _p0._0;
		} else {
			return $default;
		}
	});
	var _elm_lang$core$Maybe$Nothing = { ctor: 'Nothing' };
	var _elm_lang$core$Maybe$andThen = /*#__PURE__*/F2(function (callback, maybeValue) {
		var _p1 = maybeValue;
		if (_p1.ctor === 'Just') {
			return callback(_p1._0);
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
	var _elm_lang$core$Maybe$Just = function (a) {
		return { ctor: 'Just', _0: a };
	};
	var _elm_lang$core$Maybe$map = /*#__PURE__*/F2(function (f, maybe) {
		var _p2 = maybe;
		if (_p2.ctor === 'Just') {
			return _elm_lang$core$Maybe$Just(f(_p2._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
	var _elm_lang$core$Maybe$map2 = /*#__PURE__*/F3(function (func, ma, mb) {
		var _p3 = { ctor: '_Tuple2', _0: ma, _1: mb };
		if (_p3.ctor === '_Tuple2' && _p3._0.ctor === 'Just' && _p3._1.ctor === 'Just') {
			return _elm_lang$core$Maybe$Just(A2(func, _p3._0._0, _p3._1._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
	var _elm_lang$core$Maybe$map3 = /*#__PURE__*/F4(function (func, ma, mb, mc) {
		var _p4 = { ctor: '_Tuple3', _0: ma, _1: mb, _2: mc };
		if (_p4.ctor === '_Tuple3' && _p4._0.ctor === 'Just' && _p4._1.ctor === 'Just' && _p4._2.ctor === 'Just') {
			return _elm_lang$core$Maybe$Just(A3(func, _p4._0._0, _p4._1._0, _p4._2._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
	var _elm_lang$core$Maybe$map4 = /*#__PURE__*/F5(function (func, ma, mb, mc, md) {
		var _p5 = { ctor: '_Tuple4', _0: ma, _1: mb, _2: mc, _3: md };
		if (_p5.ctor === '_Tuple4' && _p5._0.ctor === 'Just' && _p5._1.ctor === 'Just' && _p5._2.ctor === 'Just' && _p5._3.ctor === 'Just') {
			return _elm_lang$core$Maybe$Just(A4(func, _p5._0._0, _p5._1._0, _p5._2._0, _p5._3._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});
	var _elm_lang$core$Maybe$map5 = /*#__PURE__*/F6(function (func, ma, mb, mc, md, me) {
		var _p6 = { ctor: '_Tuple5', _0: ma, _1: mb, _2: mc, _3: md, _4: me };
		if (_p6.ctor === '_Tuple5' && _p6._0.ctor === 'Just' && _p6._1.ctor === 'Just' && _p6._2.ctor === 'Just' && _p6._3.ctor === 'Just' && _p6._4.ctor === 'Just') {
			return _elm_lang$core$Maybe$Just(A5(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0, _p6._4._0));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	});

	//import Native.Utils //

	var _elm_lang$core$Native_List = {},
	    _elm_lang$core$Native_List$iife_private$Nil = { ctor: '[]' },
	    _elm_lang$core$Native_List$iife_public$Nil = _elm_lang$core$Native_List$iife_private$Nil,
	    _elm_lang$core$Native_List$iife_public$Cons = _elm_lang$core$Native_List$iife_private$Cons,
	    _elm_lang$core$Native_List$iife_public$cons = /*#__PURE__*/F2(_elm_lang$core$Native_List$iife_private$Cons),
	    _elm_lang$core$Native_List$iife_public$toArray = _elm_lang$core$Native_List$iife_private$toArray,
	    _elm_lang$core$Native_List$iife_public$fromArray = _elm_lang$core$Native_List$iife_private$fromArray,
	    _elm_lang$core$Native_List$iife_public$foldr = /*#__PURE__*/F3(_elm_lang$core$Native_List$iife_private$foldr),
	    _elm_lang$core$Native_List$iife_public$map2 = /*#__PURE__*/F3(_elm_lang$core$Native_List$iife_private$map2),
	    _elm_lang$core$Native_List$iife_public$map3 = /*#__PURE__*/F4(_elm_lang$core$Native_List$iife_private$map3),
	    _elm_lang$core$Native_List$iife_public$map4 = /*#__PURE__*/F5(_elm_lang$core$Native_List$iife_private$map4),
	    _elm_lang$core$Native_List$iife_public$map5 = /*#__PURE__*/F6(_elm_lang$core$Native_List$iife_private$map5),
	    _elm_lang$core$Native_List$iife_public$sortBy = /*#__PURE__*/F2(_elm_lang$core$Native_List$iife_private$sortBy),
	    _elm_lang$core$Native_List$iife_public$sortWith = /*#__PURE__*/F2(_elm_lang$core$Native_List$iife_private$sortWith);


	function _elm_lang$core$Native_List$iife_private$sortWith(f, xs) {
		return _elm_lang$core$Native_List$iife_private$fromArray(_elm_lang$core$Native_List$iife_private$toArray(xs).sort(function (a, b) {
			var ord = f(a)(b).ctor;
			return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1;
		}));
	}

	function _elm_lang$core$Native_List$iife_private$sortBy(f, xs) {
		return _elm_lang$core$Native_List$iife_private$fromArray(_elm_lang$core$Native_List$iife_private$toArray(xs).sort(function (a, b) {
			return _elm_lang$core$Native_Utils$iife_public$cmp(f(a), f(b));
		}));
	}

	function _elm_lang$core$Native_List$iife_private$map5(f, vs, ws, xs, ys, zs) {
		var arr = [];
		while (vs.ctor !== '[]' && ws.ctor !== '[]' && xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]') {
			arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0));
			vs = vs._1;
			ws = ws._1;
			xs = xs._1;
			ys = ys._1;
			zs = zs._1;
		}
		return _elm_lang$core$Native_List$iife_private$fromArray(arr);
	}

	function _elm_lang$core$Native_List$iife_private$map4(f, ws, xs, ys, zs) {
		var arr = [];
		while (ws.ctor !== '[]' && xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]') {
			arr.push(A4(f, ws._0, xs._0, ys._0, zs._0));
			ws = ws._1;
			xs = xs._1;
			ys = ys._1;
			zs = zs._1;
		}
		return _elm_lang$core$Native_List$iife_private$fromArray(arr);
	}

	function _elm_lang$core$Native_List$iife_private$map3(f, xs, ys, zs) {
		var arr = [];
		while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]') {
			arr.push(A3(f, xs._0, ys._0, zs._0));
			xs = xs._1;
			ys = ys._1;
			zs = zs._1;
		}
		return _elm_lang$core$Native_List$iife_private$fromArray(arr);
	}

	function _elm_lang$core$Native_List$iife_private$map2(f, xs, ys) {
		var arr = [];
		while (xs.ctor !== '[]' && ys.ctor !== '[]') {
			arr.push(A2(f, xs._0, ys._0));
			xs = xs._1;
			ys = ys._1;
		}
		return _elm_lang$core$Native_List$iife_private$fromArray(arr);
	}

	function _elm_lang$core$Native_List$iife_private$foldr(f, b, xs) {
		var arr = _elm_lang$core$Native_List$iife_private$toArray(xs);
		var acc = b;
		for (var i = arr.length; i--;) {
			acc = A2(f, arr[i], acc);
		}
		return acc;
	}

	function _elm_lang$core$Native_List$iife_private$toArray(xs) {
		var out = [];
		while (xs.ctor !== '[]') {
			out.push(xs._0);
			xs = xs._1;
		}
		return out;
	}

	function _elm_lang$core$Native_List$iife_private$fromArray(arr) {
		var out = _elm_lang$core$Native_List$iife_private$Nil;
		for (var i = arr.length; i--;) {
			out = _elm_lang$core$Native_List$iife_private$Cons(arr[i], out);
		}
		return out;
	}

	function _elm_lang$core$Native_List$iife_private$Cons(hd, tl) {
		return { ctor: '::', _0: hd, _1: tl };
	}var _elm_lang$core$List$sortWith = _elm_lang$core$Native_List$iife_public$sortWith;
	var _elm_lang$core$List$sortBy = _elm_lang$core$Native_List$iife_public$sortBy;
	var _elm_lang$core$List$sort = function (xs) {
		return A2(_elm_lang$core$List$sortBy, _elm_lang$core$Basics$identity, xs);
	};
	var _elm_lang$core$List$singleton = function (value) {
		return {
			ctor: '::',
			_0: value,
			_1: { ctor: '[]' }
		};
	};
	var _elm_lang$core$List$drop = /*#__PURE__*/F2(function (n, list) {
		drop: while (true) {
			if (_elm_lang$core$Native_Utils$iife_public$cmp(n, 0) < 1) {
				return list;
			} else {
				var _p0 = list;
				if (_p0.ctor === '[]') {
					return list;
				} else {
					var _v1 = n - 1,
					    _v2 = _p0._1;
					n = _v1;
					list = _v2;
					continue drop;
				}
			}
		}
	});
	var _elm_lang$core$List$map5 = _elm_lang$core$Native_List$iife_public$map5;
	var _elm_lang$core$List$map4 = _elm_lang$core$Native_List$iife_public$map4;
	var _elm_lang$core$List$map3 = _elm_lang$core$Native_List$iife_public$map3;
	var _elm_lang$core$List$map2 = _elm_lang$core$Native_List$iife_public$map2;
	var _elm_lang$core$List$any = /*#__PURE__*/F2(function (isOkay, list) {
		any: while (true) {
			var _p1 = list;
			if (_p1.ctor === '[]') {
				return false;
			} else {
				if (isOkay(_p1._0)) {
					return true;
				} else {
					var _v4 = isOkay,
					    _v5 = _p1._1;
					isOkay = _v4;
					list = _v5;
					continue any;
				}
			}
		}
	});
	var _elm_lang$core$List$all = /*#__PURE__*/F2(function (isOkay, list) {
		return !A2(_elm_lang$core$List$any, function (_p2) {
			return !isOkay(_p2);
		}, list);
	});
	var _elm_lang$core$List$foldr = _elm_lang$core$Native_List$iife_public$foldr;
	var _elm_lang$core$List$foldl = /*#__PURE__*/F3(function (func, acc, list) {
		foldl: while (true) {
			var _p3 = list;
			if (_p3.ctor === '[]') {
				return acc;
			} else {
				var _v7 = func,
				    _v8 = A2(func, _p3._0, acc),
				    _v9 = _p3._1;
				func = _v7;
				acc = _v8;
				list = _v9;
				continue foldl;
			}
		}
	});
	var _elm_lang$core$List$length = function (xs) {
		return A3(_elm_lang$core$List$foldl, /*#__PURE__*/F2(function (_p4, i) {
			return i + 1;
		}), 0, xs);
	};
	var _elm_lang$core$List$sum = function (numbers) {
		return A3(_elm_lang$core$List$foldl, /*#__PURE__*/F2(function (x, y) {
			return x + y;
		}), 0, numbers);
	};
	var _elm_lang$core$List$product = function (numbers) {
		return A3(_elm_lang$core$List$foldl, /*#__PURE__*/F2(function (x, y) {
			return x * y;
		}), 1, numbers);
	};
	var _elm_lang$core$List$maximum = function (list) {
		var _p5 = list;
		if (_p5.ctor === '::') {
			return _elm_lang$core$Maybe$Just(A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$max, _p5._0, _p5._1));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	};
	var _elm_lang$core$List$minimum = function (list) {
		var _p6 = list;
		if (_p6.ctor === '::') {
			return _elm_lang$core$Maybe$Just(A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$min, _p6._0, _p6._1));
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	};
	var _elm_lang$core$List$member = /*#__PURE__*/F2(function (x, xs) {
		return A2(_elm_lang$core$List$any, function (a) {
			return _elm_lang$core$Native_Utils$iife_public$eq(a, x);
		}, xs);
	});
	var _elm_lang$core$List$isEmpty = function (xs) {
		var _p7 = xs;
		if (_p7.ctor === '[]') {
			return true;
		} else {
			return false;
		}
	};
	var _elm_lang$core$List$tail = function (list) {
		var _p8 = list;
		if (_p8.ctor === '::') {
			return _elm_lang$core$Maybe$Just(_p8._1);
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	};
	var _elm_lang$core$List$head = function (list) {
		var _p9 = list;
		if (_p9.ctor === '::') {
			return _elm_lang$core$Maybe$Just(_p9._0);
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	};
	var _elm_lang$core$List_ops = _elm_lang$core$List_ops || {};
	_elm_lang$core$List_ops['::'] = _elm_lang$core$Native_List$iife_public$cons;
	var _elm_lang$core$List$map = /*#__PURE__*/F2(function (f, xs) {
		return A3(_elm_lang$core$List$foldr, /*#__PURE__*/F2(function (x, acc) {
			return {
				ctor: '::',
				_0: f(x),
				_1: acc
			};
		}), { ctor: '[]' }, xs);
	});
	var _elm_lang$core$List$filter = /*#__PURE__*/F2(function (pred, xs) {
		var conditionalCons = /*#__PURE__*/F2(function (front, back) {
			return pred(front) ? { ctor: '::', _0: front, _1: back } : back;
		});
		return A3(_elm_lang$core$List$foldr, conditionalCons, { ctor: '[]' }, xs);
	});
	var _elm_lang$core$List$maybeCons = /*#__PURE__*/F3(function (f, mx, xs) {
		var _p10 = f(mx);
		if (_p10.ctor === 'Just') {
			return { ctor: '::', _0: _p10._0, _1: xs };
		} else {
			return xs;
		}
	});
	var _elm_lang$core$List$filterMap = /*#__PURE__*/F2(function (f, xs) {
		return A3(_elm_lang$core$List$foldr, _elm_lang$core$List$maybeCons(f), { ctor: '[]' }, xs);
	});
	var _elm_lang$core$List$reverse = function (list) {
		return A3(_elm_lang$core$List$foldl, /*#__PURE__*/F2(function (x, y) {
			return { ctor: '::', _0: x, _1: y };
		}), { ctor: '[]' }, list);
	};
	var _elm_lang$core$List$scanl = /*#__PURE__*/F3(function (f, b, xs) {
		var scan1 = /*#__PURE__*/F2(function (x, accAcc) {
			var _p11 = accAcc;
			if (_p11.ctor === '::') {
				return {
					ctor: '::',
					_0: A2(f, x, _p11._0),
					_1: accAcc
				};
			} else {
				return { ctor: '[]' };
			}
		});
		return _elm_lang$core$List$reverse(A3(_elm_lang$core$List$foldl, scan1, {
			ctor: '::',
			_0: b,
			_1: { ctor: '[]' }
		}, xs));
	});
	var _elm_lang$core$List$append = /*#__PURE__*/F2(function (xs, ys) {
		var _p12 = ys;
		if (_p12.ctor === '[]') {
			return xs;
		} else {
			return A3(_elm_lang$core$List$foldr, /*#__PURE__*/F2(function (x, y) {
				return { ctor: '::', _0: x, _1: y };
			}), ys, xs);
		}
	});
	var _elm_lang$core$List$concat = function (lists) {
		return A3(_elm_lang$core$List$foldr, _elm_lang$core$List$append, { ctor: '[]' }, lists);
	};
	var _elm_lang$core$List$concatMap = /*#__PURE__*/F2(function (f, list) {
		return _elm_lang$core$List$concat(A2(_elm_lang$core$List$map, f, list));
	});
	var _elm_lang$core$List$partition = /*#__PURE__*/F2(function (pred, list) {
		var step = /*#__PURE__*/F2(function (x, _p13) {
			var _p14 = _p13;
			var _p16 = _p14._0;
			var _p15 = _p14._1;
			return pred(x) ? {
				ctor: '_Tuple2',
				_0: { ctor: '::', _0: x, _1: _p16 },
				_1: _p15
			} : {
				ctor: '_Tuple2',
				_0: _p16,
				_1: { ctor: '::', _0: x, _1: _p15 }
			};
		});
		return A3(_elm_lang$core$List$foldr, step, {
			ctor: '_Tuple2',
			_0: { ctor: '[]' },
			_1: { ctor: '[]' }
		}, list);
	});
	var _elm_lang$core$List$unzip = function (pairs) {
		var step = /*#__PURE__*/F2(function (_p18, _p17) {
			var _p19 = _p18;
			var _p20 = _p17;
			return {
				ctor: '_Tuple2',
				_0: { ctor: '::', _0: _p19._0, _1: _p20._0 },
				_1: { ctor: '::', _0: _p19._1, _1: _p20._1 }
			};
		});
		return A3(_elm_lang$core$List$foldr, step, {
			ctor: '_Tuple2',
			_0: { ctor: '[]' },
			_1: { ctor: '[]' }
		}, pairs);
	};
	var _elm_lang$core$List$intersperse = /*#__PURE__*/F2(function (sep, xs) {
		var _p21 = xs;
		if (_p21.ctor === '[]') {
			return { ctor: '[]' };
		} else {
			var step = /*#__PURE__*/F2(function (x, rest) {
				return {
					ctor: '::',
					_0: sep,
					_1: { ctor: '::', _0: x, _1: rest }
				};
			});
			var spersed = A3(_elm_lang$core$List$foldr, step, { ctor: '[]' }, _p21._1);
			return { ctor: '::', _0: _p21._0, _1: spersed };
		}
	});
	var _elm_lang$core$List$takeReverse = /*#__PURE__*/F3(function (n, list, taken) {
		takeReverse: while (true) {
			if (_elm_lang$core$Native_Utils$iife_public$cmp(n, 0) < 1) {
				return taken;
			} else {
				var _p22 = list;
				if (_p22.ctor === '[]') {
					return taken;
				} else {
					var _v23 = n - 1,
					    _v24 = _p22._1,
					    _v25 = { ctor: '::', _0: _p22._0, _1: taken };
					n = _v23;
					list = _v24;
					taken = _v25;
					continue takeReverse;
				}
			}
		}
	});
	var _elm_lang$core$List$takeTailRec = /*#__PURE__*/F2(function (n, list) {
		return _elm_lang$core$List$reverse(A3(_elm_lang$core$List$takeReverse, n, list, { ctor: '[]' }));
	});
	var _elm_lang$core$List$takeFast = /*#__PURE__*/F3(function (ctr, n, list) {
		if (_elm_lang$core$Native_Utils$iife_public$cmp(n, 0) < 1) {
			return { ctor: '[]' };
		} else {
			var _p23 = { ctor: '_Tuple2', _0: n, _1: list };
			_v26_5: do {
				_v26_1: do {
					if (_p23.ctor === '_Tuple2') {
						if (_p23._1.ctor === '[]') {
							return list;
						} else {
							if (_p23._1._1.ctor === '::') {
								switch (_p23._0) {
									case 1:
										break _v26_1;
									case 2:
										return {
											ctor: '::',
											_0: _p23._1._0,
											_1: {
												ctor: '::',
												_0: _p23._1._1._0,
												_1: { ctor: '[]' }
											}
										};
									case 3:
										if (_p23._1._1._1.ctor === '::') {
											return {
												ctor: '::',
												_0: _p23._1._0,
												_1: {
													ctor: '::',
													_0: _p23._1._1._0,
													_1: {
														ctor: '::',
														_0: _p23._1._1._1._0,
														_1: { ctor: '[]' }
													}
												}
											};
										} else {
											break _v26_5;
										}
									default:
										if (_p23._1._1._1.ctor === '::' && _p23._1._1._1._1.ctor === '::') {
											var _p28 = _p23._1._1._1._0;
											var _p27 = _p23._1._1._0;
											var _p26 = _p23._1._0;
											var _p25 = _p23._1._1._1._1._0;
											var _p24 = _p23._1._1._1._1._1;
											return _elm_lang$core$Native_Utils$iife_public$cmp(ctr, 1000) > 0 ? {
												ctor: '::',
												_0: _p26,
												_1: {
													ctor: '::',
													_0: _p27,
													_1: {
														ctor: '::',
														_0: _p28,
														_1: {
															ctor: '::',
															_0: _p25,
															_1: A2(_elm_lang$core$List$takeTailRec, n - 4, _p24)
														}
													}
												}
											} : {
												ctor: '::',
												_0: _p26,
												_1: {
													ctor: '::',
													_0: _p27,
													_1: {
														ctor: '::',
														_0: _p28,
														_1: {
															ctor: '::',
															_0: _p25,
															_1: A3(_elm_lang$core$List$takeFast, ctr + 1, n - 4, _p24)
														}
													}
												}
											};
										} else {
											break _v26_5;
										}
								}
							} else {
								if (_p23._0 === 1) {
									break _v26_1;
								} else {
									break _v26_5;
								}
							}
						}
					} else {
						break _v26_5;
					}
				} while (false);
				return {
					ctor: '::',
					_0: _p23._1._0,
					_1: { ctor: '[]' }
				};
			} while (false);
			return list;
		}
	});
	var _elm_lang$core$List$take = /*#__PURE__*/F2(function (n, list) {
		return A3(_elm_lang$core$List$takeFast, 0, n, list);
	});
	var _elm_lang$core$List$repeatHelp = /*#__PURE__*/F3(function (result, n, value) {
		repeatHelp: while (true) {
			if (_elm_lang$core$Native_Utils$iife_public$cmp(n, 0) < 1) {
				return result;
			} else {
				var _v27 = { ctor: '::', _0: value, _1: result },
				    _v28 = n - 1,
				    _v29 = value;
				result = _v27;
				n = _v28;
				value = _v29;
				continue repeatHelp;
			}
		}
	});
	var _elm_lang$core$List$repeat = /*#__PURE__*/F2(function (n, value) {
		return A3(_elm_lang$core$List$repeatHelp, { ctor: '[]' }, n, value);
	});
	var _elm_lang$core$List$rangeHelp = /*#__PURE__*/F3(function (lo, hi, list) {
		rangeHelp: while (true) {
			if (_elm_lang$core$Native_Utils$iife_public$cmp(lo, hi) < 1) {
				var _v30 = lo,
				    _v31 = hi - 1,
				    _v32 = { ctor: '::', _0: hi, _1: list };
				lo = _v30;
				hi = _v31;
				list = _v32;
				continue rangeHelp;
			} else {
				return list;
			}
		}
	});
	var _elm_lang$core$List$range = /*#__PURE__*/F2(function (lo, hi) {
		return A3(_elm_lang$core$List$rangeHelp, lo, hi, { ctor: '[]' });
	});
	var _elm_lang$core$List$indexedMap = /*#__PURE__*/F2(function (f, xs) {
		return A3(_elm_lang$core$List$map2, f, A2(_elm_lang$core$List$range, 0, _elm_lang$core$List$length(xs) - 1), xs);
	});

	var _elm_lang$core$Array$append = _elm_lang$core$Native_Array$iife_public$append;
	var _elm_lang$core$Array$length = _elm_lang$core$Native_Array$iife_public$length;
	var _elm_lang$core$Array$isEmpty = function (array) {
		return _elm_lang$core$Native_Utils$iife_public$eq(_elm_lang$core$Array$length(array), 0);
	};
	var _elm_lang$core$Array$slice = _elm_lang$core$Native_Array$iife_public$slice;
	var _elm_lang$core$Array$set = _elm_lang$core$Native_Array$iife_public$set;
	var _elm_lang$core$Array$get = /*#__PURE__*/F2(function (i, array) {
		return _elm_lang$core$Native_Utils$iife_public$cmp(0, i) < 1 && _elm_lang$core$Native_Utils$iife_public$cmp(i, _elm_lang$core$Native_Array$iife_public$length(array)) < 0 ? _elm_lang$core$Maybe$Just(A2(_elm_lang$core$Native_Array$iife_public$get, i, array)) : _elm_lang$core$Maybe$Nothing;
	});
	var _elm_lang$core$Array$push = _elm_lang$core$Native_Array$iife_public$push;
	var _elm_lang$core$Array$empty = _elm_lang$core$Native_Array$iife_public$empty;
	var _elm_lang$core$Array$filter = /*#__PURE__*/F2(function (isOkay, arr) {
		var update = /*#__PURE__*/F2(function (x, xs) {
			return isOkay(x) ? A2(_elm_lang$core$Native_Array$iife_public$push, x, xs) : xs;
		});
		return A3(_elm_lang$core$Native_Array$iife_public$foldl, update, _elm_lang$core$Native_Array$iife_public$empty, arr);
	});
	var _elm_lang$core$Array$foldr = _elm_lang$core$Native_Array$iife_public$foldr;
	var _elm_lang$core$Array$foldl = _elm_lang$core$Native_Array$iife_public$foldl;
	var _elm_lang$core$Array$indexedMap = _elm_lang$core$Native_Array$iife_public$indexedMap;
	var _elm_lang$core$Array$map = _elm_lang$core$Native_Array$iife_public$map;
	var _elm_lang$core$Array$toIndexedList = function (array) {
		return A3(_elm_lang$core$List$map2, /*#__PURE__*/F2(function (v0, v1) {
			return { ctor: '_Tuple2', _0: v0, _1: v1 };
		}), A2(_elm_lang$core$List$range, 0, _elm_lang$core$Native_Array$iife_public$length(array) - 1), _elm_lang$core$Native_Array$iife_public$toList(array));
	};
	var _elm_lang$core$Array$toList = _elm_lang$core$Native_Array$iife_public$toList;
	var _elm_lang$core$Array$fromList = _elm_lang$core$Native_Array$iife_public$fromList;
	var _elm_lang$core$Array$initialize = _elm_lang$core$Native_Array$iife_public$initialize;
	var _elm_lang$core$Array$repeat = /*#__PURE__*/F2(function (n, e) {
		return A2(_elm_lang$core$Array$initialize, n, _elm_lang$core$Basics$always(e));
	});
	var _elm_lang$core$Array$Array = { ctor: 'Array' };

	//import Native.Utils //

	var _elm_lang$core$Native_Char = {},
	    _elm_lang$core$Native_Char$iife_public$fromCode = function (c) {
		return (/*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(String.fromCharCode(c))
		);
	},
	    _elm_lang$core$Native_Char$iife_public$toCode = function (c) {
		return c.charCodeAt(0);
	},
	    _elm_lang$core$Native_Char$iife_public$toUpper = function (c) {
		return (/*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(c.toUpperCase())
		);
	},
	    _elm_lang$core$Native_Char$iife_public$toLower = function (c) {
		return (/*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(c.toLowerCase())
		);
	},
	    _elm_lang$core$Native_Char$iife_public$toLocaleUpper = function (c) {
		return (/*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(c.toLocaleUpperCase())
		);
	},
	    _elm_lang$core$Native_Char$iife_public$toLocaleLower = function (c) {
		return (/*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(c.toLocaleLowerCase())
		);
	};
	var _elm_lang$core$Char$fromCode = _elm_lang$core$Native_Char$iife_public$fromCode;
	var _elm_lang$core$Char$toCode = _elm_lang$core$Native_Char$iife_public$toCode;
	var _elm_lang$core$Char$toLocaleLower = _elm_lang$core$Native_Char$iife_public$toLocaleLower;
	var _elm_lang$core$Char$toLocaleUpper = _elm_lang$core$Native_Char$iife_public$toLocaleUpper;
	var _elm_lang$core$Char$toLower = _elm_lang$core$Native_Char$iife_public$toLower;
	var _elm_lang$core$Char$toUpper = _elm_lang$core$Native_Char$iife_public$toUpper;
	var _elm_lang$core$Char$isBetween = /*#__PURE__*/F3(function (low, high, $char) {
		var code = _elm_lang$core$Char$toCode($char);
		return _elm_lang$core$Native_Utils$iife_public$cmp(code, _elm_lang$core$Char$toCode(low)) > -1 && _elm_lang$core$Native_Utils$iife_public$cmp(code, _elm_lang$core$Char$toCode(high)) < 1;
	});
	var _elm_lang$core$Char$isUpper = A2(_elm_lang$core$Char$isBetween, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('A'), /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('Z'));
	var _elm_lang$core$Char$isLower = A2(_elm_lang$core$Char$isBetween, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('a'), /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('z'));
	var _elm_lang$core$Char$isDigit = A2(_elm_lang$core$Char$isBetween, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('0'), /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('9'));
	var _elm_lang$core$Char$isOctDigit = A2(_elm_lang$core$Char$isBetween, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('0'), /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('7'));
	var _elm_lang$core$Char$isHexDigit = function ($char) {
		return _elm_lang$core$Char$isDigit($char) || A3(_elm_lang$core$Char$isBetween, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('a'), /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('f'), $char) || A3(_elm_lang$core$Char$isBetween, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('A'), /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr('F'), $char);
	};

	//import Native.Utils //

	var _elm_lang$core$Native_Scheduler = {},
	    _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS = 10000,
	    _elm_lang$core$Native_Scheduler$iife_private$working = false,
	    _elm_lang$core$Native_Scheduler$iife_private$workQueue = [],
	    _elm_lang$core$Native_Scheduler$iife_public$succeed = _elm_lang$core$Native_Scheduler$iife_private$succeed,
	    _elm_lang$core$Native_Scheduler$iife_public$fail = _elm_lang$core$Native_Scheduler$iife_private$fail,
	    _elm_lang$core$Native_Scheduler$iife_public$nativeBinding = _elm_lang$core$Native_Scheduler$iife_private$nativeBinding,
	    _elm_lang$core$Native_Scheduler$iife_public$andThen = /*#__PURE__*/F2(_elm_lang$core$Native_Scheduler$iife_private$andThen),
	    _elm_lang$core$Native_Scheduler$iife_public$onError = /*#__PURE__*/F2(_elm_lang$core$Native_Scheduler$iife_private$onError),
	    _elm_lang$core$Native_Scheduler$iife_public$receive = _elm_lang$core$Native_Scheduler$iife_private$receive,
	    _elm_lang$core$Native_Scheduler$iife_public$spawn = _elm_lang$core$Native_Scheduler$iife_private$spawn,
	    _elm_lang$core$Native_Scheduler$iife_public$kill = _elm_lang$core$Native_Scheduler$iife_private$kill,
	    _elm_lang$core$Native_Scheduler$iife_public$sleep = _elm_lang$core$Native_Scheduler$iife_private$sleep,
	    _elm_lang$core$Native_Scheduler$iife_public$send = /*#__PURE__*/F2(_elm_lang$core$Native_Scheduler$iife_private$send),
	    _elm_lang$core$Native_Scheduler$iife_public$rawSpawn = _elm_lang$core$Native_Scheduler$iife_private$rawSpawn,
	    _elm_lang$core$Native_Scheduler$iife_public$rawSend = _elm_lang$core$Native_Scheduler$iife_private$rawSend;
	//import //

	function _elm_lang$core$Native_Scheduler$iife_private$work() {
		var numSteps = 0;
		var process;
		while (numSteps < _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS && (process = _elm_lang$core$Native_Scheduler$iife_private$workQueue.shift())) {
			if (process.root) {
				numSteps = _elm_lang$core$Native_Scheduler$iife_private$step(numSteps, process);
			}
		}
		if (!process) {
			_elm_lang$core$Native_Scheduler$iife_private$working = false;
			return;
		}
		setTimeout(_elm_lang$core$Native_Scheduler$iife_private$work, 0);
	}

	function _elm_lang$core$Native_Scheduler$iife_private$enqueue(process) {
		_elm_lang$core$Native_Scheduler$iife_private$workQueue.push(process);

		if (!_elm_lang$core$Native_Scheduler$iife_private$working) {
			setTimeout(_elm_lang$core$Native_Scheduler$iife_private$work, 0);
			_elm_lang$core$Native_Scheduler$iife_private$working = true;
		}
	}

	// STEP PROCESSES

	function _elm_lang$core$Native_Scheduler$iife_private$step(numSteps, process) {
		while (numSteps < _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS) {
			var ctor = process.root.ctor;

			if (ctor === '_Task_succeed') {
				while (process.stack && process.stack.ctor === '_Task_onError') {
					process.stack = process.stack.rest;
				}
				if (process.stack === null) {
					break;
				}
				process.root = process.stack.callback(process.root.value);
				process.stack = process.stack.rest;
				++numSteps;
				continue;
			}

			if (ctor === '_Task_fail') {
				while (process.stack && process.stack.ctor === '_Task_andThen') {
					process.stack = process.stack.rest;
				}
				if (process.stack === null) {
					break;
				}
				process.root = process.stack.callback(process.root.value);
				process.stack = process.stack.rest;
				++numSteps;
				continue;
			}

			if (ctor === '_Task_andThen') {
				process.stack = {
					ctor: '_Task_andThen',
					callback: process.root.callback,
					rest: process.stack
				};
				process.root = process.root.task;
				++numSteps;
				continue;
			}

			if (ctor === '_Task_onError') {
				process.stack = {
					ctor: '_Task_onError',
					callback: process.root.callback,
					rest: process.stack
				};
				process.root = process.root.task;
				++numSteps;
				continue;
			}

			if (ctor === '_Task_nativeBinding') {
				process.root.cancel = process.root.callback(function (newRoot) {
					process.root = newRoot;
					_elm_lang$core$Native_Scheduler$iife_private$enqueue(process);
				});

				break;
			}

			if (ctor === '_Task_receive') {
				var mailbox = process.mailbox;
				if (mailbox.length === 0) {
					break;
				}

				process.root = process.root.callback(mailbox.shift());
				++numSteps;
				continue;
			}

			throw new Error(ctor);
		}

		if (numSteps < _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS) {
			return numSteps + 1;
		}
		_elm_lang$core$Native_Scheduler$iife_private$enqueue(process);

		return numSteps;
	}

	// WORK QUEUE

	function _elm_lang$core$Native_Scheduler$iife_private$sleep(time) {
		return _elm_lang$core$Native_Scheduler$iife_private$nativeBinding(function (callback) {
			var id = setTimeout(function () {
				callback(_elm_lang$core$Native_Scheduler$iife_private$succeed(_elm_lang$core$Native_Utils$iife_public$Tuple0));
			}, time);

			return function () {
				clearTimeout(id);
			};
		});
	}

	function _elm_lang$core$Native_Scheduler$iife_private$kill(process) {
		return _elm_lang$core$Native_Scheduler$iife_private$nativeBinding(function (callback) {
			var root = process.root;
			if (root.ctor === '_Task_nativeBinding' && root.cancel) {
				root.cancel();
			}

			process.root = null;

			callback(_elm_lang$core$Native_Scheduler$iife_private$succeed(_elm_lang$core$Native_Utils$iife_public$Tuple0));
		});
	}

	function _elm_lang$core$Native_Scheduler$iife_private$send(process, msg) {
		return _elm_lang$core$Native_Scheduler$iife_private$nativeBinding(function (callback) {
			_elm_lang$core$Native_Scheduler$iife_private$rawSend(process, msg);
			callback(_elm_lang$core$Native_Scheduler$iife_private$succeed(_elm_lang$core$Native_Utils$iife_public$Tuple0));
		});
	}

	function _elm_lang$core$Native_Scheduler$iife_private$rawSend(process, msg) {
		process.mailbox.push(msg);
		_elm_lang$core$Native_Scheduler$iife_private$enqueue(process);
	}

	function _elm_lang$core$Native_Scheduler$iife_private$spawn(task) {
		return _elm_lang$core$Native_Scheduler$iife_private$nativeBinding(function (callback) {
			var process = _elm_lang$core$Native_Scheduler$iife_private$rawSpawn(task);
			callback(_elm_lang$core$Native_Scheduler$iife_private$succeed(process));
		});
	}

	// PROCESSES

	function _elm_lang$core$Native_Scheduler$iife_private$rawSpawn(task) {
		var process = {
			ctor: '_Process',
			id: _elm_lang$core$Native_Utils$iife_public$guid(),
			root: task,
			stack: null,
			mailbox: []
		};

		_elm_lang$core$Native_Scheduler$iife_private$enqueue(process);

		return process;
	}

	function _elm_lang$core$Native_Scheduler$iife_private$receive(callback) {
		return {
			ctor: '_Task_receive',
			callback: callback
		};
	}

	function _elm_lang$core$Native_Scheduler$iife_private$onError(callback, task) {
		return {
			ctor: '_Task_onError',
			callback: callback,
			task: task
		};
	}

	function _elm_lang$core$Native_Scheduler$iife_private$andThen(callback, task) {
		return {
			ctor: '_Task_andThen',
			callback: callback,
			task: task
		};
	}

	function _elm_lang$core$Native_Scheduler$iife_private$nativeBinding(callback) {
		return {
			ctor: '_Task_nativeBinding',
			callback: callback,
			cancel: null
		};
	}

	function _elm_lang$core$Native_Scheduler$iife_private$fail(error) {
		return {
			ctor: '_Task_fail',
			value: error
		};
	}

	// TASKS

	function _elm_lang$core$Native_Scheduler$iife_private$succeed(value) {
		return {
			ctor: '_Task_succeed',
			value: value
		};
	}var _elm_lang$core$Native_Platform = {},
	    _elm_lang$core$Native_Platform$iife_private$effectManagers = {},
	    _elm_lang$core$Native_Platform$iife_private$outgoingPortMap = /*#__PURE__*/F2(function cmdMap(tagger, value) {
		return value;
	}),
	    _elm_lang$core$Native_Platform$iife_private$incomingPortMap = /*#__PURE__*/F2(function subMap(tagger, finalTagger) {
		return function (value) {
			return tagger(finalTagger(value));
		};
	}),
	    _elm_lang$core$Native_Platform$iife_public$sendToApp = /*#__PURE__*/F2(_elm_lang$core$Native_Platform$iife_private$sendToApp),
	    _elm_lang$core$Native_Platform$iife_public$sendToSelf = /*#__PURE__*/F2(_elm_lang$core$Native_Platform$iife_private$sendToSelf),
	    _elm_lang$core$Native_Platform$iife_public$effectManagers = _elm_lang$core$Native_Platform$iife_private$effectManagers,
	    _elm_lang$core$Native_Platform$iife_public$outgoingPort = _elm_lang$core$Native_Platform$iife_private$outgoingPort,
	    _elm_lang$core$Native_Platform$iife_public$incomingPort = _elm_lang$core$Native_Platform$iife_private$incomingPort,
	    _elm_lang$core$Native_Platform$iife_public$htmlToProgram = _elm_lang$core$Native_Platform$iife_private$htmlToProgram,
	    _elm_lang$core$Native_Platform$iife_public$program = _elm_lang$core$Native_Platform$iife_private$program,
	    _elm_lang$core$Native_Platform$iife_public$programWithFlags = _elm_lang$core$Native_Platform$iife_private$programWithFlags,
	    _elm_lang$core$Native_Platform$iife_public$initialize = _elm_lang$core$Native_Platform$iife_private$initialize,
	    _elm_lang$core$Native_Platform$iife_public$leaf = _elm_lang$core$Native_Platform$iife_private$leaf,
	    _elm_lang$core$Native_Platform$iife_public$batch = _elm_lang$core$Native_Platform$iife_private$batch,
	    _elm_lang$core$Native_Platform$iife_public$map = /*#__PURE__*/F2(_elm_lang$core$Native_Platform$iife_private$map);

	function _elm_lang$core$Native_Platform$iife_private$setupIncomingPort(name, callback) {
		var sentBeforeInit = [];
		var subs = _elm_lang$core$Native_List$iife_public$Nil;
		var converter = _elm_lang$core$Native_Platform$iife_private$effectManagers[name].converter;
		var currentOnEffects = preInitOnEffects;
		var currentSend = preInitSend;

		// CREATE MANAGER

		var init = _elm_lang$core$Native_Scheduler$iife_public$succeed(null);

		function preInitOnEffects(router, subList, state) {
			var postInitResult = postInitOnEffects(router, subList, state);

			for (var i = 0; i < sentBeforeInit.length; i++) {
				postInitSend(sentBeforeInit[i]);
			}

			sentBeforeInit = null; // to release objects held in queue
			currentSend = postInitSend;
			currentOnEffects = postInitOnEffects;
			return postInitResult;
		}

		function postInitOnEffects(router, subList, state) {
			subs = subList;
			return init;
		}

		function onEffects(router, subList, state) {
			return currentOnEffects(router, subList, state);
		}

		_elm_lang$core$Native_Platform$iife_private$effectManagers[name].init = init;
		_elm_lang$core$Native_Platform$iife_private$effectManagers[name].onEffects = /*#__PURE__*/F3(onEffects);

		// PUBLIC API

		function preInitSend(value) {
			sentBeforeInit.push(value);
		}

		function postInitSend(value) {
			var temp = subs;
			while (temp.ctor !== '[]') {
				callback(temp._0(value));
				temp = temp._1;
			}
		}

		function send(incomingValue) {
			var result = A2(_elm_lang$core$Json_Decode$decodeValue, converter, incomingValue);
			if (result.ctor === 'Err') {
				throw new Error('Trying to send an unexpected type of value through port `' + name + '`:\n' + result._0);
			}

			currentSend(result._0);
		}

		return { send: send };
	}

	// INCOMING PORTS

	function _elm_lang$core$Native_Platform$iife_private$incomingPort(name, converter) {
		_elm_lang$core$Native_Platform$iife_private$checkPortName(name);
		_elm_lang$core$Native_Platform$iife_private$effectManagers[name] = {
			tag: 'sub',
			subMap: _elm_lang$core$Native_Platform$iife_private$incomingPortMap,
			converter: converter,
			isForeign: true
		};
		return (/*#__PURE__*/_elm_lang$core$Native_Platform$iife_private$leaf(name)
		);
	}

	function _elm_lang$core$Native_Platform$iife_private$setupOutgoingPort(name) {
		var subs = [];
		var converter = _elm_lang$core$Native_Platform$iife_private$effectManagers[name].converter;

		// CREATE MANAGER

		var init = _elm_lang$core$Native_Scheduler$iife_public$succeed(null);

		function onEffects(router, cmdList, state) {
			while (cmdList.ctor !== '[]') {
				// grab a separate reference to subs in case unsubscribe is called
				var currentSubs = subs;
				var value = converter(cmdList._0);
				for (var i = 0; i < currentSubs.length; i++) {
					currentSubs[i](value);
				}
				cmdList = cmdList._1;
			}
			return init;
		}

		_elm_lang$core$Native_Platform$iife_private$effectManagers[name].init = init;
		_elm_lang$core$Native_Platform$iife_private$effectManagers[name].onEffects = /*#__PURE__*/F3(onEffects);

		// PUBLIC API

		function subscribe(callback) {
			subs.push(callback);
		}

		function unsubscribe(callback) {
			// copy subs into a new array in case unsubscribe is called within a
			// subscribed callback
			subs = subs.slice();
			var index = subs.indexOf(callback);
			if (index >= 0) {
				subs.splice(index, 1);
			}
		}

		return {
			subscribe: subscribe,
			unsubscribe: unsubscribe
		};
	}

	// OUTGOING PORTS

	function _elm_lang$core$Native_Platform$iife_private$outgoingPort(name, converter) {
		_elm_lang$core$Native_Platform$iife_private$checkPortName(name);
		_elm_lang$core$Native_Platform$iife_private$effectManagers[name] = {
			tag: 'cmd',
			cmdMap: _elm_lang$core$Native_Platform$iife_private$outgoingPortMap,
			converter: converter,
			isForeign: true
		};
		return (/*#__PURE__*/_elm_lang$core$Native_Platform$iife_private$leaf(name)
		);
	}

	// PORTS

	function _elm_lang$core$Native_Platform$iife_private$checkPortName(name) {
		if (name in _elm_lang$core$Native_Platform$iife_private$effectManagers) {
			throw new Error('There can only be one port named `' + name + '`, but your program has multiple.');
		}
	}

	function _elm_lang$core$Native_Platform$iife_private$insert(isCmd, newEffect, effects) {
		effects = effects || {
			cmds: _elm_lang$core$Native_List$iife_public$Nil,
			subs: _elm_lang$core$Native_List$iife_public$Nil
		};
		if (isCmd) {
			effects.cmds = _elm_lang$core$Native_List$iife_public$Cons(newEffect, effects.cmds);
			return effects;
		}
		effects.subs = _elm_lang$core$Native_List$iife_public$Cons(newEffect, effects.subs);
		return effects;
	}

	function _elm_lang$core$Native_Platform$iife_private$toEffect(isCmd, home, taggers, value) {
		function applyTaggers(x) {
			var temp = taggers;
			while (temp) {
				x = temp.tagger(x);
				temp = temp.rest;
			}
			return x;
		}

		var map = isCmd ? _elm_lang$core$Native_Platform$iife_private$effectManagers[home].cmdMap : _elm_lang$core$Native_Platform$iife_private$effectManagers[home].subMap;

		return A2(map, applyTaggers, value);
	}

	function _elm_lang$core$Native_Platform$iife_private$gatherEffects(isCmd, bag, effectsDict, taggers) {
		switch (bag.type) {
			case 'leaf':
				var home = bag.home;
				var effect = _elm_lang$core$Native_Platform$iife_private$toEffect(isCmd, home, taggers, bag.value);
				effectsDict[home] = _elm_lang$core$Native_Platform$iife_private$insert(isCmd, effect, effectsDict[home]);
				return;

			case 'node':
				var list = bag.branches;
				while (list.ctor !== '[]') {
					_elm_lang$core$Native_Platform$iife_private$gatherEffects(isCmd, list._0, effectsDict, taggers);
					list = list._1;
				}
				return;

			case 'map':
				_elm_lang$core$Native_Platform$iife_private$gatherEffects(isCmd, bag.tree, effectsDict, {
					tagger: bag.tagger,
					rest: taggers
				});
				return;
		}
	}

	// PIPE BAGS INTO EFFECT MANAGERS

	function _elm_lang$core$Native_Platform$iife_private$dispatchEffects(managers, cmdBag, subBag) {
		var effectsDict = {};
		_elm_lang$core$Native_Platform$iife_private$gatherEffects(true, cmdBag, effectsDict, null);
		_elm_lang$core$Native_Platform$iife_private$gatherEffects(false, subBag, effectsDict, null);

		for (var home in managers) {
			var fx = home in effectsDict ? effectsDict[home] : {
				cmds: _elm_lang$core$Native_List$iife_public$Nil,
				subs: _elm_lang$core$Native_List$iife_public$Nil
			};

			_elm_lang$core$Native_Scheduler$iife_public$rawSend(managers[home], { ctor: 'fx', _0: fx });
		}
	}

	function _elm_lang$core$Native_Platform$iife_private$map(tagger, bag) {
		return {
			type: 'map',
			tagger: tagger,
			tree: bag
		};
	}

	function _elm_lang$core$Native_Platform$iife_private$batch(list) {
		return {
			type: 'node',
			branches: list
		};
	}

	// BAGS

	function _elm_lang$core$Native_Platform$iife_private$leaf(home) {
		return function (value) {
			return {
				type: 'leaf',
				home: home,
				value: value
			};
		};
	}

	// HELPER for STATEFUL LOOPS

	function _elm_lang$core$Native_Platform$iife_private$spawnLoop(init, onMessage) {
		var andThen = _elm_lang$core$Native_Scheduler$iife_public$andThen;

		function loop(state) {
			var handleMsg = _elm_lang$core$Native_Scheduler$iife_public$receive(function (msg) {
				return onMessage(msg, state);
			});
			return A2(andThen, loop, handleMsg);
		}

		var task = A2(andThen, loop, init);

		return _elm_lang$core$Native_Scheduler$iife_public$rawSpawn(task);
	}

	function _elm_lang$core$Native_Platform$iife_private$sendToSelf(router, msg) {
		return A2(_elm_lang$core$Native_Scheduler$iife_public$send, router.self, {
			ctor: 'self',
			_0: msg
		});
	}

	function _elm_lang$core$Native_Platform$iife_private$sendToApp(router, msg) {
		return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function (callback) {
			router.main(msg);
			callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(_elm_lang$core$Native_Utils$iife_public$Tuple0));
		});
	}

	function _elm_lang$core$Native_Platform$iife_private$makeManager(info, callback) {
		var router = {
			main: callback,
			self: undefined
		};

		var tag = info.tag;
		var onEffects = info.onEffects;
		var onSelfMsg = info.onSelfMsg;

		function onMessage(msg, state) {
			if (msg.ctor === 'self') {
				return A3(onSelfMsg, router, msg._0, state);
			}

			var fx = msg._0;
			switch (tag) {
				case 'cmd':
					return A3(onEffects, router, fx.cmds, state);

				case 'sub':
					return A3(onEffects, router, fx.subs, state);

				case 'fx':
					return A4(onEffects, router, fx.cmds, fx.subs, state);
			}
		}

		var process = _elm_lang$core$Native_Platform$iife_private$spawnLoop(info.init, onMessage);
		router.self = process;
		return process;
	}

	function _elm_lang$core$Native_Platform$iife_private$setupEffects(managers, callback) {
		var ports;

		// setup all necessary effect managers
		for (var key in _elm_lang$core$Native_Platform$iife_private$effectManagers) {
			var manager = _elm_lang$core$Native_Platform$iife_private$effectManagers[key];

			if (manager.isForeign) {
				ports = ports || {};
				ports[key] = manager.tag === 'cmd' ? _elm_lang$core$Native_Platform$iife_private$setupOutgoingPort(key) : _elm_lang$core$Native_Platform$iife_private$setupIncomingPort(key, callback);
			}

			managers[key] = _elm_lang$core$Native_Platform$iife_private$makeManager(manager, callback);
		}

		return ports;
	}

	// INITIALIZE A PROGRAM

	function _elm_lang$core$Native_Platform$iife_private$initialize(init, update, subscriptions, renderer) {
		// ambient state
		var managers = {};
		var updateView;

		// init and update state in main process
		var initApp = _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function (callback) {
			var model = init._0;
			updateView = renderer(enqueue, model);
			var cmds = init._1;
			var subs = subscriptions(model);
			_elm_lang$core$Native_Platform$iife_private$dispatchEffects(managers, cmds, subs);
			callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(model));
		});

		function onMessage(msg, model) {
			return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function (callback) {
				var results = A2(update, msg, model);
				model = results._0;
				updateView(model);
				var cmds = results._1;
				var subs = subscriptions(model);
				_elm_lang$core$Native_Platform$iife_private$dispatchEffects(managers, cmds, subs);
				callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(model));
			});
		}

		var mainProcess = _elm_lang$core$Native_Platform$iife_private$spawnLoop(initApp, onMessage);

		function enqueue(msg) {
			_elm_lang$core$Native_Scheduler$iife_public$rawSend(mainProcess, msg);
		}

		var ports = _elm_lang$core$Native_Platform$iife_private$setupEffects(managers, enqueue);

		return ports ? { ports: ports } : {};
	}

	// EFFECT MANAGERS

	// HTML TO PROGRAM

	function _elm_lang$core$Native_Platform$iife_private$htmlToProgram(vnode) {
		var emptyBag = _elm_lang$core$Native_Platform$iife_private$batch(_elm_lang$core$Native_List$iife_public$Nil);
		var noChange = _elm_lang$core$Native_Utils$iife_public$Tuple2(_elm_lang$core$Native_Utils$iife_public$Tuple0, emptyBag);

		return _elm_lang$virtual_dom$VirtualDom$program({
			init: noChange,
			view: function (model) {
				return main;
			},
			update: /*#__PURE__*/F2(function (msg, model) {
				return noChange;
			}),
			subscriptions: function (model) {
				return emptyBag;
			}
		});
	}

	function _elm_lang$core$Native_Platform$iife_private$renderer(enqueue, _) {
		return function (_) {};
	}

	function _elm_lang$core$Native_Platform$iife_private$programWithFlags(impl) {
		return function (flagDecoder) {
			return function (object, moduleName) {
				object['worker'] = function worker(flags) {
					if (typeof flagDecoder === 'undefined') {
						throw new Error('Are you trying to sneak a Never value into Elm? Trickster!\n' + 'It looks like ' + moduleName + '.main is defined with `programWithFlags` but has type `Program Never`.\n' + 'Use `program` instead if you do not want flags.');
					}

					var result = A2(_elm_lang$core$Native_Json$iife_public$run, flagDecoder, flags);
					if (result.ctor === 'Err') {
						throw new Error(moduleName + '.worker(...) was called with an unexpected argument.\n' + 'I tried to convert it to an Elm value, but ran into this problem:\n\n' + result._0);
					}

					return _elm_lang$core$Native_Platform$iife_private$initialize(impl.init(result._0), impl.update, impl.subscriptions, _elm_lang$core$Native_Platform$iife_private$renderer);
				};
			};
		};
	}

	// PROGRAMS

	function _elm_lang$core$Native_Platform$iife_private$program(impl) {
		return function (flagDecoder) {
			return function (object, moduleName) {
				object['worker'] = function worker(flags) {
					if (typeof flags !== 'undefined') {
						throw new Error('The `' + moduleName + '` module does not need flags.\n' + 'Call ' + moduleName + '.worker() with no arguments and you should be all set!');
					}

					return _elm_lang$core$Native_Platform$iife_private$initialize(impl.init, impl.update, impl.subscriptions, _elm_lang$core$Native_Platform$iife_private$renderer);
				};
			};
		};
	}var _elm_lang$core$Platform_Cmd$batch = _elm_lang$core$Native_Platform$iife_public$batch;
	var _elm_lang$core$Platform_Cmd$none = /*#__PURE__*/_elm_lang$core$Platform_Cmd$batch({ ctor: '[]' });
	var _elm_lang$core$Platform_Cmd_ops = _elm_lang$core$Platform_Cmd_ops || {};
	_elm_lang$core$Platform_Cmd_ops['!'] = /*#__PURE__*/F2(function (model, commands) {
		return {
			ctor: '_Tuple2',
			_0: model,
			_1: /*#__PURE__*/_elm_lang$core$Platform_Cmd$batch(commands)
		};
	});
	var _elm_lang$core$Platform_Cmd$map = _elm_lang$core$Native_Platform$iife_public$map;
	var _elm_lang$core$Platform_Cmd$Cmd = { ctor: 'Cmd' };

	var _elm_lang$core$Platform_Sub$batch = _elm_lang$core$Native_Platform$iife_public$batch;
	var _elm_lang$core$Platform_Sub$none = _elm_lang$core$Platform_Sub$batch({ ctor: '[]' });
	var _elm_lang$core$Platform_Sub$map = _elm_lang$core$Native_Platform$iife_public$map;
	var _elm_lang$core$Platform_Sub$Sub = { ctor: 'Sub' };

	var _elm_lang$core$Platform$hack = _elm_lang$core$Native_Scheduler$iife_public$succeed;
	var _elm_lang$core$Platform$sendToSelf = _elm_lang$core$Native_Platform$iife_public$sendToSelf;
	var _elm_lang$core$Platform$sendToApp = _elm_lang$core$Native_Platform$iife_public$sendToApp;
	var _elm_lang$core$Platform$programWithFlags = _elm_lang$core$Native_Platform$iife_public$programWithFlags;
	var _elm_lang$core$Platform$program = _elm_lang$core$Native_Platform$iife_public$program;
	var _elm_lang$core$Platform$Program = { ctor: 'Program' };
	var _elm_lang$core$Platform$Task = { ctor: 'Task' };
	var _elm_lang$core$Platform$ProcessId = { ctor: 'ProcessId' };
	var _elm_lang$core$Platform$Router = { ctor: 'Router' };

	var _elm_lang$core$Result$toMaybe = function (result) {
		var _p0 = result;
		if (_p0.ctor === 'Ok') {
			return _elm_lang$core$Maybe$Just(_p0._0);
		} else {
			return _elm_lang$core$Maybe$Nothing;
		}
	};
	var _elm_lang$core$Result$withDefault = /*#__PURE__*/F2(function (def, result) {
		var _p1 = result;
		if (_p1.ctor === 'Ok') {
			return _p1._0;
		} else {
			return def;
		}
	});
	var _elm_lang$core$Result$Err = function (a) {
		return { ctor: 'Err', _0: a };
	};
	var _elm_lang$core$Result$andThen = /*#__PURE__*/F2(function (callback, result) {
		var _p2 = result;
		if (_p2.ctor === 'Ok') {
			return callback(_p2._0);
		} else {
			return _elm_lang$core$Result$Err(_p2._0);
		}
	});
	var _elm_lang$core$Result$Ok = function (a) {
		return { ctor: 'Ok', _0: a };
	};
	var _elm_lang$core$Result$map = /*#__PURE__*/F2(function (func, ra) {
		var _p3 = ra;
		if (_p3.ctor === 'Ok') {
			return _elm_lang$core$Result$Ok(func(_p3._0));
		} else {
			return _elm_lang$core$Result$Err(_p3._0);
		}
	});
	var _elm_lang$core$Result$map2 = /*#__PURE__*/F3(function (func, ra, rb) {
		var _p4 = { ctor: '_Tuple2', _0: ra, _1: rb };
		if (_p4._0.ctor === 'Ok') {
			if (_p4._1.ctor === 'Ok') {
				return _elm_lang$core$Result$Ok(A2(func, _p4._0._0, _p4._1._0));
			} else {
				return _elm_lang$core$Result$Err(_p4._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p4._0._0);
		}
	});
	var _elm_lang$core$Result$map3 = /*#__PURE__*/F4(function (func, ra, rb, rc) {
		var _p5 = { ctor: '_Tuple3', _0: ra, _1: rb, _2: rc };
		if (_p5._0.ctor === 'Ok') {
			if (_p5._1.ctor === 'Ok') {
				if (_p5._2.ctor === 'Ok') {
					return _elm_lang$core$Result$Ok(A3(func, _p5._0._0, _p5._1._0, _p5._2._0));
				} else {
					return _elm_lang$core$Result$Err(_p5._2._0);
				}
			} else {
				return _elm_lang$core$Result$Err(_p5._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p5._0._0);
		}
	});
	var _elm_lang$core$Result$map4 = /*#__PURE__*/F5(function (func, ra, rb, rc, rd) {
		var _p6 = { ctor: '_Tuple4', _0: ra, _1: rb, _2: rc, _3: rd };
		if (_p6._0.ctor === 'Ok') {
			if (_p6._1.ctor === 'Ok') {
				if (_p6._2.ctor === 'Ok') {
					if (_p6._3.ctor === 'Ok') {
						return _elm_lang$core$Result$Ok(A4(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0));
					} else {
						return _elm_lang$core$Result$Err(_p6._3._0);
					}
				} else {
					return _elm_lang$core$Result$Err(_p6._2._0);
				}
			} else {
				return _elm_lang$core$Result$Err(_p6._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p6._0._0);
		}
	});
	var _elm_lang$core$Result$map5 = /*#__PURE__*/F6(function (func, ra, rb, rc, rd, re) {
		var _p7 = { ctor: '_Tuple5', _0: ra, _1: rb, _2: rc, _3: rd, _4: re };
		if (_p7._0.ctor === 'Ok') {
			if (_p7._1.ctor === 'Ok') {
				if (_p7._2.ctor === 'Ok') {
					if (_p7._3.ctor === 'Ok') {
						if (_p7._4.ctor === 'Ok') {
							return _elm_lang$core$Result$Ok(A5(func, _p7._0._0, _p7._1._0, _p7._2._0, _p7._3._0, _p7._4._0));
						} else {
							return _elm_lang$core$Result$Err(_p7._4._0);
						}
					} else {
						return _elm_lang$core$Result$Err(_p7._3._0);
					}
				} else {
					return _elm_lang$core$Result$Err(_p7._2._0);
				}
			} else {
				return _elm_lang$core$Result$Err(_p7._1._0);
			}
		} else {
			return _elm_lang$core$Result$Err(_p7._0._0);
		}
	});
	var _elm_lang$core$Result$mapError = /*#__PURE__*/F2(function (f, result) {
		var _p8 = result;
		if (_p8.ctor === 'Ok') {
			return _elm_lang$core$Result$Ok(_p8._0);
		} else {
			return _elm_lang$core$Result$Err(f(_p8._0));
		}
	});
	var _elm_lang$core$Result$fromMaybe = /*#__PURE__*/F2(function (err, maybe) {
		var _p9 = maybe;
		if (_p9.ctor === 'Just') {
			return _elm_lang$core$Result$Ok(_p9._0);
		} else {
			return _elm_lang$core$Result$Err(err);
		}
	});

	var _elm_lang$core$Task$onError = _elm_lang$core$Native_Scheduler$iife_public$onError;
	var _elm_lang$core$Task$andThen = _elm_lang$core$Native_Scheduler$iife_public$andThen;
	var _elm_lang$core$Task$spawnCmd = /*#__PURE__*/F2(function (router, _p0) {
		var _p1 = _p0;
		return _elm_lang$core$Native_Scheduler$iife_public$spawn(A2(_elm_lang$core$Task$andThen, _elm_lang$core$Platform$sendToApp(router), _p1._0));
	});
	var _elm_lang$core$Task$fail = _elm_lang$core$Native_Scheduler$iife_public$fail;
	var _elm_lang$core$Task$mapError = /*#__PURE__*/F2(function (convert, task) {
		return A2(_elm_lang$core$Task$onError, function (_p2) {
			return _elm_lang$core$Task$fail(convert(_p2));
		}, task);
	});
	var _elm_lang$core$Task$succeed = _elm_lang$core$Native_Scheduler$iife_public$succeed;
	var _elm_lang$core$Task$map = /*#__PURE__*/F2(function (func, taskA) {
		return A2(_elm_lang$core$Task$andThen, function (a) {
			return _elm_lang$core$Task$succeed(func(a));
		}, taskA);
	});
	var _elm_lang$core$Task$map2 = /*#__PURE__*/F3(function (func, taskA, taskB) {
		return A2(_elm_lang$core$Task$andThen, function (a) {
			return A2(_elm_lang$core$Task$andThen, function (b) {
				return _elm_lang$core$Task$succeed(A2(func, a, b));
			}, taskB);
		}, taskA);
	});
	var _elm_lang$core$Task$map3 = /*#__PURE__*/F4(function (func, taskA, taskB, taskC) {
		return A2(_elm_lang$core$Task$andThen, function (a) {
			return A2(_elm_lang$core$Task$andThen, function (b) {
				return A2(_elm_lang$core$Task$andThen, function (c) {
					return _elm_lang$core$Task$succeed(A3(func, a, b, c));
				}, taskC);
			}, taskB);
		}, taskA);
	});
	var _elm_lang$core$Task$map4 = /*#__PURE__*/F5(function (func, taskA, taskB, taskC, taskD) {
		return A2(_elm_lang$core$Task$andThen, function (a) {
			return A2(_elm_lang$core$Task$andThen, function (b) {
				return A2(_elm_lang$core$Task$andThen, function (c) {
					return A2(_elm_lang$core$Task$andThen, function (d) {
						return _elm_lang$core$Task$succeed(A4(func, a, b, c, d));
					}, taskD);
				}, taskC);
			}, taskB);
		}, taskA);
	});
	var _elm_lang$core$Task$map5 = /*#__PURE__*/F6(function (func, taskA, taskB, taskC, taskD, taskE) {
		return A2(_elm_lang$core$Task$andThen, function (a) {
			return A2(_elm_lang$core$Task$andThen, function (b) {
				return A2(_elm_lang$core$Task$andThen, function (c) {
					return A2(_elm_lang$core$Task$andThen, function (d) {
						return A2(_elm_lang$core$Task$andThen, function (e) {
							return _elm_lang$core$Task$succeed(A5(func, a, b, c, d, e));
						}, taskE);
					}, taskD);
				}, taskC);
			}, taskB);
		}, taskA);
	});
	var _elm_lang$core$Task$sequence = function (tasks) {
		var _p3 = tasks;
		if (_p3.ctor === '[]') {
			return _elm_lang$core$Task$succeed({ ctor: '[]' });
		} else {
			return A3(_elm_lang$core$Task$map2, /*#__PURE__*/F2(function (x, y) {
				return { ctor: '::', _0: x, _1: y };
			}), _p3._0, _elm_lang$core$Task$sequence(_p3._1));
		}
	};
	var _elm_lang$core$Task$onEffects = /*#__PURE__*/F3(function (router, commands, state) {
		return A2(_elm_lang$core$Task$map, function (_p4) {
			return { ctor: '_Tuple0' };
		}, _elm_lang$core$Task$sequence(A2(_elm_lang$core$List$map, _elm_lang$core$Task$spawnCmd(router), commands)));
	});
	var _elm_lang$core$Task$init = _elm_lang$core$Task$succeed({ ctor: '_Tuple0' });
	var _elm_lang$core$Task$onSelfMsg = /*#__PURE__*/F3(function (_p7, _p6, _p5) {
		return _elm_lang$core$Task$succeed({ ctor: '_Tuple0' });
	});
	var _elm_lang$core$Task$command = /*#__PURE__*/_elm_lang$core$Native_Platform$iife_public$leaf('Task');
	var _elm_lang$core$Task$Perform = function (a) {
		return { ctor: 'Perform', _0: a };
	};
	var _elm_lang$core$Task$perform = /*#__PURE__*/F2(function (toMessage, task) {
		return _elm_lang$core$Task$command(_elm_lang$core$Task$Perform(A2(_elm_lang$core$Task$map, toMessage, task)));
	});
	var _elm_lang$core$Task$attempt = /*#__PURE__*/F2(function (resultToMessage, task) {
		return _elm_lang$core$Task$command(_elm_lang$core$Task$Perform(A2(_elm_lang$core$Task$onError, function (_p8) {
			return _elm_lang$core$Task$succeed(resultToMessage(_elm_lang$core$Result$Err(_p8)));
		}, A2(_elm_lang$core$Task$andThen, function (_p9) {
			return _elm_lang$core$Task$succeed(resultToMessage(_elm_lang$core$Result$Ok(_p9)));
		}, task))));
	});
	var _elm_lang$core$Task$cmdMap = /*#__PURE__*/F2(function (tagger, _p10) {
		var _p11 = _p10;
		return _elm_lang$core$Task$Perform(A2(_elm_lang$core$Task$map, tagger, _p11._0));
	});
	_elm_lang$core$Native_Platform$iife_public$effectManagers['Task'] = { pkg: 'elm-lang/core', init: _elm_lang$core$Task$init, onEffects: _elm_lang$core$Task$onEffects, onSelfMsg: _elm_lang$core$Task$onSelfMsg, tag: 'cmd', cmdMap: _elm_lang$core$Task$cmdMap };

	//import Native.Utils //

	var _elm_lang$core$Native_Debug = {},
	    _elm_lang$core$Native_Debug$iife_public$crash = _elm_lang$core$Native_Debug$iife_private$crash,
	    _elm_lang$core$Native_Debug$iife_public$log = /*#__PURE__*/F2(_elm_lang$core$Native_Debug$iife_private$log);
	//import Maybe, Native.List, Native.Utils, Result //

	function _elm_lang$core$Native_Debug$iife_private$crash(message) {
		throw new Error(message);
	}

	function _elm_lang$core$Native_Debug$iife_private$log(tag, value) {
		var msg = tag + ': ' + _elm_lang$core$Native_Utils$iife_public$toString(value);
		var process = process || {};
		if (process.stdout) {
			process.stdout.write(msg);
		} else {
			console.log(msg);
		}
		return value;
	}var _elm_lang$core$Native_String = {},
	    _elm_lang$core$Native_String$iife_public$isEmpty = _elm_lang$core$Native_String$iife_private$isEmpty,
	    _elm_lang$core$Native_String$iife_public$cons = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$cons),
	    _elm_lang$core$Native_String$iife_public$uncons = _elm_lang$core$Native_String$iife_private$uncons,
	    _elm_lang$core$Native_String$iife_public$append = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$append),
	    _elm_lang$core$Native_String$iife_public$concat = _elm_lang$core$Native_String$iife_private$concat,
	    _elm_lang$core$Native_String$iife_public$length = _elm_lang$core$Native_String$iife_private$length,
	    _elm_lang$core$Native_String$iife_public$map = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$map),
	    _elm_lang$core$Native_String$iife_public$filter = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$filter),
	    _elm_lang$core$Native_String$iife_public$reverse = _elm_lang$core$Native_String$iife_private$reverse,
	    _elm_lang$core$Native_String$iife_public$foldl = /*#__PURE__*/F3(_elm_lang$core$Native_String$iife_private$foldl),
	    _elm_lang$core$Native_String$iife_public$foldr = /*#__PURE__*/F3(_elm_lang$core$Native_String$iife_private$foldr),
	    _elm_lang$core$Native_String$iife_public$split = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$split),
	    _elm_lang$core$Native_String$iife_public$join = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$join),
	    _elm_lang$core$Native_String$iife_public$repeat = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$repeat),
	    _elm_lang$core$Native_String$iife_public$slice = /*#__PURE__*/F3(_elm_lang$core$Native_String$iife_private$slice),
	    _elm_lang$core$Native_String$iife_public$left = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$left),
	    _elm_lang$core$Native_String$iife_public$right = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$right),
	    _elm_lang$core$Native_String$iife_public$dropLeft = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$dropLeft),
	    _elm_lang$core$Native_String$iife_public$dropRight = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$dropRight),
	    _elm_lang$core$Native_String$iife_public$pad = /*#__PURE__*/F3(_elm_lang$core$Native_String$iife_private$pad),
	    _elm_lang$core$Native_String$iife_public$padLeft = /*#__PURE__*/F3(_elm_lang$core$Native_String$iife_private$padLeft),
	    _elm_lang$core$Native_String$iife_public$padRight = /*#__PURE__*/F3(_elm_lang$core$Native_String$iife_private$padRight),
	    _elm_lang$core$Native_String$iife_public$trim = _elm_lang$core$Native_String$iife_private$trim,
	    _elm_lang$core$Native_String$iife_public$trimLeft = _elm_lang$core$Native_String$iife_private$trimLeft,
	    _elm_lang$core$Native_String$iife_public$trimRight = _elm_lang$core$Native_String$iife_private$trimRight,
	    _elm_lang$core$Native_String$iife_public$words = _elm_lang$core$Native_String$iife_private$words,
	    _elm_lang$core$Native_String$iife_public$lines = _elm_lang$core$Native_String$iife_private$lines,
	    _elm_lang$core$Native_String$iife_public$toUpper = _elm_lang$core$Native_String$iife_private$toUpper,
	    _elm_lang$core$Native_String$iife_public$toLower = _elm_lang$core$Native_String$iife_private$toLower,
	    _elm_lang$core$Native_String$iife_public$any = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$any),
	    _elm_lang$core$Native_String$iife_public$all = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$all),
	    _elm_lang$core$Native_String$iife_public$contains = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$contains),
	    _elm_lang$core$Native_String$iife_public$startsWith = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$startsWith),
	    _elm_lang$core$Native_String$iife_public$endsWith = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$endsWith),
	    _elm_lang$core$Native_String$iife_public$indexes = /*#__PURE__*/F2(_elm_lang$core$Native_String$iife_private$indexes),
	    _elm_lang$core$Native_String$iife_public$toInt = _elm_lang$core$Native_String$iife_private$toInt,
	    _elm_lang$core$Native_String$iife_public$toFloat = _elm_lang$core$Native_String$iife_private$toFloat,
	    _elm_lang$core$Native_String$iife_public$toList = _elm_lang$core$Native_String$iife_private$toList,
	    _elm_lang$core$Native_String$iife_public$fromList = _elm_lang$core$Native_String$iife_private$fromList;

	function _elm_lang$core$Native_String$iife_private$fromList(chars) {
		return _elm_lang$core$Native_List$iife_public$toArray(chars).join('');
	}

	function _elm_lang$core$Native_String$iife_private$toList(str) {
		return _elm_lang$core$Native_List$iife_public$fromArray(str.split('').map(_elm_lang$core$Native_Utils$iife_public$chr));
	}

	function _elm_lang$core$Native_String$iife_private$floatErr(s) {
		return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float");
	}

	function _elm_lang$core$Native_String$iife_private$toFloat(s) {
		// check if it is a hex, octal, or binary number
		if (s.length === 0 || /[\sxbo]/.test(s)) {
			return _elm_lang$core$Native_String$iife_private$floatErr(s);
		}
		var n = +s;
		// faster isNaN check
		return n === n ? _elm_lang$core$Result$Ok(n) : _elm_lang$core$Native_String$iife_private$floatErr(s);
	}

	function _elm_lang$core$Native_String$iife_private$intErr(s) {
		return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int");
	}

	function _elm_lang$core$Native_String$iife_private$toInt(s) {
		var len = s.length;

		// if empty
		if (len === 0) {
			return _elm_lang$core$Native_String$iife_private$intErr(s);
		}

		// if hex
		var c = s[0];
		if (c === '0' && s[1] === 'x') {
			for (var i = 2; i < len; ++i) {
				var c = s[i];
				if ('0' <= c && c <= '9' || 'A' <= c && c <= 'F' || 'a' <= c && c <= 'f') {
					continue;
				}
				return _elm_lang$core$Native_String$iife_private$intErr(s);
			}
			return _elm_lang$core$Result$Ok(parseInt(s, 16));
		}

		// is decimal
		if (c > '9' || c < '0' && c !== '-' && c !== '+') {
			return _elm_lang$core$Native_String$iife_private$intErr(s);
		}
		for (var i = 1; i < len; ++i) {
			var c = s[i];
			if (c < '0' || '9' < c) {
				return _elm_lang$core$Native_String$iife_private$intErr(s);
			}
		}

		return _elm_lang$core$Result$Ok(parseInt(s, 10));
	}
	function _elm_lang$core$Native_String$iife_private$indexes(sub, str) {
		var subLen = sub.length;

		if (subLen < 1) {
			return _elm_lang$core$Native_List$iife_public$Nil;
		}

		var i = 0;
		var is = [];

		while ((i = str.indexOf(sub, i)) > -1) {
			is.push(i);
			i = i + subLen;
		}

		return _elm_lang$core$Native_List$iife_public$fromArray(is);
	}
	function _elm_lang$core$Native_String$iife_private$endsWith(sub, str) {
		return str.length >= sub.length && str.lastIndexOf(sub) === str.length - sub.length;
	}
	function _elm_lang$core$Native_String$iife_private$startsWith(sub, str) {
		return str.indexOf(sub) === 0;
	}

	function _elm_lang$core$Native_String$iife_private$contains(sub, str) {
		return str.indexOf(sub) > -1;
	}
	function _elm_lang$core$Native_String$iife_private$all(pred, str) {
		for (var i = str.length; i--;) {
			if (!pred( /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(str[i]))) {
				return false;
			}
		}
		return true;
	}

	function _elm_lang$core$Native_String$iife_private$any(pred, str) {
		for (var i = str.length; i--;) {
			if (pred( /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(str[i]))) {
				return true;
			}
		}
		return false;
	}
	function _elm_lang$core$Native_String$iife_private$toLower(str) {
		return str.toLowerCase();
	}

	function _elm_lang$core$Native_String$iife_private$toUpper(str) {
		return str.toUpperCase();
	}
	function _elm_lang$core$Native_String$iife_private$lines(str) {
		return _elm_lang$core$Native_List$iife_public$fromArray(str.split(/\r\n|\r|\n/g));
	}

	function _elm_lang$core$Native_String$iife_private$words(str) {
		return _elm_lang$core$Native_List$iife_public$fromArray(str.trim().split(/\s+/g));
	}
	function _elm_lang$core$Native_String$iife_private$trimRight(str) {
		return str.replace(/\s+$/, '');
	}
	function _elm_lang$core$Native_String$iife_private$trimLeft(str) {
		return str.replace(/^\s+/, '');
	}

	function _elm_lang$core$Native_String$iife_private$trim(str) {
		return str.trim();
	}
	function _elm_lang$core$Native_String$iife_private$padLeft(n, chr, str) {
		return _elm_lang$core$Native_String$iife_private$repeat(n - str.length, chr) + str;
	}
	function _elm_lang$core$Native_String$iife_private$padRight(n, chr, str) {
		return str + _elm_lang$core$Native_String$iife_private$repeat(n - str.length, chr);
	}
	function _elm_lang$core$Native_String$iife_private$pad(n, chr, str) {
		var half = (n - str.length) / 2;
		return _elm_lang$core$Native_String$iife_private$repeat(Math.ceil(half), chr) + str + _elm_lang$core$Native_String$iife_private$repeat(half | 0, chr);
	}
	function _elm_lang$core$Native_String$iife_private$dropRight(n, str) {
		return n < 1 ? str : str.slice(0, -n);
	}
	function _elm_lang$core$Native_String$iife_private$dropLeft(n, str) {
		return n < 1 ? str : str.slice(n);
	}
	function _elm_lang$core$Native_String$iife_private$right(n, str) {
		return n < 1 ? '' : str.slice(-n);
	}
	function _elm_lang$core$Native_String$iife_private$left(n, str) {
		return n < 1 ? '' : str.slice(0, n);
	}
	function _elm_lang$core$Native_String$iife_private$slice(start, end, str) {
		return str.slice(start, end);
	}
	function _elm_lang$core$Native_String$iife_private$repeat(n, str) {
		var result = '';
		while (n > 0) {
			if (n & 1) {
				result += str;
			}
			n >>= 1, str += str;
		}
		return result;
	}
	function _elm_lang$core$Native_String$iife_private$join(sep, strs) {
		return _elm_lang$core$Native_List$iife_public$toArray(strs).join(sep);
	}
	function _elm_lang$core$Native_String$iife_private$split(sep, str) {
		return _elm_lang$core$Native_List$iife_public$fromArray(str.split(sep));
	}
	function _elm_lang$core$Native_String$iife_private$foldr(f, b, str) {
		for (var i = str.length; i--;) {
			b = A2(f, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(str[i]), b);
		}
		return b;
	}
	function _elm_lang$core$Native_String$iife_private$foldl(f, b, str) {
		var len = str.length;
		for (var i = 0; i < len; ++i) {
			b = A2(f, /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(str[i]), b);
		}
		return b;
	}
	function _elm_lang$core$Native_String$iife_private$reverse(str) {
		return str.split('').reverse().join('');
	}
	function _elm_lang$core$Native_String$iife_private$filter(pred, str) {
		return str.split('').map(_elm_lang$core$Native_Utils$iife_public$chr).filter(pred).join('');
	}
	function _elm_lang$core$Native_String$iife_private$map(f, str) {
		var out = str.split('');
		for (var i = out.length; i--;) {
			out[i] = f( /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(out[i]));
		}
		return out.join('');
	}
	function _elm_lang$core$Native_String$iife_private$length(str) {
		return str.length;
	}
	function _elm_lang$core$Native_String$iife_private$concat(strs) {
		return _elm_lang$core$Native_List$iife_public$toArray(strs).join('');
	}
	function _elm_lang$core$Native_String$iife_private$append(a, b) {
		return a + b;
	}
	function _elm_lang$core$Native_String$iife_private$uncons(str) {
		var hd = str[0];
		if (hd) {
			return _elm_lang$core$Maybe$Just(_elm_lang$core$Native_Utils$iife_public$Tuple2( /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$chr(hd), str.slice(1)));
		}
		return _elm_lang$core$Maybe$Nothing;
	}
	function _elm_lang$core$Native_String$iife_private$cons(chr, str) {
		return chr + str;
	}

	function _elm_lang$core$Native_String$iife_private$isEmpty(str) {
		return str.length === 0;
	}var _elm_lang$core$String$fromList = _elm_lang$core$Native_String$iife_public$fromList;
	var _elm_lang$core$String$toList = _elm_lang$core$Native_String$iife_public$toList;
	var _elm_lang$core$String$toFloat = _elm_lang$core$Native_String$iife_public$toFloat;
	var _elm_lang$core$String$toInt = _elm_lang$core$Native_String$iife_public$toInt;
	var _elm_lang$core$String$indices = _elm_lang$core$Native_String$iife_public$indexes;
	var _elm_lang$core$String$indexes = _elm_lang$core$Native_String$iife_public$indexes;
	var _elm_lang$core$String$endsWith = _elm_lang$core$Native_String$iife_public$endsWith;
	var _elm_lang$core$String$startsWith = _elm_lang$core$Native_String$iife_public$startsWith;
	var _elm_lang$core$String$contains = _elm_lang$core$Native_String$iife_public$contains;
	var _elm_lang$core$String$all = _elm_lang$core$Native_String$iife_public$all;
	var _elm_lang$core$String$any = _elm_lang$core$Native_String$iife_public$any;
	var _elm_lang$core$String$toLower = _elm_lang$core$Native_String$iife_public$toLower;
	var _elm_lang$core$String$toUpper = _elm_lang$core$Native_String$iife_public$toUpper;
	var _elm_lang$core$String$lines = _elm_lang$core$Native_String$iife_public$lines;
	var _elm_lang$core$String$words = _elm_lang$core$Native_String$iife_public$words;
	var _elm_lang$core$String$trimRight = _elm_lang$core$Native_String$iife_public$trimRight;
	var _elm_lang$core$String$trimLeft = _elm_lang$core$Native_String$iife_public$trimLeft;
	var _elm_lang$core$String$trim = _elm_lang$core$Native_String$iife_public$trim;
	var _elm_lang$core$String$padRight = _elm_lang$core$Native_String$iife_public$padRight;
	var _elm_lang$core$String$padLeft = _elm_lang$core$Native_String$iife_public$padLeft;
	var _elm_lang$core$String$pad = _elm_lang$core$Native_String$iife_public$pad;
	var _elm_lang$core$String$dropRight = _elm_lang$core$Native_String$iife_public$dropRight;
	var _elm_lang$core$String$dropLeft = _elm_lang$core$Native_String$iife_public$dropLeft;
	var _elm_lang$core$String$right = _elm_lang$core$Native_String$iife_public$right;
	var _elm_lang$core$String$left = _elm_lang$core$Native_String$iife_public$left;
	var _elm_lang$core$String$slice = _elm_lang$core$Native_String$iife_public$slice;
	var _elm_lang$core$String$repeat = _elm_lang$core$Native_String$iife_public$repeat;
	var _elm_lang$core$String$join = _elm_lang$core$Native_String$iife_public$join;
	var _elm_lang$core$String$split = _elm_lang$core$Native_String$iife_public$split;
	var _elm_lang$core$String$foldr = _elm_lang$core$Native_String$iife_public$foldr;
	var _elm_lang$core$String$foldl = _elm_lang$core$Native_String$iife_public$foldl;
	var _elm_lang$core$String$reverse = _elm_lang$core$Native_String$iife_public$reverse;
	var _elm_lang$core$String$filter = _elm_lang$core$Native_String$iife_public$filter;
	var _elm_lang$core$String$map = _elm_lang$core$Native_String$iife_public$map;
	var _elm_lang$core$String$length = _elm_lang$core$Native_String$iife_public$length;
	var _elm_lang$core$String$concat = _elm_lang$core$Native_String$iife_public$concat;
	var _elm_lang$core$String$append = _elm_lang$core$Native_String$iife_public$append;
	var _elm_lang$core$String$uncons = _elm_lang$core$Native_String$iife_public$uncons;
	var _elm_lang$core$String$cons = _elm_lang$core$Native_String$iife_public$cons;
	var _elm_lang$core$String$fromChar = function ($char) {
		return A2(_elm_lang$core$String$cons, $char, '');
	};
	var _elm_lang$core$String$isEmpty = _elm_lang$core$Native_String$iife_public$isEmpty;

	var _elm_lang$core$Dict$foldr = /*#__PURE__*/F3(function (f, acc, t) {
		foldr: while (true) {
			var _p0 = t;
			if (_p0.ctor === 'RBEmpty_elm_builtin') {
				return acc;
			} else {
				var _v1 = f,
				    _v2 = A3(f, _p0._1, _p0._2, A3(_elm_lang$core$Dict$foldr, f, acc, _p0._4)),
				    _v3 = _p0._3;
				f = _v1;
				acc = _v2;
				t = _v3;
				continue foldr;
			}
		}
	});
	var _elm_lang$core$Dict$keys = function (dict) {
		return A3(_elm_lang$core$Dict$foldr, /*#__PURE__*/F3(function (key, value, keyList) {
			return { ctor: '::', _0: key, _1: keyList };
		}), { ctor: '[]' }, dict);
	};
	var _elm_lang$core$Dict$values = function (dict) {
		return A3(_elm_lang$core$Dict$foldr, /*#__PURE__*/F3(function (key, value, valueList) {
			return { ctor: '::', _0: value, _1: valueList };
		}), { ctor: '[]' }, dict);
	};
	var _elm_lang$core$Dict$toList = function (dict) {
		return A3(_elm_lang$core$Dict$foldr, /*#__PURE__*/F3(function (key, value, list) {
			return {
				ctor: '::',
				_0: { ctor: '_Tuple2', _0: key, _1: value },
				_1: list
			};
		}), { ctor: '[]' }, dict);
	};
	var _elm_lang$core$Dict$foldl = /*#__PURE__*/F3(function (f, acc, dict) {
		foldl: while (true) {
			var _p1 = dict;
			if (_p1.ctor === 'RBEmpty_elm_builtin') {
				return acc;
			} else {
				var _v5 = f,
				    _v6 = A3(f, _p1._1, _p1._2, A3(_elm_lang$core$Dict$foldl, f, acc, _p1._3)),
				    _v7 = _p1._4;
				f = _v5;
				acc = _v6;
				dict = _v7;
				continue foldl;
			}
		}
	});
	var _elm_lang$core$Dict$merge = /*#__PURE__*/F6(function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) {
		var stepState = /*#__PURE__*/F3(function (rKey, rValue, _p2) {
			stepState: while (true) {
				var _p3 = _p2;
				var _p9 = _p3._1;
				var _p8 = _p3._0;
				var _p4 = _p8;
				if (_p4.ctor === '[]') {
					return {
						ctor: '_Tuple2',
						_0: _p8,
						_1: A3(rightStep, rKey, rValue, _p9)
					};
				} else {
					var _p7 = _p4._1;
					var _p6 = _p4._0._1;
					var _p5 = _p4._0._0;
					if (_elm_lang$core$Native_Utils$iife_public$cmp(_p5, rKey) < 0) {
						var _v10 = rKey,
						    _v11 = rValue,
						    _v12 = {
							ctor: '_Tuple2',
							_0: _p7,
							_1: A3(leftStep, _p5, _p6, _p9)
						};
						rKey = _v10;
						rValue = _v11;
						_p2 = _v12;
						continue stepState;
					} else {
						if (_elm_lang$core$Native_Utils$iife_public$cmp(_p5, rKey) > 0) {
							return {
								ctor: '_Tuple2',
								_0: _p8,
								_1: A3(rightStep, rKey, rValue, _p9)
							};
						} else {
							return {
								ctor: '_Tuple2',
								_0: _p7,
								_1: A4(bothStep, _p5, _p6, rValue, _p9)
							};
						}
					}
				}
			}
		});
		var _p10 = A3(_elm_lang$core$Dict$foldl, stepState, {
			ctor: '_Tuple2',
			_0: _elm_lang$core$Dict$toList(leftDict),
			_1: initialResult
		}, rightDict);
		var leftovers = _p10._0;
		var intermediateResult = _p10._1;
		return A3(_elm_lang$core$List$foldl, /*#__PURE__*/F2(function (_p11, result) {
			var _p12 = _p11;
			return A3(leftStep, _p12._0, _p12._1, result);
		}), intermediateResult, leftovers);
	});
	var _elm_lang$core$Dict$reportRemBug = /*#__PURE__*/F4(function (msg, c, lgot, rgot) {
		return _elm_lang$core$Native_Debug$iife_public$crash(_elm_lang$core$String$concat({
			ctor: '::',
			_0: 'Internal red-black tree invariant violated, expected ',
			_1: {
				ctor: '::',
				_0: msg,
				_1: {
					ctor: '::',
					_0: ' and got ',
					_1: {
						ctor: '::',
						_0: _elm_lang$core$Basics$toString(c),
						_1: {
							ctor: '::',
							_0: '/',
							_1: {
								ctor: '::',
								_0: lgot,
								_1: {
									ctor: '::',
									_0: '/',
									_1: {
										ctor: '::',
										_0: rgot,
										_1: {
											ctor: '::',
											_0: '\nPlease report this bug to <https://github.com/elm-lang/core/issues>',
											_1: { ctor: '[]' }
										}
									}
								}
							}
						}
					}
				}
			}
		}));
	});
	var _elm_lang$core$Dict$isBBlack = function (dict) {
		var _p13 = dict;
		_v14_2: do {
			if (_p13.ctor === 'RBNode_elm_builtin') {
				if (_p13._0.ctor === 'BBlack') {
					return true;
				} else {
					break _v14_2;
				}
			} else {
				if (_p13._0.ctor === 'LBBlack') {
					return true;
				} else {
					break _v14_2;
				}
			}
		} while (false);
		return false;
	};
	var _elm_lang$core$Dict$sizeHelp = /*#__PURE__*/F2(function (n, dict) {
		sizeHelp: while (true) {
			var _p14 = dict;
			if (_p14.ctor === 'RBEmpty_elm_builtin') {
				return n;
			} else {
				var _v16 = A2(_elm_lang$core$Dict$sizeHelp, n + 1, _p14._4),
				    _v17 = _p14._3;
				n = _v16;
				dict = _v17;
				continue sizeHelp;
			}
		}
	});
	var _elm_lang$core$Dict$size = function (dict) {
		return A2(_elm_lang$core$Dict$sizeHelp, 0, dict);
	};
	var _elm_lang$core$Dict$get = /*#__PURE__*/F2(function (targetKey, dict) {
		get: while (true) {
			var _p15 = dict;
			if (_p15.ctor === 'RBEmpty_elm_builtin') {
				return _elm_lang$core$Maybe$Nothing;
			} else {
				var _p16 = A2(_elm_lang$core$Basics$compare, targetKey, _p15._1);
				switch (_p16.ctor) {
					case 'LT':
						var _v20 = targetKey,
						    _v21 = _p15._3;
						targetKey = _v20;
						dict = _v21;
						continue get;
					case 'EQ':
						return _elm_lang$core$Maybe$Just(_p15._2);
					default:
						var _v22 = targetKey,
						    _v23 = _p15._4;
						targetKey = _v22;
						dict = _v23;
						continue get;
				}
			}
		}
	});
	var _elm_lang$core$Dict$member = /*#__PURE__*/F2(function (key, dict) {
		var _p17 = A2(_elm_lang$core$Dict$get, key, dict);
		if (_p17.ctor === 'Just') {
			return true;
		} else {
			return false;
		}
	});
	var _elm_lang$core$Dict$maxWithDefault = /*#__PURE__*/F3(function (k, v, r) {
		maxWithDefault: while (true) {
			var _p18 = r;
			if (_p18.ctor === 'RBEmpty_elm_builtin') {
				return { ctor: '_Tuple2', _0: k, _1: v };
			} else {
				var _v26 = _p18._1,
				    _v27 = _p18._2,
				    _v28 = _p18._4;
				k = _v26;
				v = _v27;
				r = _v28;
				continue maxWithDefault;
			}
		}
	});
	var _elm_lang$core$Dict$NBlack = { ctor: 'NBlack' };
	var _elm_lang$core$Dict$BBlack = { ctor: 'BBlack' };
	var _elm_lang$core$Dict$Black = { ctor: 'Black' };
	var _elm_lang$core$Dict$blackish = function (t) {
		var _p19 = t;
		if (_p19.ctor === 'RBNode_elm_builtin') {
			var _p20 = _p19._0;
			return _elm_lang$core$Native_Utils$iife_public$eq(_p20, _elm_lang$core$Dict$Black) || _elm_lang$core$Native_Utils$iife_public$eq(_p20, _elm_lang$core$Dict$BBlack);
		} else {
			return true;
		}
	};
	var _elm_lang$core$Dict$Red = { ctor: 'Red' };
	var _elm_lang$core$Dict$moreBlack = function (color) {
		var _p21 = color;
		switch (_p21.ctor) {
			case 'Black':
				return _elm_lang$core$Dict$BBlack;
			case 'Red':
				return _elm_lang$core$Dict$Black;
			case 'NBlack':
				return _elm_lang$core$Dict$Red;
			default:
				return _elm_lang$core$Native_Debug$iife_public$crash('Can\'t make a double black node more black!');
		}
	};
	var _elm_lang$core$Dict$lessBlack = function (color) {
		var _p22 = color;
		switch (_p22.ctor) {
			case 'BBlack':
				return _elm_lang$core$Dict$Black;
			case 'Black':
				return _elm_lang$core$Dict$Red;
			case 'Red':
				return _elm_lang$core$Dict$NBlack;
			default:
				return _elm_lang$core$Native_Debug$iife_public$crash('Can\'t make a negative black node less black!');
		}
	};
	var _elm_lang$core$Dict$LBBlack = { ctor: 'LBBlack' };
	var _elm_lang$core$Dict$LBlack = { ctor: 'LBlack' };
	var _elm_lang$core$Dict$RBEmpty_elm_builtin = function (a) {
		return { ctor: 'RBEmpty_elm_builtin', _0: a };
	};
	var _elm_lang$core$Dict$empty = /*#__PURE__*/_elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack);
	var _elm_lang$core$Dict$isEmpty = function (dict) {
		return _elm_lang$core$Native_Utils$iife_public$eq(dict, _elm_lang$core$Dict$empty);
	};
	var _elm_lang$core$Dict$RBNode_elm_builtin = /*#__PURE__*/F5(function (a, b, c, d, e) {
		return { ctor: 'RBNode_elm_builtin', _0: a, _1: b, _2: c, _3: d, _4: e };
	});
	var _elm_lang$core$Dict$ensureBlackRoot = function (dict) {
		var _p23 = dict;
		if (_p23.ctor === 'RBNode_elm_builtin' && _p23._0.ctor === 'Red') {
			return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p23._1, _p23._2, _p23._3, _p23._4);
		} else {
			return dict;
		}
	};
	var _elm_lang$core$Dict$lessBlackTree = function (dict) {
		var _p24 = dict;
		if (_p24.ctor === 'RBNode_elm_builtin') {
			return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$lessBlack(_p24._0), _p24._1, _p24._2, _p24._3, _p24._4);
		} else {
			return (/*#__PURE__*/_elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack)
			);
		}
	};
	var _elm_lang$core$Dict$balancedTree = function (col) {
		return function (xk) {
			return function (xv) {
				return function (yk) {
					return function (yv) {
						return function (zk) {
							return function (zv) {
								return function (a) {
									return function (b) {
										return function (c) {
											return function (d) {
												return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$lessBlack(col), yk, yv, A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, xk, xv, a, b), A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, zk, zv, c, d));
											};
										};
									};
								};
							};
						};
					};
				};
			};
		};
	};
	var _elm_lang$core$Dict$blacken = function (t) {
		var _p25 = t;
		if (_p25.ctor === 'RBEmpty_elm_builtin') {
			return (/*#__PURE__*/_elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack)
			);
		} else {
			return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p25._1, _p25._2, _p25._3, _p25._4);
		}
	};
	var _elm_lang$core$Dict$redden = function (t) {
		var _p26 = t;
		if (_p26.ctor === 'RBEmpty_elm_builtin') {
			return _elm_lang$core$Native_Debug$iife_public$crash('can\'t make a Leaf red');
		} else {
			return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, _p26._1, _p26._2, _p26._3, _p26._4);
		}
	};
	var _elm_lang$core$Dict$balanceHelp = function (tree) {
		var _p27 = tree;
		_v36_6: do {
			_v36_5: do {
				_v36_4: do {
					_v36_3: do {
						_v36_2: do {
							_v36_1: do {
								_v36_0: do {
									if (_p27.ctor === 'RBNode_elm_builtin') {
										if (_p27._3.ctor === 'RBNode_elm_builtin') {
											if (_p27._4.ctor === 'RBNode_elm_builtin') {
												switch (_p27._3._0.ctor) {
													case 'Red':
														switch (_p27._4._0.ctor) {
															case 'Red':
																if (_p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Red') {
																	break _v36_0;
																} else {
																	if (_p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Red') {
																		break _v36_1;
																	} else {
																		if (_p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Red') {
																			break _v36_2;
																		} else {
																			if (_p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Red') {
																				break _v36_3;
																			} else {
																				break _v36_6;
																			}
																		}
																	}
																}
															case 'NBlack':
																if (_p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Red') {
																	break _v36_0;
																} else {
																	if (_p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Red') {
																		break _v36_1;
																	} else {
																		if (_p27._0.ctor === 'BBlack' && _p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Black' && _p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Black') {
																			break _v36_4;
																		} else {
																			break _v36_6;
																		}
																	}
																}
															default:
																if (_p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Red') {
																	break _v36_0;
																} else {
																	if (_p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Red') {
																		break _v36_1;
																	} else {
																		break _v36_6;
																	}
																}
														}
													case 'NBlack':
														switch (_p27._4._0.ctor) {
															case 'Red':
																if (_p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Red') {
																	break _v36_2;
																} else {
																	if (_p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Red') {
																		break _v36_3;
																	} else {
																		if (_p27._0.ctor === 'BBlack' && _p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Black' && _p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Black') {
																			break _v36_5;
																		} else {
																			break _v36_6;
																		}
																	}
																}
															case 'NBlack':
																if (_p27._0.ctor === 'BBlack') {
																	if (_p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Black' && _p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Black') {
																		break _v36_4;
																	} else {
																		if (_p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Black' && _p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Black') {
																			break _v36_5;
																		} else {
																			break _v36_6;
																		}
																	}
																} else {
																	break _v36_6;
																}
															default:
																if (_p27._0.ctor === 'BBlack' && _p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Black' && _p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Black') {
																	break _v36_5;
																} else {
																	break _v36_6;
																}
														}
													default:
														switch (_p27._4._0.ctor) {
															case 'Red':
																if (_p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Red') {
																	break _v36_2;
																} else {
																	if (_p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Red') {
																		break _v36_3;
																	} else {
																		break _v36_6;
																	}
																}
															case 'NBlack':
																if (_p27._0.ctor === 'BBlack' && _p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Black' && _p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Black') {
																	break _v36_4;
																} else {
																	break _v36_6;
																}
															default:
																break _v36_6;
														}
												}
											} else {
												switch (_p27._3._0.ctor) {
													case 'Red':
														if (_p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Red') {
															break _v36_0;
														} else {
															if (_p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Red') {
																break _v36_1;
															} else {
																break _v36_6;
															}
														}
													case 'NBlack':
														if (_p27._0.ctor === 'BBlack' && _p27._3._3.ctor === 'RBNode_elm_builtin' && _p27._3._3._0.ctor === 'Black' && _p27._3._4.ctor === 'RBNode_elm_builtin' && _p27._3._4._0.ctor === 'Black') {
															break _v36_5;
														} else {
															break _v36_6;
														}
													default:
														break _v36_6;
												}
											}
										} else {
											if (_p27._4.ctor === 'RBNode_elm_builtin') {
												switch (_p27._4._0.ctor) {
													case 'Red':
														if (_p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Red') {
															break _v36_2;
														} else {
															if (_p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Red') {
																break _v36_3;
															} else {
																break _v36_6;
															}
														}
													case 'NBlack':
														if (_p27._0.ctor === 'BBlack' && _p27._4._3.ctor === 'RBNode_elm_builtin' && _p27._4._3._0.ctor === 'Black' && _p27._4._4.ctor === 'RBNode_elm_builtin' && _p27._4._4._0.ctor === 'Black') {
															break _v36_4;
														} else {
															break _v36_6;
														}
													default:
														break _v36_6;
												}
											} else {
												break _v36_6;
											}
										}
									} else {
										break _v36_6;
									}
								} while (false);
								return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._3._1)(_p27._3._3._2)(_p27._3._1)(_p27._3._2)(_p27._1)(_p27._2)(_p27._3._3._3)(_p27._3._3._4)(_p27._3._4)(_p27._4);
							} while (false);
							return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._1)(_p27._3._2)(_p27._3._4._1)(_p27._3._4._2)(_p27._1)(_p27._2)(_p27._3._3)(_p27._3._4._3)(_p27._3._4._4)(_p27._4);
						} while (false);
						return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._3._1)(_p27._4._3._2)(_p27._4._1)(_p27._4._2)(_p27._3)(_p27._4._3._3)(_p27._4._3._4)(_p27._4._4);
					} while (false);
					return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._1)(_p27._4._2)(_p27._4._4._1)(_p27._4._4._2)(_p27._3)(_p27._4._3)(_p27._4._4._3)(_p27._4._4._4);
				} while (false);
				return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._4._3._1, _p27._4._3._2, A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3, _p27._4._3._3), A5(_elm_lang$core$Dict$balance, _elm_lang$core$Dict$Black, _p27._4._1, _p27._4._2, _p27._4._3._4, _elm_lang$core$Dict$redden(_p27._4._4)));
			} while (false);
			return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._3._4._1, _p27._3._4._2, A5(_elm_lang$core$Dict$balance, _elm_lang$core$Dict$Black, _p27._3._1, _p27._3._2, _elm_lang$core$Dict$redden(_p27._3._3), _p27._3._4._3), A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3._4._4, _p27._4));
		} while (false);
		return tree;
	};
	var _elm_lang$core$Dict$balance = /*#__PURE__*/F5(function (c, k, v, l, r) {
		var tree = A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r);
		return _elm_lang$core$Dict$blackish(tree) ? _elm_lang$core$Dict$balanceHelp(tree) : tree;
	});
	var _elm_lang$core$Dict$bubble = /*#__PURE__*/F5(function (c, k, v, l, r) {
		return _elm_lang$core$Dict$isBBlack(l) || _elm_lang$core$Dict$isBBlack(r) ? A5(_elm_lang$core$Dict$balance, _elm_lang$core$Dict$moreBlack(c), k, v, _elm_lang$core$Dict$lessBlackTree(l), _elm_lang$core$Dict$lessBlackTree(r)) : A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r);
	});
	var _elm_lang$core$Dict$removeMax = /*#__PURE__*/F5(function (c, k, v, l, r) {
		var _p28 = r;
		if (_p28.ctor === 'RBEmpty_elm_builtin') {
			return A3(_elm_lang$core$Dict$rem, c, l, r);
		} else {
			return A5(_elm_lang$core$Dict$bubble, c, k, v, l, A5(_elm_lang$core$Dict$removeMax, _p28._0, _p28._1, _p28._2, _p28._3, _p28._4));
		}
	});
	var _elm_lang$core$Dict$rem = /*#__PURE__*/F3(function (color, left, right) {
		var _p29 = { ctor: '_Tuple2', _0: left, _1: right };
		if (_p29._0.ctor === 'RBEmpty_elm_builtin') {
			if (_p29._1.ctor === 'RBEmpty_elm_builtin') {
				var _p30 = color;
				switch (_p30.ctor) {
					case 'Red':
						return (/*#__PURE__*/_elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack)
						);
					case 'Black':
						return (/*#__PURE__*/_elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBBlack)
						);
					default:
						return _elm_lang$core$Native_Debug$iife_public$crash('cannot have bblack or nblack nodes at this point');
				}
			} else {
				var _p33 = _p29._1._0;
				var _p32 = _p29._0._0;
				var _p31 = { ctor: '_Tuple3', _0: color, _1: _p32, _2: _p33 };
				if (_p31.ctor === '_Tuple3' && _p31._0.ctor === 'Black' && _p31._1.ctor === 'LBlack' && _p31._2.ctor === 'Red') {
					return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._1._1, _p29._1._2, _p29._1._3, _p29._1._4);
				} else {
					return A4(_elm_lang$core$Dict$reportRemBug, 'Black/LBlack/Red', color, _elm_lang$core$Basics$toString(_p32), _elm_lang$core$Basics$toString(_p33));
				}
			}
		} else {
			if (_p29._1.ctor === 'RBEmpty_elm_builtin') {
				var _p36 = _p29._1._0;
				var _p35 = _p29._0._0;
				var _p34 = { ctor: '_Tuple3', _0: color, _1: _p35, _2: _p36 };
				if (_p34.ctor === '_Tuple3' && _p34._0.ctor === 'Black' && _p34._1.ctor === 'Red' && _p34._2.ctor === 'LBlack') {
					return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._0._1, _p29._0._2, _p29._0._3, _p29._0._4);
				} else {
					return A4(_elm_lang$core$Dict$reportRemBug, 'Black/Red/LBlack', color, _elm_lang$core$Basics$toString(_p35), _elm_lang$core$Basics$toString(_p36));
				}
			} else {
				var _p40 = _p29._0._2;
				var _p39 = _p29._0._4;
				var _p38 = _p29._0._1;
				var newLeft = A5(_elm_lang$core$Dict$removeMax, _p29._0._0, _p38, _p40, _p29._0._3, _p39);
				var _p37 = A3(_elm_lang$core$Dict$maxWithDefault, _p38, _p40, _p39);
				var k = _p37._0;
				var v = _p37._1;
				return A5(_elm_lang$core$Dict$bubble, color, k, v, newLeft, right);
			}
		}
	});
	var _elm_lang$core$Dict$map = /*#__PURE__*/F2(function (f, dict) {
		var _p41 = dict;
		if (_p41.ctor === 'RBEmpty_elm_builtin') {
			return (/*#__PURE__*/_elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack)
			);
		} else {
			var _p42 = _p41._1;
			return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p41._0, _p42, A2(f, _p42, _p41._2), A2(_elm_lang$core$Dict$map, f, _p41._3), A2(_elm_lang$core$Dict$map, f, _p41._4));
		}
	});
	var _elm_lang$core$Dict$Same = { ctor: 'Same' };
	var _elm_lang$core$Dict$Remove = { ctor: 'Remove' };
	var _elm_lang$core$Dict$Insert = { ctor: 'Insert' };
	var _elm_lang$core$Dict$update = /*#__PURE__*/F3(function (k, alter, dict) {
		var up = function (dict) {
			var _p43 = dict;
			if (_p43.ctor === 'RBEmpty_elm_builtin') {
				var _p44 = alter(_elm_lang$core$Maybe$Nothing);
				if (_p44.ctor === 'Nothing') {
					return { ctor: '_Tuple2', _0: _elm_lang$core$Dict$Same, _1: _elm_lang$core$Dict$empty };
				} else {
					return {
						ctor: '_Tuple2',
						_0: _elm_lang$core$Dict$Insert,
						_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, k, _p44._0, _elm_lang$core$Dict$empty, _elm_lang$core$Dict$empty)
					};
				}
			} else {
				var _p55 = _p43._2;
				var _p54 = _p43._4;
				var _p53 = _p43._3;
				var _p52 = _p43._1;
				var _p51 = _p43._0;
				var _p45 = A2(_elm_lang$core$Basics$compare, k, _p52);
				switch (_p45.ctor) {
					case 'EQ':
						var _p46 = alter(_elm_lang$core$Maybe$Just(_p55));
						if (_p46.ctor === 'Nothing') {
							return {
								ctor: '_Tuple2',
								_0: _elm_lang$core$Dict$Remove,
								_1: A3(_elm_lang$core$Dict$rem, _p51, _p53, _p54)
							};
						} else {
							return {
								ctor: '_Tuple2',
								_0: _elm_lang$core$Dict$Same,
								_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p46._0, _p53, _p54)
							};
						}
					case 'LT':
						var _p47 = up(_p53);
						var flag = _p47._0;
						var newLeft = _p47._1;
						var _p48 = flag;
						switch (_p48.ctor) {
							case 'Same':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Same,
									_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, newLeft, _p54)
								};
							case 'Insert':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Insert,
									_1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, newLeft, _p54)
								};
							default:
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Remove,
									_1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, newLeft, _p54)
								};
						}
					default:
						var _p49 = up(_p54);
						var flag = _p49._0;
						var newRight = _p49._1;
						var _p50 = flag;
						switch (_p50.ctor) {
							case 'Same':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Same,
									_1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, _p53, newRight)
								};
							case 'Insert':
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Insert,
									_1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, _p53, newRight)
								};
							default:
								return {
									ctor: '_Tuple2',
									_0: _elm_lang$core$Dict$Remove,
									_1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, _p53, newRight)
								};
						}
				}
			}
		};
		var _p56 = up(dict);
		var flag = _p56._0;
		var updatedDict = _p56._1;
		var _p57 = flag;
		switch (_p57.ctor) {
			case 'Same':
				return updatedDict;
			case 'Insert':
				return _elm_lang$core$Dict$ensureBlackRoot(updatedDict);
			default:
				return _elm_lang$core$Dict$blacken(updatedDict);
		}
	});
	var _elm_lang$core$Dict$insert = /*#__PURE__*/F3(function (key, value, dict) {
		return A3(_elm_lang$core$Dict$update, key, _elm_lang$core$Basics$always(_elm_lang$core$Maybe$Just(value)), dict);
	});
	var _elm_lang$core$Dict$singleton = /*#__PURE__*/F2(function (key, value) {
		return A3(_elm_lang$core$Dict$insert, key, value, _elm_lang$core$Dict$empty);
	});
	var _elm_lang$core$Dict$union = /*#__PURE__*/F2(function (t1, t2) {
		return A3(_elm_lang$core$Dict$foldl, _elm_lang$core$Dict$insert, t2, t1);
	});
	var _elm_lang$core$Dict$filter = /*#__PURE__*/F2(function (predicate, dictionary) {
		var add = /*#__PURE__*/F3(function (key, value, dict) {
			return A2(predicate, key, value) ? A3(_elm_lang$core$Dict$insert, key, value, dict) : dict;
		});
		return A3(_elm_lang$core$Dict$foldl, add, _elm_lang$core$Dict$empty, dictionary);
	});
	var _elm_lang$core$Dict$intersect = /*#__PURE__*/F2(function (t1, t2) {
		return A2(_elm_lang$core$Dict$filter, /*#__PURE__*/F2(function (k, _p58) {
			return A2(_elm_lang$core$Dict$member, k, t2);
		}), t1);
	});
	var _elm_lang$core$Dict$partition = /*#__PURE__*/F2(function (predicate, dict) {
		var add = /*#__PURE__*/F3(function (key, value, _p59) {
			var _p60 = _p59;
			var _p62 = _p60._1;
			var _p61 = _p60._0;
			return A2(predicate, key, value) ? {
				ctor: '_Tuple2',
				_0: A3(_elm_lang$core$Dict$insert, key, value, _p61),
				_1: _p62
			} : {
				ctor: '_Tuple2',
				_0: _p61,
				_1: A3(_elm_lang$core$Dict$insert, key, value, _p62)
			};
		});
		return A3(_elm_lang$core$Dict$foldl, add, { ctor: '_Tuple2', _0: _elm_lang$core$Dict$empty, _1: _elm_lang$core$Dict$empty }, dict);
	});
	var _elm_lang$core$Dict$fromList = function (assocs) {
		return A3(_elm_lang$core$List$foldl, /*#__PURE__*/F2(function (_p63, dict) {
			var _p64 = _p63;
			return A3(_elm_lang$core$Dict$insert, _p64._0, _p64._1, dict);
		}), _elm_lang$core$Dict$empty, assocs);
	};
	var _elm_lang$core$Dict$remove = /*#__PURE__*/F2(function (key, dict) {
		return A3(_elm_lang$core$Dict$update, key, _elm_lang$core$Basics$always(_elm_lang$core$Maybe$Nothing), dict);
	});
	var _elm_lang$core$Dict$diff = /*#__PURE__*/F2(function (t1, t2) {
		return A3(_elm_lang$core$Dict$foldl, /*#__PURE__*/F3(function (k, v, t) {
			return A2(_elm_lang$core$Dict$remove, k, t);
		}), t1, t2);
	});

	var _elm_lang$core$Debug$crash = _elm_lang$core$Native_Debug$iife_public$crash;
	var _elm_lang$core$Debug$log = _elm_lang$core$Native_Debug$iife_public$log;

	//import Maybe, Native.Array, Native.List, Native.Utils, Result //

	var _elm_lang$core$Native_Json = {},
	    _elm_lang$core$Native_Json$iife_public$encode = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$encode),
	    _elm_lang$core$Native_Json$iife_public$runOnString = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$runOnString),
	    _elm_lang$core$Native_Json$iife_public$run = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$run),
	    _elm_lang$core$Native_Json$iife_public$decodeNull = _elm_lang$core$Native_Json$iife_private$decodeNull,
	    _elm_lang$core$Native_Json$iife_public$decodePrimitive = _elm_lang$core$Native_Json$iife_private$decodePrimitive,
	    _elm_lang$core$Native_Json$iife_public$decodeContainer = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$decodeContainer),
	    _elm_lang$core$Native_Json$iife_public$decodeField = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$decodeField),
	    _elm_lang$core$Native_Json$iife_public$decodeIndex = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$decodeIndex),
	    _elm_lang$core$Native_Json$iife_public$map1 = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$map1),
	    _elm_lang$core$Native_Json$iife_public$map2 = /*#__PURE__*/F3(_elm_lang$core$Native_Json$iife_private$map2),
	    _elm_lang$core$Native_Json$iife_public$map3 = /*#__PURE__*/F4(_elm_lang$core$Native_Json$iife_private$map3),
	    _elm_lang$core$Native_Json$iife_public$map4 = /*#__PURE__*/F5(_elm_lang$core$Native_Json$iife_private$map4),
	    _elm_lang$core$Native_Json$iife_public$map5 = /*#__PURE__*/F6(_elm_lang$core$Native_Json$iife_private$map5),
	    _elm_lang$core$Native_Json$iife_public$map6 = /*#__PURE__*/F7(_elm_lang$core$Native_Json$iife_private$map6),
	    _elm_lang$core$Native_Json$iife_public$map7 = /*#__PURE__*/F8(_elm_lang$core$Native_Json$iife_private$map7),
	    _elm_lang$core$Native_Json$iife_public$map8 = /*#__PURE__*/F9(_elm_lang$core$Native_Json$iife_private$map8),
	    _elm_lang$core$Native_Json$iife_public$decodeKeyValuePairs = _elm_lang$core$Native_Json$iife_private$decodeKeyValuePairs,
	    _elm_lang$core$Native_Json$iife_public$andThen = /*#__PURE__*/F2(_elm_lang$core$Native_Json$iife_private$andThen),
	    _elm_lang$core$Native_Json$iife_public$fail = _elm_lang$core$Native_Json$iife_private$fail,
	    _elm_lang$core$Native_Json$iife_public$succeed = _elm_lang$core$Native_Json$iife_private$succeed,
	    _elm_lang$core$Native_Json$iife_public$oneOf = _elm_lang$core$Native_Json$iife_private$oneOf,
	    _elm_lang$core$Native_Json$iife_public$identity = _elm_lang$core$Native_Json$iife_private$identity,
	    _elm_lang$core$Native_Json$iife_public$encodeNull = null,
	    _elm_lang$core$Native_Json$iife_public$encodeArray = _elm_lang$core$Native_Array$iife_public$toJSArray,
	    _elm_lang$core$Native_Json$iife_public$encodeList = _elm_lang$core$Native_List$iife_public$toArray,
	    _elm_lang$core$Native_Json$iife_public$encodeObject = _elm_lang$core$Native_Json$iife_private$encodeObject,
	    _elm_lang$core$Native_Json$iife_public$equality = _elm_lang$core$Native_Json$iife_private$equality;

	function _elm_lang$core$Native_Json$iife_private$encodeObject(keyValuePairs) {
		var obj = {};
		while (keyValuePairs.ctor !== '[]') {
			var pair = keyValuePairs._0;
			obj[pair._0] = pair._1;
			keyValuePairs = keyValuePairs._1;
		}
		return obj;
	}

	function _elm_lang$core$Native_Json$iife_private$identity(value) {
		return value;
	}

	// ENCODE

	function _elm_lang$core$Native_Json$iife_private$encode(indentLevel, value) {
		return JSON.stringify(value, null, indentLevel);
	}

	function _elm_lang$core$Native_Json$iife_private$listEquality(aDecoders, bDecoders) {
		var len = aDecoders.length;
		if (len !== bDecoders.length) {
			return false;
		}
		for (var i = 0; i < len; i++) {
			if (!_elm_lang$core$Native_Json$iife_private$equality(aDecoders[i], bDecoders[i])) {
				return false;
			}
		}
		return true;
	}

	// EQUALITY

	function _elm_lang$core$Native_Json$iife_private$equality(a, b) {
		if (a === b) {
			return true;
		}

		if (a.tag !== b.tag) {
			return false;
		}

		switch (a.tag) {
			case 'succeed':
			case 'fail':
				return a.msg === b.msg;

			case 'bool':
			case 'int':
			case 'float':
			case 'string':
			case 'value':
				return true;

			case 'null':
				return a.value === b.value;

			case 'list':
			case 'array':
			case 'maybe':
			case 'key-value':
				return _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

			case 'field':
				return a.field === b.field && _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

			case 'index':
				return a.index === b.index && _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

			case 'map-many':
				if (a.func !== b.func) {
					return false;
				}
				return _elm_lang$core$Native_Json$iife_private$listEquality(a.decoders, b.decoders);

			case 'andThen':
				return a.callback === b.callback && _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

			case 'oneOf':
				return _elm_lang$core$Native_Json$iife_private$listEquality(a.decoders, b.decoders);
		}
	}

	function _elm_lang$core$Native_Json$iife_private$runHelp(decoder, value) {
		switch (decoder.tag) {
			case 'bool':
				return typeof value === 'boolean' ? _elm_lang$core$Native_Json$iife_private$ok(value) : _elm_lang$core$Native_Json$iife_private$badPrimitive('a Bool', value);

			case 'int':
				if (typeof value !== 'number') {
					return _elm_lang$core$Native_Json$iife_private$badPrimitive('an Int', value);
				}

				if (-2147483647 < value && value < 2147483647 && (value | 0) === value) {
					return _elm_lang$core$Native_Json$iife_private$ok(value);
				}

				if (isFinite(value) && !(value % 1)) {
					return _elm_lang$core$Native_Json$iife_private$ok(value);
				}

				return _elm_lang$core$Native_Json$iife_private$badPrimitive('an Int', value);

			case 'float':
				return typeof value === 'number' ? _elm_lang$core$Native_Json$iife_private$ok(value) : _elm_lang$core$Native_Json$iife_private$badPrimitive('a Float', value);

			case 'string':
				return typeof value === 'string' ? _elm_lang$core$Native_Json$iife_private$ok(value) : value instanceof String ? _elm_lang$core$Native_Json$iife_private$ok(value + '') : _elm_lang$core$Native_Json$iife_private$badPrimitive('a String', value);

			case 'null':
				return value === null ? _elm_lang$core$Native_Json$iife_private$ok(decoder.value) : _elm_lang$core$Native_Json$iife_private$badPrimitive('null', value);

			case 'value':
				return _elm_lang$core$Native_Json$iife_private$ok(value);

			case 'list':
				if (!(value instanceof Array)) {
					return _elm_lang$core$Native_Json$iife_private$badPrimitive('a List', value);
				}

				var list = _elm_lang$core$Native_List$iife_public$Nil;
				for (var i = value.length; i--;) {
					var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[i]);
					if (result.tag !== 'ok') {
						return _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(i, result);
					}
					list = _elm_lang$core$Native_List$iife_public$Cons(result.value, list);
				}
				return _elm_lang$core$Native_Json$iife_private$ok(list);

			case 'array':
				if (!(value instanceof Array)) {
					return _elm_lang$core$Native_Json$iife_private$badPrimitive('an Array', value);
				}

				var len = value.length;
				var array = new Array(len);
				for (var i = len; i--;) {
					var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[i]);
					if (result.tag !== 'ok') {
						return _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(i, result);
					}
					array[i] = result.value;
				}
				return _elm_lang$core$Native_Json$iife_private$ok(_elm_lang$core$Native_Array$iife_public$fromJSArray(array));

			case 'maybe':
				var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value);
				return result.tag === 'ok' ? _elm_lang$core$Native_Json$iife_private$ok(_elm_lang$core$Maybe$Just(result.value)) : _elm_lang$core$Native_Json$iife_private$ok(_elm_lang$core$Maybe$Nothing);

			case 'field':
				var field = decoder.field;
				if (typeof value !== 'object' || value === null || !(field in value)) {
					return _elm_lang$core$Native_Json$iife_private$badPrimitive('an object with a field named `' + field + '`', value);
				}

				var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[field]);
				return result.tag === 'ok' ? result : _elm_lang$core$Native_Json$iife_private$badField(field, result);

			case 'index':
				var index = decoder.index;
				if (!(value instanceof Array)) {
					return _elm_lang$core$Native_Json$iife_private$badPrimitive('an array', value);
				}
				if (index >= value.length) {
					return _elm_lang$core$Native_Json$iife_private$badPrimitive('a longer array. Need index ' + index + ' but there are only ' + value.length + ' entries', value);
				}

				var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[index]);
				return result.tag === 'ok' ? result : _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(index, result);

			case 'key-value':
				if (typeof value !== 'object' || value === null || value instanceof Array) {
					return _elm_lang$core$Native_Json$iife_private$badPrimitive('an object', value);
				}

				var keyValuePairs = _elm_lang$core$Native_List$iife_public$Nil;
				for (var key in value) {
					var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[key]);
					if (result.tag !== 'ok') {
						return _elm_lang$core$Native_Json$iife_private$badField(key, result);
					}
					var pair = _elm_lang$core$Native_Utils$iife_public$Tuple2(key, result.value);
					keyValuePairs = _elm_lang$core$Native_List$iife_public$Cons(pair, keyValuePairs);
				}
				return _elm_lang$core$Native_Json$iife_private$ok(keyValuePairs);

			case 'map-many':
				var answer = decoder.func;
				var decoders = decoder.decoders;
				for (var i = 0; i < decoders.length; i++) {
					var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoders[i], value);
					if (result.tag !== 'ok') {
						return result;
					}
					answer = answer(result.value);
				}
				return _elm_lang$core$Native_Json$iife_private$ok(answer);

			case 'andThen':
				var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value);
				return result.tag !== 'ok' ? result : _elm_lang$core$Native_Json$iife_private$runHelp(decoder.callback(result.value), value);

			case 'oneOf':
				var errors = [];
				var temp = decoder.decoders;
				while (temp.ctor !== '[]') {
					var result = _elm_lang$core$Native_Json$iife_private$runHelp(temp._0, value);

					if (result.tag === 'ok') {
						return result;
					}

					errors.push(result);

					temp = temp._1;
				}
				return _elm_lang$core$Native_Json$iife_private$badOneOf(errors);

			case 'fail':
				return _elm_lang$core$Native_Json$iife_private$bad(decoder.msg);

			case 'succeed':
				return _elm_lang$core$Native_Json$iife_private$ok(decoder.msg);
		}
	}

	function _elm_lang$core$Native_Json$iife_private$run(decoder, value) {
		var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder, value);
		return result.tag === 'ok' ? _elm_lang$core$Result$Ok(result.value) : _elm_lang$core$Result$Err(_elm_lang$core$Native_Json$iife_private$badToString(result));
	}

	// DECODE

	function _elm_lang$core$Native_Json$iife_private$runOnString(decoder, string) {
		var json;
		try {
			json = JSON.parse(string);
		} catch (e) {
			return _elm_lang$core$Result$Err('Given an invalid JSON: ' + e.message);
		}
		return _elm_lang$core$Native_Json$iife_private$run(decoder, json);
	}

	function _elm_lang$core$Native_Json$iife_private$jsToString(value) {
		return value === undefined ? 'undefined' : JSON.stringify(value);
	}

	function _elm_lang$core$Native_Json$iife_private$badToString(problem) {
		var context = '_';
		while (problem) {
			switch (problem.tag) {
				case 'primitive':
					return 'Expecting ' + problem.type + (context === '_' ? '' : ' at ' + context) + ' but instead got: ' + _elm_lang$core$Native_Json$iife_private$jsToString(problem.value);

				case 'index':
					context += '[' + problem.index + ']';
					problem = problem.rest;
					break;

				case 'field':
					context += '.' + problem.field;
					problem = problem.rest;
					break;

				case 'oneOf':
					var problems = problem.problems;
					for (var i = 0; i < problems.length; i++) {
						problems[i] = _elm_lang$core$Native_Json$iife_private$badToString(problems[i]);
					}
					return 'I ran into the following problems' + (context === '_' ? '' : ' at ' + context) + ':\n\n' + problems.join('\n');

				case 'fail':
					return 'I ran into a `fail` decoder' + (context === '_' ? '' : ' at ' + context) + ': ' + problem.msg;
			}
		}
	}

	function _elm_lang$core$Native_Json$iife_private$bad(msg) {
		return { tag: 'fail', msg: msg };
	}

	function _elm_lang$core$Native_Json$iife_private$badOneOf(problems) {
		return { tag: 'oneOf', problems: problems };
	}

	function _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(index, nestedProblems) {
		return { tag: 'index', index: index, rest: nestedProblems };
	}

	function _elm_lang$core$Native_Json$iife_private$badField(field, nestedProblems) {
		return { tag: 'field', field: field, rest: nestedProblems };
	}

	function _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(index, nestedProblems) {
		return { tag: 'index', index: index, rest: nestedProblems };
	}

	function _elm_lang$core$Native_Json$iife_private$badPrimitive(type, value) {
		return { tag: 'primitive', type: type, value: value };
	}

	// DECODE HELPERS

	function _elm_lang$core$Native_Json$iife_private$ok(value) {
		return { tag: 'ok', value: value };
	}

	function _elm_lang$core$Native_Json$iife_private$map8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
	}

	function _elm_lang$core$Native_Json$iife_private$map7(f, d1, d2, d3, d4, d5, d6, d7) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
	}

	function _elm_lang$core$Native_Json$iife_private$map6(f, d1, d2, d3, d4, d5, d6) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1, d2, d3, d4, d5, d6]);
	}

	function _elm_lang$core$Native_Json$iife_private$map5(f, d1, d2, d3, d4, d5) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1, d2, d3, d4, d5]);
	}

	function _elm_lang$core$Native_Json$iife_private$map4(f, d1, d2, d3, d4) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1, d2, d3, d4]);
	}

	function _elm_lang$core$Native_Json$iife_private$map3(f, d1, d2, d3) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1, d2, d3]);
	}

	function _elm_lang$core$Native_Json$iife_private$map2(f, d1, d2) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1, d2]);
	}

	// DECODING OBJECTS

	function _elm_lang$core$Native_Json$iife_private$map1(f, d1) {
		return _elm_lang$core$Native_Json$iife_private$mapMany(f, [d1]);
	}

	function _elm_lang$core$Native_Json$iife_private$oneOf(decoders) {
		return {
			ctor: '<decoder>',
			tag: 'oneOf',
			decoders: decoders
		};
	}

	function _elm_lang$core$Native_Json$iife_private$andThen(callback, decoder) {
		return {
			ctor: '<decoder>',
			tag: 'andThen',
			decoder: decoder,
			callback: callback
		};
	}

	function _elm_lang$core$Native_Json$iife_private$mapMany(f, decoders) {
		return {
			ctor: '<decoder>',
			tag: 'map-many',
			func: f,
			decoders: decoders
		};
	}

	function _elm_lang$core$Native_Json$iife_private$decodeKeyValuePairs(decoder) {
		return {
			ctor: '<decoder>',
			tag: 'key-value',
			decoder: decoder
		};
	}

	function _elm_lang$core$Native_Json$iife_private$decodeIndex(index, decoder) {
		return {
			ctor: '<decoder>',
			tag: 'index',
			index: index,
			decoder: decoder
		};
	}

	function _elm_lang$core$Native_Json$iife_private$decodeField(field, decoder) {
		return {
			ctor: '<decoder>',
			tag: 'field',
			field: field,
			decoder: decoder
		};
	}

	function _elm_lang$core$Native_Json$iife_private$decodeNull(value) {
		return {
			ctor: '<decoder>',
			tag: 'null',
			value: value
		};
	}

	function _elm_lang$core$Native_Json$iife_private$decodeContainer(tag, decoder) {
		return {
			ctor: '<decoder>',
			tag: tag,
			decoder: decoder
		};
	}

	function _elm_lang$core$Native_Json$iife_private$decodePrimitive(tag) {
		return {
			ctor: '<decoder>',
			tag: tag
		};
	}

	function _elm_lang$core$Native_Json$iife_private$fail(msg) {
		return {
			ctor: '<decoder>',
			tag: 'fail',
			msg: msg
		};
	}

	// CORE DECODERS

	function _elm_lang$core$Native_Json$iife_private$succeed(msg) {
		return {
			ctor: '<decoder>',
			tag: 'succeed',
			msg: msg
		};
	}var _elm_lang$core$Json_Encode$list = _elm_lang$core$Native_Json$iife_public$encodeList;
	var _elm_lang$core$Json_Encode$array = _elm_lang$core$Native_Json$iife_public$encodeArray;
	var _elm_lang$core$Json_Encode$object = _elm_lang$core$Native_Json$iife_public$encodeObject;
	var _elm_lang$core$Json_Encode$null = _elm_lang$core$Native_Json$iife_public$encodeNull;
	var _elm_lang$core$Json_Encode$bool = _elm_lang$core$Native_Json$iife_public$identity;
	var _elm_lang$core$Json_Encode$float = _elm_lang$core$Native_Json$iife_public$identity;
	var _elm_lang$core$Json_Encode$int = _elm_lang$core$Native_Json$iife_public$identity;
	var _elm_lang$core$Json_Encode$string = _elm_lang$core$Native_Json$iife_public$identity;
	var _elm_lang$core$Json_Encode$encode = _elm_lang$core$Native_Json$iife_public$encode;
	var _elm_lang$core$Json_Encode$Value = { ctor: 'Value' };

	var _elm_lang$core$Json_Decode$null = _elm_lang$core$Native_Json$iife_public$decodeNull;
	var _elm_lang$core$Json_Decode$value = /*#__PURE__*/_elm_lang$core$Native_Json$iife_public$decodePrimitive('value');
	var _elm_lang$core$Json_Decode$andThen = _elm_lang$core$Native_Json$iife_public$andThen;
	var _elm_lang$core$Json_Decode$fail = _elm_lang$core$Native_Json$iife_public$fail;
	var _elm_lang$core$Json_Decode$succeed = _elm_lang$core$Native_Json$iife_public$succeed;
	var _elm_lang$core$Json_Decode$lazy = function (thunk) {
		return A2(_elm_lang$core$Json_Decode$andThen, thunk, _elm_lang$core$Json_Decode$succeed({ ctor: '_Tuple0' }));
	};
	var _elm_lang$core$Json_Decode$decodeValue = _elm_lang$core$Native_Json$iife_public$run;
	var _elm_lang$core$Json_Decode$decodeString = _elm_lang$core$Native_Json$iife_public$runOnString;
	var _elm_lang$core$Json_Decode$map8 = _elm_lang$core$Native_Json$iife_public$map8;
	var _elm_lang$core$Json_Decode$map7 = _elm_lang$core$Native_Json$iife_public$map7;
	var _elm_lang$core$Json_Decode$map6 = _elm_lang$core$Native_Json$iife_public$map6;
	var _elm_lang$core$Json_Decode$map5 = _elm_lang$core$Native_Json$iife_public$map5;
	var _elm_lang$core$Json_Decode$map4 = _elm_lang$core$Native_Json$iife_public$map4;
	var _elm_lang$core$Json_Decode$map3 = _elm_lang$core$Native_Json$iife_public$map3;
	var _elm_lang$core$Json_Decode$map2 = _elm_lang$core$Native_Json$iife_public$map2;
	var _elm_lang$core$Json_Decode$map = _elm_lang$core$Native_Json$iife_public$map1;
	var _elm_lang$core$Json_Decode$oneOf = _elm_lang$core$Native_Json$iife_public$oneOf;
	var _elm_lang$core$Json_Decode$maybe = function (decoder) {
		return A2(_elm_lang$core$Native_Json$iife_public$decodeContainer, 'maybe', decoder);
	};
	var _elm_lang$core$Json_Decode$index = _elm_lang$core$Native_Json$iife_public$decodeIndex;
	var _elm_lang$core$Json_Decode$field = _elm_lang$core$Native_Json$iife_public$decodeField;
	var _elm_lang$core$Json_Decode$at = /*#__PURE__*/F2(function (fields, decoder) {
		return A3(_elm_lang$core$List$foldr, _elm_lang$core$Json_Decode$field, decoder, fields);
	});
	var _elm_lang$core$Json_Decode$keyValuePairs = _elm_lang$core$Native_Json$iife_public$decodeKeyValuePairs;
	var _elm_lang$core$Json_Decode$dict = function (decoder) {
		return A2(_elm_lang$core$Json_Decode$map, _elm_lang$core$Dict$fromList, _elm_lang$core$Json_Decode$keyValuePairs(decoder));
	};
	var _elm_lang$core$Json_Decode$array = function (decoder) {
		return A2(_elm_lang$core$Native_Json$iife_public$decodeContainer, 'array', decoder);
	};
	var _elm_lang$core$Json_Decode$list = function (decoder) {
		return A2(_elm_lang$core$Native_Json$iife_public$decodeContainer, 'list', decoder);
	};
	var _elm_lang$core$Json_Decode$nullable = function (decoder) {
		return _elm_lang$core$Json_Decode$oneOf({
			ctor: '::',
			_0: _elm_lang$core$Json_Decode$null(_elm_lang$core$Maybe$Nothing),
			_1: {
				ctor: '::',
				_0: A2(_elm_lang$core$Json_Decode$map, _elm_lang$core$Maybe$Just, decoder),
				_1: { ctor: '[]' }
			}
		});
	};
	var _elm_lang$core$Json_Decode$float = /*#__PURE__*/_elm_lang$core$Native_Json$iife_public$decodePrimitive('float');
	var _elm_lang$core$Json_Decode$int = /*#__PURE__*/_elm_lang$core$Native_Json$iife_public$decodePrimitive('int');
	var _elm_lang$core$Json_Decode$bool = /*#__PURE__*/_elm_lang$core$Native_Json$iife_public$decodePrimitive('bool');
	var _elm_lang$core$Json_Decode$string = /*#__PURE__*/_elm_lang$core$Native_Json$iife_public$decodePrimitive('string');
	var _elm_lang$core$Json_Decode$Decoder = { ctor: 'Decoder' };

	var _elm_lang$core$Tuple$mapSecond = /*#__PURE__*/F2(function (func, _p0) {
		var _p1 = _p0;
		return {
			ctor: '_Tuple2',
			_0: _p1._0,
			_1: func(_p1._1)
		};
	});
	var _elm_lang$core$Tuple$mapFirst = /*#__PURE__*/F2(function (func, _p2) {
		var _p3 = _p2;
		return {
			ctor: '_Tuple2',
			_0: func(_p3._0),
			_1: _p3._1
		};
	});
	var _elm_lang$core$Tuple$second = function (_p4) {
		var _p5 = _p4;
		return _p5._1;
	};
	var _elm_lang$core$Tuple$first = function (_p6) {
		var _p7 = _p6;
		return _p7._0;
	};

	var _elm_lang$dom$Native_Dom = {},
	    _elm_lang$dom$Native_Dom$iife_private$fakeNode = {
		addEventListener: function () {},
		removeEventListener: function () {}
	},
	    _elm_lang$dom$Native_Dom$iife_private$onDocument = /*#__PURE__*/_elm_lang$dom$Native_Dom$iife_private$on(typeof document !== 'undefined' ? document : _elm_lang$dom$Native_Dom$iife_private$fakeNode),
	    _elm_lang$dom$Native_Dom$iife_private$onWindow = /*#__PURE__*/_elm_lang$dom$Native_Dom$iife_private$on(typeof window !== 'undefined' ? window : _elm_lang$dom$Native_Dom$iife_private$fakeNode),
	    _elm_lang$dom$Native_Dom$iife_private$rAF = typeof requestAnimationFrame !== 'undefined' ? requestAnimationFrame : function (callback) {
		callback();
	},
	    _elm_lang$dom$Native_Dom$iife_public$onDocument = /*#__PURE__*/F3(_elm_lang$dom$Native_Dom$iife_private$onDocument),
	    _elm_lang$dom$Native_Dom$iife_public$onWindow = /*#__PURE__*/F3(_elm_lang$dom$Native_Dom$iife_private$onWindow),
	    _elm_lang$dom$Native_Dom$iife_public$focus = _elm_lang$dom$Native_Dom$iife_private$focus,
	    _elm_lang$dom$Native_Dom$iife_public$blur = _elm_lang$dom$Native_Dom$iife_private$blur,
	    _elm_lang$dom$Native_Dom$iife_public$getScrollTop = _elm_lang$dom$Native_Dom$iife_private$getScrollTop,
	    _elm_lang$dom$Native_Dom$iife_public$setScrollTop = /*#__PURE__*/F2(_elm_lang$dom$Native_Dom$iife_private$setScrollTop),
	    _elm_lang$dom$Native_Dom$iife_public$getScrollLeft = _elm_lang$dom$Native_Dom$iife_private$getScrollLeft,
	    _elm_lang$dom$Native_Dom$iife_public$setScrollLeft = /*#__PURE__*/F2(_elm_lang$dom$Native_Dom$iife_private$setScrollLeft),
	    _elm_lang$dom$Native_Dom$iife_public$toBottom = _elm_lang$dom$Native_Dom$iife_private$toBottom,
	    _elm_lang$dom$Native_Dom$iife_public$toRight = _elm_lang$dom$Native_Dom$iife_private$toRight,
	    _elm_lang$dom$Native_Dom$iife_public$height = /*#__PURE__*/F2(_elm_lang$dom$Native_Dom$iife_private$height),
	    _elm_lang$dom$Native_Dom$iife_public$width = /*#__PURE__*/F2(_elm_lang$dom$Native_Dom$iife_private$width);

	function _elm_lang$dom$Native_Dom$iife_private$height(options, id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			switch (options.ctor) {
				case 'Content':
					return node.scrollHeight;
				case 'VisibleContent':
					return node.clientHeight;
				case 'VisibleContentWithBorders':
					return node.offsetHeight;
				case 'VisibleContentWithBordersAndMargins':
					var rect = node.getBoundingClientRect();
					return rect.bottom - rect.top;
			}
		});
	}

	// SIZE

	function _elm_lang$dom$Native_Dom$iife_private$width(options, id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			switch (options.ctor) {
				case 'Content':
					return node.scrollWidth;
				case 'VisibleContent':
					return node.clientWidth;
				case 'VisibleContentWithBorders':
					return node.offsetWidth;
				case 'VisibleContentWithBordersAndMargins':
					var rect = node.getBoundingClientRect();
					return rect.right - rect.left;
			}
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$toRight(id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			node.scrollLeft = node.scrollWidth;
			return _elm_lang$core$Native_Utils$iife_public$Tuple0;
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$setScrollLeft(id, desiredScrollLeft) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			node.scrollLeft = desiredScrollLeft;
			return _elm_lang$core$Native_Utils$iife_public$Tuple0;
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$getScrollLeft(id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			return node.scrollLeft;
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$toBottom(id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			node.scrollTop = node.scrollHeight;
			return _elm_lang$core$Native_Utils$iife_public$Tuple0;
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$setScrollTop(id, desiredScrollTop) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			node.scrollTop = desiredScrollTop;
			return _elm_lang$core$Native_Utils$iife_public$Tuple0;
		});
	}

	// SCROLLING

	function _elm_lang$dom$Native_Dom$iife_private$getScrollTop(id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			return node.scrollTop;
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$blur(id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			node.blur();
			return _elm_lang$core$Native_Utils$iife_public$Tuple0;
		});
	}

	// FOCUS

	function _elm_lang$dom$Native_Dom$iife_private$focus(id) {
		return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function (node) {
			node.focus();
			return _elm_lang$core$Native_Utils$iife_public$Tuple0;
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$withNode(id, doStuff) {
		return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function (callback) {
			_elm_lang$dom$Native_Dom$iife_private$rAF(function () {
				var node = document.getElementById(id);
				if (node === null) {
					callback(_elm_lang$core$Native_Scheduler$iife_public$fail({ ctor: 'NotFound', _0: id }));
					return;
				}
				callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(doStuff(node)));
			});
		});
	}

	function _elm_lang$dom$Native_Dom$iife_private$on(node) {
		return function (eventName, decoder, toTask) {
			return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function (callback) {

				function performTask(event) {
					var result = A2(_elm_lang$core$Json_Decode$decodeValue, decoder, event);
					if (result.ctor === 'Ok') {
						_elm_lang$core$Native_Scheduler$iife_public$rawSpawn(toTask(result._0));
					}
				}

				node.addEventListener(eventName, performTask);

				return function () {
					node.removeEventListener(eventName, performTask);
				};
			});
		};
	}

	var _elm_lang$dom$Dom$blur = _elm_lang$dom$Native_Dom$iife_public$blur;
	var _elm_lang$dom$Dom$focus = _elm_lang$dom$Native_Dom$iife_public$focus;
	var _elm_lang$dom$Dom$NotFound = function (a) {
		return { ctor: 'NotFound', _0: a };
	};

	var _elm_lang$virtual_dom$VirtualDom_Debug$wrap;
	var _elm_lang$virtual_dom$VirtualDom_Debug$wrapWithFlags;

	var _elm_lang$virtual_dom$Native_VirtualDom = {},
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY = 'STYLE',
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY = 'EVENT',
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY = 'ATTR',
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY = 'ATTR_NS',
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = typeof document !== 'undefined' ? document : {},
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$POSTFIX = '_elmW6BL',
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$program = /*#__PURE__*/_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeProgram(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$checkNoFlags),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$programWithFlags = /*#__PURE__*/_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeProgram(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$checkYesFlags),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$rAF = typeof requestAnimationFrame !== 'undefined' ? requestAnimationFrame : function (callback) {
		setTimeout(callback, 1000 / 60);
	},
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$mostEvents = ['click', 'dblclick', 'mousemove', 'mouseup', 'mousedown', 'mouseenter', 'mouseleave', 'touchstart', 'touchend', 'touchcancel', 'touchmove', 'pointerdown', 'pointerup', 'pointerover', 'pointerout', 'pointerenter', 'pointerleave', 'pointermove', 'pointercancel', 'dragstart', 'drag', 'dragend', 'dragenter', 'dragover', 'dragleave', 'drop', 'keyup', 'keydown', 'keypress', 'input', 'change', 'focus', 'blur'],
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$allEvents = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$mostEvents.concat('wheel', 'scroll'),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$node = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$node,
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$text = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$text,
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$custom = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$custom,
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$map = /*#__PURE__*/F2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$map),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$on = /*#__PURE__*/F3(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$on),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$style = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$style,
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$property = /*#__PURE__*/F2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$property),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$attribute = /*#__PURE__*/F2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$attribute),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$attributeNS = /*#__PURE__*/F3(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$attributeNS),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$mapProperty = /*#__PURE__*/F2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$mapProperty),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy = /*#__PURE__*/F2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy2 = /*#__PURE__*/F3(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy2),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy3 = /*#__PURE__*/F4(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy3),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$keyedNode = /*#__PURE__*/F3(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$keyedNode),
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$program = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$program,
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$programWithFlags = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$programWithFlags,
	    _elm_lang$virtual_dom$Native_VirtualDom$iife_public$staticProgram = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$staticProgram;

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeIgnorer(overlayNode) {
		return function (event) {
			if (event.type === 'keydown' && event.metaKey && event.which === 82) {
				return;
			}

			var isScroll = event.type === 'scroll' || event.type === 'wheel';

			var node = event.target;
			while (node !== null) {
				if (node.className === 'elm-overlay-message-details' && isScroll) {
					return;
				}

				if (node === overlayNode && !isScroll) {
					return;
				}
				node = node.parentNode;
			}

			event.stopPropagation();
			event.preventDefault();
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverseHelp(verbEventListener, handler, eventNames) {
		for (var i = 0; i < eventNames.length; i++) {
			document.body[verbEventListener](eventNames[i], handler, true);
		}
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverse(verbEventListener, ignorer, blocking) {
		switch (blocking) {
			case 'Normal':
				return;

			case 'Pause':
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverseHelp(verbEventListener, ignorer, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$mostEvents);

			case 'Message':
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverseHelp(verbEventListener, ignorer, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$allEvents);
		}
	}

	// BLOCK EVENTS

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$wrapViewIn(appEventNode, overlayNode, viewIn) {
		var ignorer = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeIgnorer(overlayNode);
		var blocking = 'Normal';
		var overflow;

		var normalTagger = appEventNode.tagger;
		var blockTagger = function () {};

		return function (model) {
			var tuple = viewIn(model);
			var newBlocking = tuple._0.ctor;
			appEventNode.tagger = newBlocking === 'Normal' ? normalTagger : blockTagger;
			if (blocking !== newBlocking) {
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverse('removeEventListener', ignorer, blocking);
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverse('addEventListener', ignorer, newBlocking);

				if (blocking === 'Normal') {
					overflow = document.body.style.overflow;
					document.body.style.overflow = 'hidden';
				}

				if (newBlocking === 'Normal') {
					document.body.style.overflow = overflow;
				}

				blocking = newBlocking;
			}
			return tuple._1;
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$openDebugWindow(moduleName, popoutRef, virtualNode, eventNode) {
		var w = 900;
		var h = 360;
		var x = screen.width - w;
		var y = screen.height - h;
		var debugWindow = window.open('', '', 'width=' + w + ',height=' + h + ',left=' + x + ',top=' + y);

		// switch to window document
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = debugWindow.document;

		popoutRef.doc = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc;
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.title = 'Debugger - ' + moduleName;
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.body.style.margin = '0';
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.body.style.padding = '0';
		var domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(virtualNode, eventNode);
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.body.appendChild(domNode);

		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.addEventListener('keydown', function (event) {
			if (event.metaKey && event.which === 82) {
				window.location.reload();
			}
			if (event.which === 38) {
				eventNode.tagger({ ctor: 'Up' });
				event.preventDefault();
			}
			if (event.which === 40) {
				eventNode.tagger({ ctor: 'Down' });
				event.preventDefault();
			}
		});

		function close() {
			popoutRef.doc = undefined;
			debugWindow.close();
		}
		window.addEventListener('unload', close);
		debugWindow.addEventListener('unload', function () {
			popoutRef.doc = undefined;
			window.removeEventListener('unload', close);
			eventNode.tagger({ ctor: 'Close' });
		});

		// switch back to the normal document
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = document;

		return domNode;
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeDebugStepper(initialModel, view, eventNode, parentNode, moduleName, popoutRef) {
		var curr;
		var domNode;

		return function stepper(model) {
			if (!model.isDebuggerOpen) {
				return;
			}

			if (!popoutRef.doc) {
				curr = view(model);
				domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$openDebugWindow(moduleName, popoutRef, curr, eventNode);
				return;
			}

			// switch to document of popout
			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = popoutRef.doc;

			var next = view(model);
			var patches = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diff(curr, next);
			domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatches(domNode, curr, patches, eventNode);
			curr = next;

			// switch back to normal document
			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = document;
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugRenderer(moduleName, parentNode, popoutRef, view, viewIn, viewOut) {
		return function (tagger, initialModel) {
			var appEventNode = { tagger: tagger, parent: undefined };
			var eventNode = { tagger: tagger, parent: undefined };

			// make normal stepper
			var appVirtualNode = view(initialModel);
			var appNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(appVirtualNode, appEventNode);
			parentNode.appendChild(appNode);
			var appStepper = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(appNode, view, appVirtualNode, appEventNode);

			// make overlay stepper
			var overVirtualNode = viewIn(initialModel)._1;
			var overNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(overVirtualNode, eventNode);
			parentNode.appendChild(overNode);
			var wrappedViewIn = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$wrapViewIn(appEventNode, overNode, viewIn);
			var overStepper = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(overNode, wrappedViewIn, overVirtualNode, eventNode);

			// make debugger stepper
			var debugStepper = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeDebugStepper(initialModel, viewOut, eventNode, parentNode, moduleName, popoutRef);

			return function stepper(model) {
				appStepper(model);
				overStepper(model);
				debugStepper(model);
			};
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$scrollTask(popoutRef) {
		return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function (callback) {
			var doc = popoutRef.doc;
			if (doc) {
				var msgs = doc.getElementsByClassName('debugger-sidebar-messages')[0];
				if (msgs) {
					msgs.scrollTop = msgs.scrollHeight;
				}
			}
			callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(_elm_lang$core$Native_Utils$iife_public$Tuple0));
		});
	}

	// DEBUG SETUP

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugSetup(impl, object, moduleName, flagChecker) {
		object['fullscreen'] = function fullscreen(flags) {
			var popoutRef = { doc: undefined };
			return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, document.body), impl.update(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$scrollTask(popoutRef)), impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugRenderer(moduleName, document.body, popoutRef, impl.view, impl.viewIn, impl.viewOut));
		};

		object['embed'] = function fullscreen(node, flags) {
			var popoutRef = { doc: undefined };
			return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, node), impl.update(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$scrollTask(popoutRef)), impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugRenderer(moduleName, node, popoutRef, impl.view, impl.viewIn, impl.viewOut));
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(domNode, view, initialVirtualNode, eventNode) {
		var state = 'NO_REQUEST';
		var currNode = initialVirtualNode;
		var nextModel;

		function updateIfNeeded() {
			switch (state) {
				case 'NO_REQUEST':
					throw new Error('Unexpected draw callback.\n' + 'Please report this to <https://github.com/elm-lang/virtual-dom/issues>.');

				case 'PENDING_REQUEST':
					_elm_lang$virtual_dom$Native_VirtualDom$iife_private$rAF(updateIfNeeded);
					state = 'EXTRA_REQUEST';

					var nextNode = view(nextModel);
					var patches = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diff(currNode, nextNode);
					domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatches(domNode, currNode, patches, eventNode);
					currNode = nextNode;

					return;

				case 'EXTRA_REQUEST':
					state = 'NO_REQUEST';
					return;
			}
		}

		return function stepper(model) {
			if (state === 'NO_REQUEST') {
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$rAF(updateIfNeeded);
			}
			state = 'PENDING_REQUEST';
			nextModel = model;
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalRenderer(parentNode, view) {
		return function (tagger, initialModel) {
			var eventNode = { tagger: tagger, parent: undefined };
			var initialVirtualNode = view(initialModel);
			var domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(initialVirtualNode, eventNode);
			parentNode.appendChild(domNode);
			return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(domNode, view, initialVirtualNode, eventNode);
		};
	}

	// STEPPER

	//  NORMAL SETUP

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalSetup(impl, object, moduleName, flagChecker) {
		object['embed'] = function embed(node, flags) {
			while (node.lastChild) {
				node.removeChild(node.lastChild);
			}

			return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, node), impl.update, impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalRenderer(node, impl.view));
		};

		object['fullscreen'] = function fullscreen(flags) {
			return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, document.body), impl.update, impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalRenderer(document.body, impl.view));
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$crash(errorMessage, domNode) {
		if (domNode) {
			domNode.innerHTML = '<div style="padding-left:1em;">' + '<h2 style="font-weight:normal;"><b>Oops!</b> Something went wrong when starting your Elm program.</h2>' + '<pre style="padding-left:1em;">' + errorMessage + '</pre>' + '</div>';
		}

		throw new Error(errorMessage);
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$checkYesFlags(flagDecoder, moduleName) {
		return function (init, flags, domNode) {
			if (typeof flagDecoder === 'undefined') {
				var errorMessage = 'Are you trying to sneak a Never value into Elm? Trickster!\n' + 'It looks like ' + moduleName + '.main is defined with `programWithFlags` but has type `Program Never`.\n' + 'Use `program` instead if you do not want flags.';

				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$crash(errorMessage, domNode);
			}

			var result = A2(_elm_lang$core$Native_Json$iife_public$run, flagDecoder, flags);
			if (result.ctor === 'Ok') {
				return init(result._0);
			}

			var errorMessage = 'Trying to initialize the `' + moduleName + '` module with an unexpected flag.\n' + 'I tried to convert it to an Elm value, but ran into this problem:\n\n' + result._0;

			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$crash(errorMessage, domNode);
		};
	}

	// FLAG CHECKERS

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$checkNoFlags(flagDecoder, moduleName) {
		return function (init, flags, domNode) {
			if (typeof flags === 'undefined') {
				return init;
			}

			var errorMessage = 'The `' + moduleName + '` module does not need flags.\n' + 'Initialize it with no arguments and you should be all set!';

			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$crash(errorMessage, domNode);
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$staticProgram(vNode) {
		var nothing = _elm_lang$core$Native_Utils$iife_public$Tuple2(_elm_lang$core$Native_Utils$iife_public$Tuple0, _elm_lang$core$Platform_Cmd$none);
		return A2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$program, _elm_lang$virtual_dom$VirtualDom_Debug$wrap, {
			init: nothing,
			view: function () {
				return vNode;
			},
			update: /*#__PURE__*/F2(function () {
				return nothing;
			}),
			subscriptions: function () {
				return _elm_lang$core$Platform_Sub$none;
			}
		})();
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeProgram(flagChecker) {
		return (/*#__PURE__*/F2(function (debugWrap, impl) {
				return function (flagDecoder) {
					return function (object, moduleName, debugMetadata) {
						var checker = flagChecker(flagDecoder, moduleName);
						if (typeof debugMetadata === 'undefined') {
							_elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalSetup(impl, object, moduleName, checker);
						} else {
							_elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugSetup(A2(debugWrap, debugMetadata, impl), object, moduleName, checker);
						}
					};
				};
			})
		);
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorderEndInsertsHelp(endInserts, patch) {
		if (typeof endInserts === 'undefined') {
			return;
		}

		var frag = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createDocumentFragment();
		for (var i = 0; i < endInserts.length; i++) {
			var insert = endInserts[i];
			var entry = insert.entry;
			frag.appendChild(entry.tag === 'move' ? entry.data : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(entry.vnode, patch.eventNode));
		}
		return frag;
	}

	// PROGRAMS

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorder(domNode, patch) {
		var data = patch.data;

		// remove end inserts
		var frag = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorderEndInsertsHelp(data.endInserts, patch);

		// removals
		domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(domNode, data.patches);

		// inserts
		var inserts = data.inserts;
		for (var i = 0; i < inserts.length; i++) {
			var insert = inserts[i];
			var entry = insert.entry;
			var node = entry.tag === 'move' ? entry.data : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(entry.vnode, patch.eventNode);
			domNode.insertBefore(node, domNode.childNodes[insert.index]);
		}

		// add end inserts
		if (typeof frag !== 'undefined') {
			domNode.appendChild(frag);
		}

		return domNode;
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchRedraw(domNode, vNode, eventNode) {
		var parentNode = domNode.parentNode;
		var newNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(vNode, eventNode);

		if (typeof newNode.elm_event_node_ref === 'undefined') {
			newNode.elm_event_node_ref = domNode.elm_event_node_ref;
		}

		if (parentNode && newNode !== domNode) {
			parentNode.replaceChild(newNode, domNode);
		}
		return newNode;
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatch(domNode, patch) {
		switch (patch.type) {
			case 'p-redraw':
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchRedraw(domNode, patch.data, patch.eventNode);

			case 'p-facts':
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, patch.eventNode, patch.data);
				return domNode;

			case 'p-text':
				domNode.replaceData(0, domNode.length, patch.data);
				return domNode;

			case 'p-thunk':
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(domNode, patch.data);

			case 'p-tagger':
				if (typeof domNode.elm_event_node_ref !== 'undefined') {
					domNode.elm_event_node_ref.tagger = patch.data;
				} else {
					domNode.elm_event_node_ref = { tagger: patch.data, parent: patch.eventNode };
				}
				return domNode;

			case 'p-remove-last':
				var i = patch.data;
				while (i--) {
					domNode.removeChild(domNode.lastChild);
				}
				return domNode;

			case 'p-append':
				var newNodes = patch.data;
				for (var i = 0; i < newNodes.length; i++) {
					domNode.appendChild(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(newNodes[i], patch.eventNode));
				}
				return domNode;

			case 'p-remove':
				var data = patch.data;
				if (typeof data === 'undefined') {
					domNode.parentNode.removeChild(domNode);
					return domNode;
				}
				var entry = data.entry;
				if (typeof entry.index !== 'undefined') {
					domNode.parentNode.removeChild(domNode);
				}
				entry.data = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(domNode, data.patches);
				return domNode;

			case 'p-reorder':
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorder(domNode, patch);

			case 'p-custom':
				var impl = patch.data;
				return impl.applyPatch(domNode, impl.data);

			default:
				throw new Error('Ran into an unknown patch!');
		}
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(rootDomNode, patches) {
		for (var i = 0; i < patches.length; i++) {
			var patch = patches[i];
			var localDomNode = patch.domNode;
			var newNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatch(localDomNode, patch);
			if (localDomNode === rootDomNode) {
				rootDomNode = newNode;
			}
		}
		return rootDomNode;
	}

	////////////  APPLY PATCHES  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatches(rootDomNode, oldVirtualNode, patches, eventNode) {
		if (patches.length === 0) {
			return rootDomNode;
		}

		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
		return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(rootDomNode, patches);
	}

	// assumes `patches` is non-empty and indexes increase monotonically.
	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode) {
		var patch = patches[i];
		var index = patch.index;

		while (index === low) {
			var patchType = patch.type;

			if (patchType === 'p-thunk') {
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodes(domNode, vNode.node, patch.data, eventNode);
			} else if (patchType === 'p-reorder') {
				patch.domNode = domNode;
				patch.eventNode = eventNode;

				var subPatches = patch.data.patches;
				if (subPatches.length > 0) {
					_elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
				}
			} else if (patchType === 'p-remove') {
				patch.domNode = domNode;
				patch.eventNode = eventNode;

				var data = patch.data;
				if (typeof data !== 'undefined') {
					data.entry.data = domNode;
					var subPatches = data.patches;
					if (subPatches.length > 0) {
						_elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
					}
				}
			} else {
				patch.domNode = domNode;
				patch.eventNode = eventNode;
			}

			i++;

			if (!(patch = patches[i]) || (index = patch.index) > high) {
				return i;
			}
		}

		switch (vNode.type) {
			case 'tagger':
				var subNode = vNode.node;

				while (subNode.type === "tagger") {
					subNode = subNode.node;
				}

				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);

			case 'node':
				var vChildren = vNode.children;
				var childNodes = domNode.childNodes;
				for (var j = 0; j < vChildren.length; j++) {
					low++;
					var vChild = vChildren[j];
					var nextLow = low + (vChild.descendantsCount || 0);
					if (low <= index && index <= nextLow) {
						i = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode);
						if (!(patch = patches[i]) || (index = patch.index) > high) {
							return i;
						}
					}
					low = nextLow;
				}
				return i;

			case 'keyed-node':
				var vChildren = vNode.children;
				var childNodes = domNode.childNodes;
				for (var j = 0; j < vChildren.length; j++) {
					low++;
					var vChild = vChildren[j]._1;
					var nextLow = low + (vChild.descendantsCount || 0);
					if (low <= index && index <= nextLow) {
						i = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode);
						if (!(patch = patches[i]) || (index = patch.index) > high) {
							return i;
						}
					}
					low = nextLow;
				}
				return i;

			case 'text':
			case 'thunk':
				throw new Error('should never traverse `text` or `thunk` nodes like this');
		}
	}

	////////////  ADD DOM NODES  ////////////
	//
	// Each DOM node has an "index" assigned in order of traversal. It is important
	// to minimize our crawl over the actual DOM, so these indexes (along with the
	// descendantsCount of virtual nodes) let us skip touching entire subtrees of
	// the DOM if we know there are no patches there.


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodes(domNode, vNode, patches, eventNode) {
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.descendantsCount, eventNode);
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, key, vnode, index) {
		var entry = changes[key];

		// never seen this key before
		if (typeof entry === 'undefined') {
			var patch = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-remove', index, undefined);
			localPatches.push(patch);

			changes[key] = {
				tag: 'remove',
				vnode: vnode,
				index: index,
				data: patch
			};

			return;
		}

		// this key was inserted earlier, a match!
		if (entry.tag === 'insert') {
			entry.tag = 'move';
			var subPatches = [];
			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(vnode, entry.vnode, subPatches, index);

			var patch = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-remove', index, {
				patches: subPatches,
				entry: entry
			});
			localPatches.push(patch);

			return;
		}

		// this key has already been removed or moved, a duplicate!
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, key + _elm_lang$virtual_dom$Native_VirtualDom$iife_private$POSTFIX, vnode, index);
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, key, vnode, bIndex, inserts) {
		var entry = changes[key];

		// never seen this key before
		if (typeof entry === 'undefined') {
			entry = {
				tag: 'insert',
				vnode: vnode,
				index: bIndex,
				data: undefined
			};

			inserts.push({ index: bIndex, entry: entry });
			changes[key] = entry;

			return;
		}

		// this key was removed earlier, a match!
		if (entry.tag === 'remove') {
			inserts.push({ index: bIndex, entry: entry });

			entry.tag = 'move';
			var subPatches = [];
			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(entry.vnode, vnode, subPatches, entry.index);
			entry.index = bIndex;
			entry.data.data = {
				patches: subPatches,
				entry: entry
			};

			return;
		}

		// this key has already been inserted or moved, a duplicate!
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, key + _elm_lang$virtual_dom$Native_VirtualDom$iife_private$POSTFIX, vnode, bIndex, inserts);
	}

	////////////  KEYED DIFF  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffKeyedChildren(aParent, bParent, patches, rootIndex) {
		var localPatches = [];

		var changes = {}; // Dict String Entry
		var inserts = []; // Array { index : Int, entry : Entry }
		// type Entry = { tag : String, vnode : VNode, index : Int, data : _ }

		var aChildren = aParent.children;
		var bChildren = bParent.children;
		var aLen = aChildren.length;
		var bLen = bChildren.length;
		var aIndex = 0;
		var bIndex = 0;

		var index = rootIndex;

		while (aIndex < aLen && bIndex < bLen) {
			var a = aChildren[aIndex];
			var b = bChildren[bIndex];

			var aKey = a._0;
			var bKey = b._0;
			var aNode = a._1;
			var bNode = b._1;

			// check if keys match

			if (aKey === bKey) {
				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNode, bNode, localPatches, index);
				index += aNode.descendantsCount || 0;

				aIndex++;
				bIndex++;
				continue;
			}

			// look ahead 1 to detect insertions and removals.

			var aLookAhead = aIndex + 1 < aLen;
			var bLookAhead = bIndex + 1 < bLen;

			if (aLookAhead) {
				var aNext = aChildren[aIndex + 1];
				var aNextKey = aNext._0;
				var aNextNode = aNext._1;
				var oldMatch = bKey === aNextKey;
			}

			if (bLookAhead) {
				var bNext = bChildren[bIndex + 1];
				var bNextKey = bNext._0;
				var bNextNode = bNext._1;
				var newMatch = aKey === bNextKey;
			}

			// swap a and b
			if (aLookAhead && bLookAhead && newMatch && oldMatch) {
				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNode, bNextNode, localPatches, index);
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, aKey, bNode, bIndex, inserts);
				index += aNode.descendantsCount || 0;

				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, aKey, aNextNode, index);
				index += aNextNode.descendantsCount || 0;

				aIndex += 2;
				bIndex += 2;
				continue;
			}

			// insert b
			if (bLookAhead && newMatch) {
				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, bKey, bNode, bIndex, inserts);
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNode, bNextNode, localPatches, index);
				index += aNode.descendantsCount || 0;

				aIndex += 1;
				bIndex += 2;
				continue;
			}

			// remove a
			if (aLookAhead && oldMatch) {
				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, aKey, aNode, index);
				index += aNode.descendantsCount || 0;

				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNextNode, bNode, localPatches, index);
				index += aNextNode.descendantsCount || 0;

				aIndex += 2;
				bIndex += 1;
				continue;
			}

			// remove a, insert b
			if (aLookAhead && bLookAhead && aNextKey === bNextKey) {
				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, aKey, aNode, index);
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, bKey, bNode, bIndex, inserts);
				index += aNode.descendantsCount || 0;

				index++;
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNextNode, bNextNode, localPatches, index);
				index += aNextNode.descendantsCount || 0;

				aIndex += 2;
				bIndex += 2;
				continue;
			}

			break;
		}

		// eat up any remaining nodes with removeNode and insertNode

		while (aIndex < aLen) {
			index++;
			var a = aChildren[aIndex];
			var aNode = a._1;
			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, a._0, aNode, index);
			index += aNode.descendantsCount || 0;
			aIndex++;
		}

		var endInserts;
		while (bIndex < bLen) {
			endInserts = endInserts || [];
			var b = bChildren[bIndex];
			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, b._0, b._1, undefined, endInserts);
			bIndex++;
		}

		if (localPatches.length > 0 || inserts.length > 0 || typeof endInserts !== 'undefined') {
			patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-reorder', rootIndex, {
				patches: localPatches,
				inserts: inserts,
				endInserts: endInserts
			}));
		}
	}

	////////////  CHANGES FROM KEYED DIFF  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffChildren(aParent, bParent, patches, rootIndex) {
		var aChildren = aParent.children;
		var bChildren = bParent.children;

		var aLen = aChildren.length;
		var bLen = bChildren.length;

		// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS

		if (aLen > bLen) {
			patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-remove-last', rootIndex, aLen - bLen));
		} else if (aLen < bLen) {
			patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-append', rootIndex, bChildren.slice(aLen)));
		}

		// PAIRWISE DIFF EVERYTHING ELSE

		var index = rootIndex;
		var minLen = aLen < bLen ? aLen : bLen;
		for (var i = 0; i < minLen; i++) {
			index++;
			var aChild = aChildren[i];
			_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aChild, bChildren[i], patches, index);
			index += aChild.descendantsCount || 0;
		}
	}

	// TODO Instead of creating a new diff object, it's possible to just test if
	// there *is* a diff. During the actual patch, do the diff again and make the
	// modifications directly. This way, there's no new allocations. Worth it?
	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a, b, category) {
		var diff;

		// look for changes and removals
		for (var aKey in a) {
			if (aKey === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY || aKey === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY || aKey === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY || aKey === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY) {
				var subDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a[aKey], b[aKey] || {}, aKey);
				if (subDiff) {
					diff = diff || {};
					diff[aKey] = subDiff;
				}
				continue;
			}

			// remove if not in the new facts
			if (!(aKey in b)) {
				diff = diff || {};
				diff[aKey] = typeof category === 'undefined' ? typeof a[aKey] === 'string' ? '' : null : category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY ? '' : category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY || category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY ? undefined : { namespace: a[aKey].namespace, value: undefined };

				continue;
			}

			var aValue = a[aKey];
			var bValue = b[aKey];

			// reference equal, so don't worry about it
			if (aValue === bValue && aKey !== 'value' || category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY && _elm_lang$virtual_dom$Native_VirtualDom$iife_private$equalEvents(aValue, bValue)) {
				continue;
			}

			diff = diff || {};
			diff[aKey] = bValue;
		}

		// add new stuff
		for (var bKey in b) {
			if (!(bKey in a)) {
				diff = diff || {};
				diff[bKey] = b[bKey];
			}
		}

		return diff;
	}

	// assumes the incoming arrays are the same length
	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$pairwiseRefEqual(as, bs) {
		for (var i = 0; i < as.length; i++) {
			if (as[i] !== bs[i]) {
				return false;
			}
		}

		return true;
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(a, b, patches, index) {
		if (a === b) {
			return;
		}

		var aType = a.type;
		var bType = b.type;

		// Bail if you run into different types of nodes. Implies that the
		// structure has changed significantly and it's not worth a diff.
		if (aType !== bType) {
			patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-redraw', index, b));
			return;
		}

		// Now we know that both nodes are the same type.
		switch (bType) {
			case 'thunk':
				var aArgs = a.args;
				var bArgs = b.args;
				var i = aArgs.length;
				var same = a.func === b.func && i === bArgs.length;
				while (same && i--) {
					same = aArgs[i] === bArgs[i];
				}
				if (same) {
					b.node = a.node;
					return;
				}
				b.node = b.thunk();
				var subPatches = [];
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(a.node, b.node, subPatches, 0);
				if (subPatches.length > 0) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-thunk', index, subPatches));
				}
				return;

			case 'tagger':
				// gather nested taggers
				var aTaggers = a.tagger;
				var bTaggers = b.tagger;
				var nesting = false;

				var aSubNode = a.node;
				while (aSubNode.type === 'tagger') {
					nesting = true;

					typeof aTaggers !== 'object' ? aTaggers = [aTaggers, aSubNode.tagger] : aTaggers.push(aSubNode.tagger);

					aSubNode = aSubNode.node;
				}

				var bSubNode = b.node;
				while (bSubNode.type === 'tagger') {
					nesting = true;

					typeof bTaggers !== 'object' ? bTaggers = [bTaggers, bSubNode.tagger] : bTaggers.push(bSubNode.tagger);

					bSubNode = bSubNode.node;
				}

				// Just bail if different numbers of taggers. This implies the
				// structure of the virtual DOM has changed.
				if (nesting && aTaggers.length !== bTaggers.length) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-redraw', index, b));
					return;
				}

				// check if taggers are "the same"
				if (nesting ? !_elm_lang$virtual_dom$Native_VirtualDom$iife_private$pairwiseRefEqual(aTaggers, bTaggers) : aTaggers !== bTaggers) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-tagger', index, bTaggers));
				}

				// diff everything below the taggers
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aSubNode, bSubNode, patches, index + 1);
				return;

			case 'text':
				if (a.text !== b.text) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-text', index, b.text));
					return;
				}

				return;

			case 'node':
				// Bail if obvious indicators have changed. Implies more serious
				// structural changes such that it's not worth it to diff.
				if (a.tag !== b.tag || a.namespace !== b.namespace) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-redraw', index, b));
					return;
				}

				var factsDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a.facts, b.facts);

				if (typeof factsDiff !== 'undefined') {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-facts', index, factsDiff));
				}

				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffChildren(a, b, patches, index);
				return;

			case 'keyed-node':
				// Bail if obvious indicators have changed. Implies more serious
				// structural changes such that it's not worth it to diff.
				if (a.tag !== b.tag || a.namespace !== b.namespace) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-redraw', index, b));
					return;
				}

				var factsDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a.facts, b.facts);

				if (typeof factsDiff !== 'undefined') {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-facts', index, factsDiff));
				}

				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffKeyedChildren(a, b, patches, index);
				return;

			case 'custom':
				if (a.impl !== b.impl) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-redraw', index, b));
					return;
				}

				var factsDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a.facts, b.facts);
				if (typeof factsDiff !== 'undefined') {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-facts', index, factsDiff));
				}

				var patch = b.impl.diff(a, b);
				if (patch) {
					patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch('p-custom', index, patch));
					return;
				}

				return;
		}
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch(type, index, data) {
		return {
			index: index,
			type: type,
			data: data,
			domNode: undefined,
			eventNode: undefined
		};
	}

	////////////  DIFF  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diff(a, b) {
		var patches = [];
		_elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(a, b, patches, 0);
		return patches;
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrsNS(domNode, nsAttrs) {
		for (var key in nsAttrs) {
			var pair = nsAttrs[key];
			var namespace = pair.namespace;
			var value = pair.value;

			if (typeof value === 'undefined') {
				domNode.removeAttributeNS(namespace, key);
			} else {
				domNode.setAttributeNS(namespace, key, value);
			}
		}
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrs(domNode, attrs) {
		for (var key in attrs) {
			var value = attrs[key];
			if (typeof value === 'undefined') {
				domNode.removeAttribute(key);
			} else {
				domNode.setAttribute(key, value);
			}
		}
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeEventHandler(eventNode, info) {
		function eventHandler(event) {
			var info = eventHandler.info;

			var value = A2(_elm_lang$core$Native_Json$iife_public$run, info.decoder, event);

			if (value.ctor === 'Ok') {
				var options = info.options;
				if (options.stopPropagation) {
					event.stopPropagation();
				}
				if (options.preventDefault) {
					event.preventDefault();
				}

				var message = value._0;

				var currentEventNode = eventNode;
				while (currentEventNode) {
					var tagger = currentEventNode.tagger;
					if (typeof tagger === 'function') {
						message = tagger(message);
					} else {
						for (var i = tagger.length; i--;) {
							message = tagger[i](message);
						}
					}
					currentEventNode = currentEventNode.parent;
				}
			}
		};

		eventHandler.info = info;

		return eventHandler;
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyEvents(domNode, eventNode, events) {
		var allHandlers = domNode.elm_handlers || {};

		for (var key in events) {
			var handler = allHandlers[key];
			var value = events[key];

			if (typeof value === 'undefined') {
				domNode.removeEventListener(key, handler);
				allHandlers[key] = undefined;
			} else if (typeof handler === 'undefined') {
				var handler = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeEventHandler(eventNode, value);
				domNode.addEventListener(key, handler);
				allHandlers[key] = handler;
			} else {
				handler.info = value;
			}
		}

		domNode.elm_handlers = allHandlers;
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyStyles(domNode, styles) {
		var domNodeStyle = domNode.style;

		for (var key in styles) {
			domNodeStyle[key] = styles[key];
		}
	}

	////////////  APPLY FACTS  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, facts) {
		for (var key in facts) {
			var value = facts[key];

			switch (key) {
				case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY:
					_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyStyles(domNode, value);
					break;

				case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY:
					_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyEvents(domNode, eventNode, value);
					break;

				case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY:
					_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrs(domNode, value);
					break;

				case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY:
					_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrsNS(domNode, value);
					break;

				case 'value':
					if (domNode[key] !== value) {
						domNode[key] = value;
					}
					break;

				default:
					domNode[key] = value;
					break;
			}
		}
	}

	////////////  RENDER  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(vNode, eventNode) {
		switch (vNode.type) {
			case 'thunk':
				if (!vNode.node) {
					vNode.node = vNode.thunk();
				}
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(vNode.node, eventNode);

			case 'tagger':
				var subNode = vNode.node;
				var tagger = vNode.tagger;

				while (subNode.type === 'tagger') {
					typeof tagger !== 'object' ? tagger = [tagger, subNode.tagger] : tagger.push(subNode.tagger);

					subNode = subNode.node;
				}

				var subEventRoot = { tagger: tagger, parent: eventNode };
				var domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(subNode, subEventRoot);
				domNode.elm_event_node_ref = subEventRoot;
				return domNode;

			case 'text':
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createTextNode(vNode.text);

			case 'node':
				var domNode = vNode.namespace ? _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElementNS(vNode.namespace, vNode.tag) : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElement(vNode.tag);

				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, vNode.facts);

				var children = vNode.children;

				for (var i = 0; i < children.length; i++) {
					domNode.appendChild(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(children[i], eventNode));
				}

				return domNode;

			case 'keyed-node':
				var domNode = vNode.namespace ? _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElementNS(vNode.namespace, vNode.tag) : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElement(vNode.tag);

				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, vNode.facts);

				var children = vNode.children;

				for (var i = 0; i < children.length; i++) {
					domNode.appendChild(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(children[i]._1, eventNode));
				}

				return domNode;

			case 'custom':
				var domNode = vNode.impl.render(vNode.model);
				_elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, vNode.facts);
				return domNode;
		}
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$mapProperty(func, property) {
		if (property.key !== _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY) {
			return property;
		}
		return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$on(property.realKey, property.value.options, A2(_elm_lang$core$Json_Decode$map, func, property.value.decoder));
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$equalEvents(a, b) {
		if (a.options !== b.options) {
			if (a.options.stopPropagation !== b.options.stopPropagation || a.options.preventDefault !== b.options.preventDefault) {
				return false;
			}
		}
		return _elm_lang$core$Native_Json$iife_public$equality(a.decoder, b.decoder);
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$on(name, options, decoder) {
		return {
			key: _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY,
			realKey: name,
			value: {
				options: options,
				decoder: decoder
			}
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$attributeNS(namespace, key, value) {
		return {
			key: _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY,
			realKey: key,
			value: {
				value: value,
				namespace: namespace
			}
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$attribute(key, value) {
		return {
			key: _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY,
			realKey: key,
			value: value
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$property(key, value) {
		return {
			key: key,
			value: value
		};
	}

	////////////  PROPERTIES AND ATTRIBUTES  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$style(value) {
		return {
			key: _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY,
			value: value
		};
	}

	// FACTS


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$organizeFacts(factList) {
		var namespace,
		    facts = {};

		while (factList.ctor !== '[]') {
			var entry = factList._0;
			var key = entry.key;

			if (key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY || key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY || key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY) {
				var subFacts = facts[key] || {};
				subFacts[entry.realKey] = entry.value;
				facts[key] = subFacts;
			} else if (key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY) {
				var styles = facts[key] || {};
				var styleList = entry.value;
				while (styleList.ctor !== '[]') {
					var style = styleList._0;
					styles[style._0] = style._1;
					styleList = styleList._1;
				}
				facts[key] = styles;
			} else if (key === 'namespace') {
				namespace = entry.value;
			} else if (key === 'className') {
				var classes = facts[key];
				facts[key] = typeof classes === 'undefined' ? entry.value : classes + ' ' + entry.value;
			} else {
				facts[key] = entry.value;
			}
			factList = factList._1;
		}

		return {
			facts: facts,
			namespace: namespace
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy3(fn, a, b, c) {
		return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$thunk(fn, [a, b, c], function () {
			return A3(fn, a, b, c);
		});
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy2(fn, a, b) {
		return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$thunk(fn, [a, b], function () {
			return A2(fn, a, b);
		});
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy(fn, a) {
		return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$thunk(fn, [a], function () {
			return fn(a);
		});
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$thunk(func, args, thunk) {
		return {
			type: 'thunk',
			func: func,
			args: args,
			thunk: thunk,
			node: undefined
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$map(tagger, node) {
		return {
			type: 'tagger',
			tagger: tagger,
			node: node,
			descendantsCount: 1 + (node.descendantsCount || 0)
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$custom(factList, model, impl) {
		var facts = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$organizeFacts(factList).facts;

		return {
			type: 'custom',
			facts: facts,
			model: model,
			impl: impl
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$keyedNode(tag, factList, kidList) {
		var organized = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$organizeFacts(factList);
		var namespace = organized.namespace;
		var facts = organized.facts;

		var children = [];
		var descendantsCount = 0;
		while (kidList.ctor !== '[]') {
			var kid = kidList._0;
			descendantsCount += kid._1.descendantsCount || 0;
			children.push(kid);
			kidList = kidList._1;
		}
		descendantsCount += children.length;

		return {
			type: 'keyed-node',
			tag: tag,
			facts: facts,
			children: children,
			namespace: namespace,
			descendantsCount: descendantsCount
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$nodeHelp(tag, factList, kidList) {
		var organized = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$organizeFacts(factList);
		var namespace = organized.namespace;
		var facts = organized.facts;

		var children = [];
		var descendantsCount = 0;
		while (kidList.ctor !== '[]') {
			var kid = kidList._0;
			descendantsCount += kid.descendantsCount || 0;
			children.push(kid);
			kidList = kidList._1;
		}
		descendantsCount += children.length;

		return {
			type: 'node',
			tag: tag,
			facts: facts,
			children: children,
			namespace: namespace,
			descendantsCount: descendantsCount
		};
	}

	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$node(tag) {
		return (/*#__PURE__*/F2(function (factList, kidList) {
				return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$nodeHelp(tag, factList, kidList);
			})
		);
	}

	////////////  VIRTUAL DOM NODES  ////////////


	function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$text(string) {
		return {
			type: 'text',
			text: string
		};
	}var _elm_lang$virtual_dom$VirtualDom$programWithFlags = function (impl) {
		return A2(_elm_lang$virtual_dom$Native_VirtualDom$iife_public$programWithFlags, _elm_lang$virtual_dom$VirtualDom_Debug$wrapWithFlags, impl);
	};
	var _elm_lang$virtual_dom$VirtualDom$program = function (impl) {
		return A2(_elm_lang$virtual_dom$Native_VirtualDom$iife_public$program, _elm_lang$virtual_dom$VirtualDom_Debug$wrap, impl);
	};
	var _elm_lang$virtual_dom$VirtualDom$keyedNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$keyedNode;
	var _elm_lang$virtual_dom$VirtualDom$lazy3 = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy3;
	var _elm_lang$virtual_dom$VirtualDom$lazy2 = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy2;
	var _elm_lang$virtual_dom$VirtualDom$lazy = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy;
	var _elm_lang$virtual_dom$VirtualDom$defaultOptions = { stopPropagation: false, preventDefault: false };
	var _elm_lang$virtual_dom$VirtualDom$onWithOptions = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$on;
	var _elm_lang$virtual_dom$VirtualDom$on = /*#__PURE__*/F2(function (eventName, decoder) {
		return A3(_elm_lang$virtual_dom$VirtualDom$onWithOptions, eventName, _elm_lang$virtual_dom$VirtualDom$defaultOptions, decoder);
	});
	var _elm_lang$virtual_dom$VirtualDom$style = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$style;
	var _elm_lang$virtual_dom$VirtualDom$mapProperty = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$mapProperty;
	var _elm_lang$virtual_dom$VirtualDom$attributeNS = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$attributeNS;
	var _elm_lang$virtual_dom$VirtualDom$attribute = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$attribute;
	var _elm_lang$virtual_dom$VirtualDom$property = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$property;
	var _elm_lang$virtual_dom$VirtualDom$map = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$map;
	var _elm_lang$virtual_dom$VirtualDom$text = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$text;
	var _elm_lang$virtual_dom$VirtualDom$node = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$node;
	var _elm_lang$virtual_dom$VirtualDom$Options = /*#__PURE__*/F2(function (a, b) {
		return { stopPropagation: a, preventDefault: b };
	});
	var _elm_lang$virtual_dom$VirtualDom$Node = { ctor: 'Node' };
	var _elm_lang$virtual_dom$VirtualDom$Property = { ctor: 'Property' };

	var _elm_lang$html$Html$programWithFlags = _elm_lang$virtual_dom$VirtualDom$programWithFlags;
	var _elm_lang$html$Html$program = _elm_lang$virtual_dom$VirtualDom$program;
	var _elm_lang$html$Html$beginnerProgram = function (_p0) {
		var _p1 = _p0;
		return _elm_lang$html$Html$program({
			init: A2(_elm_lang$core$Platform_Cmd_ops['!'], _p1.model, { ctor: '[]' }),
			update: /*#__PURE__*/F2(function (msg, model) {
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], A2(_p1.update, msg, model), { ctor: '[]' });
			}),
			view: _p1.view,
			subscriptions: function (_p2) {
				return _elm_lang$core$Platform_Sub$none;
			}
		});
	};
	var _elm_lang$html$Html$map = _elm_lang$virtual_dom$VirtualDom$map;
	var _elm_lang$html$Html$text = _elm_lang$virtual_dom$VirtualDom$text;
	var _elm_lang$html$Html$node = _elm_lang$virtual_dom$VirtualDom$node;
	var _elm_lang$html$Html$body = /*#__PURE__*/_elm_lang$html$Html$node('body');
	var _elm_lang$html$Html$section = /*#__PURE__*/_elm_lang$html$Html$node('section');
	var _elm_lang$html$Html$nav = /*#__PURE__*/_elm_lang$html$Html$node('nav');
	var _elm_lang$html$Html$article = /*#__PURE__*/_elm_lang$html$Html$node('article');
	var _elm_lang$html$Html$aside = /*#__PURE__*/_elm_lang$html$Html$node('aside');
	var _elm_lang$html$Html$h1 = /*#__PURE__*/_elm_lang$html$Html$node('h1');
	var _elm_lang$html$Html$h2 = /*#__PURE__*/_elm_lang$html$Html$node('h2');
	var _elm_lang$html$Html$h3 = /*#__PURE__*/_elm_lang$html$Html$node('h3');
	var _elm_lang$html$Html$h4 = /*#__PURE__*/_elm_lang$html$Html$node('h4');
	var _elm_lang$html$Html$h5 = /*#__PURE__*/_elm_lang$html$Html$node('h5');
	var _elm_lang$html$Html$h6 = /*#__PURE__*/_elm_lang$html$Html$node('h6');
	var _elm_lang$html$Html$header = /*#__PURE__*/_elm_lang$html$Html$node('header');
	var _elm_lang$html$Html$footer = /*#__PURE__*/_elm_lang$html$Html$node('footer');
	var _elm_lang$html$Html$address = /*#__PURE__*/_elm_lang$html$Html$node('address');
	var _elm_lang$html$Html$main_ = /*#__PURE__*/_elm_lang$html$Html$node('main');
	var _elm_lang$html$Html$p = /*#__PURE__*/_elm_lang$html$Html$node('p');
	var _elm_lang$html$Html$hr = /*#__PURE__*/_elm_lang$html$Html$node('hr');
	var _elm_lang$html$Html$pre = /*#__PURE__*/_elm_lang$html$Html$node('pre');
	var _elm_lang$html$Html$blockquote = /*#__PURE__*/_elm_lang$html$Html$node('blockquote');
	var _elm_lang$html$Html$ol = /*#__PURE__*/_elm_lang$html$Html$node('ol');
	var _elm_lang$html$Html$ul = /*#__PURE__*/_elm_lang$html$Html$node('ul');
	var _elm_lang$html$Html$li = /*#__PURE__*/_elm_lang$html$Html$node('li');
	var _elm_lang$html$Html$dl = /*#__PURE__*/_elm_lang$html$Html$node('dl');
	var _elm_lang$html$Html$dt = /*#__PURE__*/_elm_lang$html$Html$node('dt');
	var _elm_lang$html$Html$dd = /*#__PURE__*/_elm_lang$html$Html$node('dd');
	var _elm_lang$html$Html$figure = /*#__PURE__*/_elm_lang$html$Html$node('figure');
	var _elm_lang$html$Html$figcaption = /*#__PURE__*/_elm_lang$html$Html$node('figcaption');
	var _elm_lang$html$Html$div = /*#__PURE__*/_elm_lang$html$Html$node('div');
	var _elm_lang$html$Html$a = /*#__PURE__*/_elm_lang$html$Html$node('a');
	var _elm_lang$html$Html$em = /*#__PURE__*/_elm_lang$html$Html$node('em');
	var _elm_lang$html$Html$strong = /*#__PURE__*/_elm_lang$html$Html$node('strong');
	var _elm_lang$html$Html$small = /*#__PURE__*/_elm_lang$html$Html$node('small');
	var _elm_lang$html$Html$s = /*#__PURE__*/_elm_lang$html$Html$node('s');
	var _elm_lang$html$Html$cite = /*#__PURE__*/_elm_lang$html$Html$node('cite');
	var _elm_lang$html$Html$q = /*#__PURE__*/_elm_lang$html$Html$node('q');
	var _elm_lang$html$Html$dfn = /*#__PURE__*/_elm_lang$html$Html$node('dfn');
	var _elm_lang$html$Html$abbr = /*#__PURE__*/_elm_lang$html$Html$node('abbr');
	var _elm_lang$html$Html$time = /*#__PURE__*/_elm_lang$html$Html$node('time');
	var _elm_lang$html$Html$code = /*#__PURE__*/_elm_lang$html$Html$node('code');
	var _elm_lang$html$Html$var = /*#__PURE__*/_elm_lang$html$Html$node('var');
	var _elm_lang$html$Html$samp = /*#__PURE__*/_elm_lang$html$Html$node('samp');
	var _elm_lang$html$Html$kbd = /*#__PURE__*/_elm_lang$html$Html$node('kbd');
	var _elm_lang$html$Html$sub = /*#__PURE__*/_elm_lang$html$Html$node('sub');
	var _elm_lang$html$Html$sup = /*#__PURE__*/_elm_lang$html$Html$node('sup');
	var _elm_lang$html$Html$i = /*#__PURE__*/_elm_lang$html$Html$node('i');
	var _elm_lang$html$Html$b = /*#__PURE__*/_elm_lang$html$Html$node('b');
	var _elm_lang$html$Html$u = /*#__PURE__*/_elm_lang$html$Html$node('u');
	var _elm_lang$html$Html$mark = /*#__PURE__*/_elm_lang$html$Html$node('mark');
	var _elm_lang$html$Html$ruby = /*#__PURE__*/_elm_lang$html$Html$node('ruby');
	var _elm_lang$html$Html$rt = /*#__PURE__*/_elm_lang$html$Html$node('rt');
	var _elm_lang$html$Html$rp = /*#__PURE__*/_elm_lang$html$Html$node('rp');
	var _elm_lang$html$Html$bdi = /*#__PURE__*/_elm_lang$html$Html$node('bdi');
	var _elm_lang$html$Html$bdo = /*#__PURE__*/_elm_lang$html$Html$node('bdo');
	var _elm_lang$html$Html$span = /*#__PURE__*/_elm_lang$html$Html$node('span');
	var _elm_lang$html$Html$br = /*#__PURE__*/_elm_lang$html$Html$node('br');
	var _elm_lang$html$Html$wbr = /*#__PURE__*/_elm_lang$html$Html$node('wbr');
	var _elm_lang$html$Html$ins = /*#__PURE__*/_elm_lang$html$Html$node('ins');
	var _elm_lang$html$Html$del = /*#__PURE__*/_elm_lang$html$Html$node('del');
	var _elm_lang$html$Html$img = /*#__PURE__*/_elm_lang$html$Html$node('img');
	var _elm_lang$html$Html$iframe = /*#__PURE__*/_elm_lang$html$Html$node('iframe');
	var _elm_lang$html$Html$embed = /*#__PURE__*/_elm_lang$html$Html$node('embed');
	var _elm_lang$html$Html$object = /*#__PURE__*/_elm_lang$html$Html$node('object');
	var _elm_lang$html$Html$param = /*#__PURE__*/_elm_lang$html$Html$node('param');
	var _elm_lang$html$Html$video = /*#__PURE__*/_elm_lang$html$Html$node('video');
	var _elm_lang$html$Html$audio = /*#__PURE__*/_elm_lang$html$Html$node('audio');
	var _elm_lang$html$Html$source = /*#__PURE__*/_elm_lang$html$Html$node('source');
	var _elm_lang$html$Html$track = /*#__PURE__*/_elm_lang$html$Html$node('track');
	var _elm_lang$html$Html$canvas = /*#__PURE__*/_elm_lang$html$Html$node('canvas');
	var _elm_lang$html$Html$math = /*#__PURE__*/_elm_lang$html$Html$node('math');
	var _elm_lang$html$Html$table = /*#__PURE__*/_elm_lang$html$Html$node('table');
	var _elm_lang$html$Html$caption = /*#__PURE__*/_elm_lang$html$Html$node('caption');
	var _elm_lang$html$Html$colgroup = /*#__PURE__*/_elm_lang$html$Html$node('colgroup');
	var _elm_lang$html$Html$col = /*#__PURE__*/_elm_lang$html$Html$node('col');
	var _elm_lang$html$Html$tbody = /*#__PURE__*/_elm_lang$html$Html$node('tbody');
	var _elm_lang$html$Html$thead = /*#__PURE__*/_elm_lang$html$Html$node('thead');
	var _elm_lang$html$Html$tfoot = /*#__PURE__*/_elm_lang$html$Html$node('tfoot');
	var _elm_lang$html$Html$tr = /*#__PURE__*/_elm_lang$html$Html$node('tr');
	var _elm_lang$html$Html$td = /*#__PURE__*/_elm_lang$html$Html$node('td');
	var _elm_lang$html$Html$th = /*#__PURE__*/_elm_lang$html$Html$node('th');
	var _elm_lang$html$Html$form = /*#__PURE__*/_elm_lang$html$Html$node('form');
	var _elm_lang$html$Html$fieldset = /*#__PURE__*/_elm_lang$html$Html$node('fieldset');
	var _elm_lang$html$Html$legend = /*#__PURE__*/_elm_lang$html$Html$node('legend');
	var _elm_lang$html$Html$label = /*#__PURE__*/_elm_lang$html$Html$node('label');
	var _elm_lang$html$Html$input = /*#__PURE__*/_elm_lang$html$Html$node('input');
	var _elm_lang$html$Html$button = /*#__PURE__*/_elm_lang$html$Html$node('button');
	var _elm_lang$html$Html$select = /*#__PURE__*/_elm_lang$html$Html$node('select');
	var _elm_lang$html$Html$datalist = /*#__PURE__*/_elm_lang$html$Html$node('datalist');
	var _elm_lang$html$Html$optgroup = /*#__PURE__*/_elm_lang$html$Html$node('optgroup');
	var _elm_lang$html$Html$option = /*#__PURE__*/_elm_lang$html$Html$node('option');
	var _elm_lang$html$Html$textarea = /*#__PURE__*/_elm_lang$html$Html$node('textarea');
	var _elm_lang$html$Html$keygen = /*#__PURE__*/_elm_lang$html$Html$node('keygen');
	var _elm_lang$html$Html$output = /*#__PURE__*/_elm_lang$html$Html$node('output');
	var _elm_lang$html$Html$progress = /*#__PURE__*/_elm_lang$html$Html$node('progress');
	var _elm_lang$html$Html$meter = /*#__PURE__*/_elm_lang$html$Html$node('meter');
	var _elm_lang$html$Html$details = /*#__PURE__*/_elm_lang$html$Html$node('details');
	var _elm_lang$html$Html$summary = /*#__PURE__*/_elm_lang$html$Html$node('summary');
	var _elm_lang$html$Html$menuitem = /*#__PURE__*/_elm_lang$html$Html$node('menuitem');
	var _elm_lang$html$Html$menu = /*#__PURE__*/_elm_lang$html$Html$node('menu');

	var _elm_lang$html$Html_Attributes$map = _elm_lang$virtual_dom$VirtualDom$mapProperty;
	var _elm_lang$html$Html_Attributes$attribute = _elm_lang$virtual_dom$VirtualDom$attribute;
	var _elm_lang$html$Html_Attributes$contextmenu = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'contextmenu', value);
	};
	var _elm_lang$html$Html_Attributes$draggable = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'draggable', value);
	};
	var _elm_lang$html$Html_Attributes$itemprop = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'itemprop', value);
	};
	var _elm_lang$html$Html_Attributes$tabindex = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'tabIndex', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$charset = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'charset', value);
	};
	var _elm_lang$html$Html_Attributes$height = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'height', _elm_lang$core$Basics$toString(value));
	};
	var _elm_lang$html$Html_Attributes$width = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'width', _elm_lang$core$Basics$toString(value));
	};
	var _elm_lang$html$Html_Attributes$formaction = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'formAction', value);
	};
	var _elm_lang$html$Html_Attributes$list = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'list', value);
	};
	var _elm_lang$html$Html_Attributes$minlength = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'minLength', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$maxlength = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'maxlength', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$size = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'size', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$form = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'form', value);
	};
	var _elm_lang$html$Html_Attributes$cols = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'cols', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$rows = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'rows', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$challenge = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'challenge', value);
	};
	var _elm_lang$html$Html_Attributes$media = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'media', value);
	};
	var _elm_lang$html$Html_Attributes$rel = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'rel', value);
	};
	var _elm_lang$html$Html_Attributes$datetime = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'datetime', value);
	};
	var _elm_lang$html$Html_Attributes$pubdate = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'pubdate', value);
	};
	var _elm_lang$html$Html_Attributes$colspan = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'colspan', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$rowspan = function (n) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'rowspan', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$manifest = function (value) {
		return A2(_elm_lang$html$Html_Attributes$attribute, 'manifest', value);
	};
	var _elm_lang$html$Html_Attributes$property = _elm_lang$virtual_dom$VirtualDom$property;
	var _elm_lang$html$Html_Attributes$stringProperty = /*#__PURE__*/F2(function (name, string) {
		return A2(_elm_lang$html$Html_Attributes$property, name, _elm_lang$core$Json_Encode$string(string));
	});
	var _elm_lang$html$Html_Attributes$class = function (name) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'className', name);
	};
	var _elm_lang$html$Html_Attributes$id = function (name) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'id', name);
	};
	var _elm_lang$html$Html_Attributes$title = function (name) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'title', name);
	};
	var _elm_lang$html$Html_Attributes$accesskey = function ($char) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'accessKey', _elm_lang$core$String$fromChar($char));
	};
	var _elm_lang$html$Html_Attributes$dir = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'dir', value);
	};
	var _elm_lang$html$Html_Attributes$dropzone = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'dropzone', value);
	};
	var _elm_lang$html$Html_Attributes$lang = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'lang', value);
	};
	var _elm_lang$html$Html_Attributes$content = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'content', value);
	};
	var _elm_lang$html$Html_Attributes$httpEquiv = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'httpEquiv', value);
	};
	var _elm_lang$html$Html_Attributes$language = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'language', value);
	};
	var _elm_lang$html$Html_Attributes$src = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'src', value);
	};
	var _elm_lang$html$Html_Attributes$alt = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'alt', value);
	};
	var _elm_lang$html$Html_Attributes$preload = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'preload', value);
	};
	var _elm_lang$html$Html_Attributes$poster = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'poster', value);
	};
	var _elm_lang$html$Html_Attributes$kind = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'kind', value);
	};
	var _elm_lang$html$Html_Attributes$srclang = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'srclang', value);
	};
	var _elm_lang$html$Html_Attributes$sandbox = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'sandbox', value);
	};
	var _elm_lang$html$Html_Attributes$srcdoc = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'srcdoc', value);
	};
	var _elm_lang$html$Html_Attributes$type_ = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'type', value);
	};
	var _elm_lang$html$Html_Attributes$value = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'value', value);
	};
	var _elm_lang$html$Html_Attributes$defaultValue = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'defaultValue', value);
	};
	var _elm_lang$html$Html_Attributes$placeholder = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'placeholder', value);
	};
	var _elm_lang$html$Html_Attributes$accept = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'accept', value);
	};
	var _elm_lang$html$Html_Attributes$acceptCharset = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'acceptCharset', value);
	};
	var _elm_lang$html$Html_Attributes$action = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'action', value);
	};
	var _elm_lang$html$Html_Attributes$autocomplete = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'autocomplete', bool ? 'on' : 'off');
	};
	var _elm_lang$html$Html_Attributes$enctype = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'enctype', value);
	};
	var _elm_lang$html$Html_Attributes$method = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'method', value);
	};
	var _elm_lang$html$Html_Attributes$name = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'name', value);
	};
	var _elm_lang$html$Html_Attributes$pattern = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'pattern', value);
	};
	var _elm_lang$html$Html_Attributes$for = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'htmlFor', value);
	};
	var _elm_lang$html$Html_Attributes$max = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'max', value);
	};
	var _elm_lang$html$Html_Attributes$min = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'min', value);
	};
	var _elm_lang$html$Html_Attributes$step = function (n) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'step', n);
	};
	var _elm_lang$html$Html_Attributes$wrap = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'wrap', value);
	};
	var _elm_lang$html$Html_Attributes$usemap = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'useMap', value);
	};
	var _elm_lang$html$Html_Attributes$shape = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'shape', value);
	};
	var _elm_lang$html$Html_Attributes$coords = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'coords', value);
	};
	var _elm_lang$html$Html_Attributes$keytype = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'keytype', value);
	};
	var _elm_lang$html$Html_Attributes$align = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'align', value);
	};
	var _elm_lang$html$Html_Attributes$cite = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'cite', value);
	};
	var _elm_lang$html$Html_Attributes$href = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'href', value);
	};
	var _elm_lang$html$Html_Attributes$target = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'target', value);
	};
	var _elm_lang$html$Html_Attributes$downloadAs = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'download', value);
	};
	var _elm_lang$html$Html_Attributes$hreflang = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'hreflang', value);
	};
	var _elm_lang$html$Html_Attributes$ping = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'ping', value);
	};
	var _elm_lang$html$Html_Attributes$start = function (n) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'start', _elm_lang$core$Basics$toString(n));
	};
	var _elm_lang$html$Html_Attributes$headers = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'headers', value);
	};
	var _elm_lang$html$Html_Attributes$scope = function (value) {
		return A2(_elm_lang$html$Html_Attributes$stringProperty, 'scope', value);
	};
	var _elm_lang$html$Html_Attributes$boolProperty = /*#__PURE__*/F2(function (name, bool) {
		return A2(_elm_lang$html$Html_Attributes$property, name, _elm_lang$core$Json_Encode$bool(bool));
	});
	var _elm_lang$html$Html_Attributes$hidden = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'hidden', bool);
	};
	var _elm_lang$html$Html_Attributes$contenteditable = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'contentEditable', bool);
	};
	var _elm_lang$html$Html_Attributes$spellcheck = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'spellcheck', bool);
	};
	var _elm_lang$html$Html_Attributes$async = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'async', bool);
	};
	var _elm_lang$html$Html_Attributes$defer = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'defer', bool);
	};
	var _elm_lang$html$Html_Attributes$scoped = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'scoped', bool);
	};
	var _elm_lang$html$Html_Attributes$autoplay = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'autoplay', bool);
	};
	var _elm_lang$html$Html_Attributes$controls = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'controls', bool);
	};
	var _elm_lang$html$Html_Attributes$loop = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'loop', bool);
	};
	var _elm_lang$html$Html_Attributes$default = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'default', bool);
	};
	var _elm_lang$html$Html_Attributes$seamless = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'seamless', bool);
	};
	var _elm_lang$html$Html_Attributes$checked = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'checked', bool);
	};
	var _elm_lang$html$Html_Attributes$selected = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'selected', bool);
	};
	var _elm_lang$html$Html_Attributes$autofocus = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'autofocus', bool);
	};
	var _elm_lang$html$Html_Attributes$disabled = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'disabled', bool);
	};
	var _elm_lang$html$Html_Attributes$multiple = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'multiple', bool);
	};
	var _elm_lang$html$Html_Attributes$novalidate = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'noValidate', bool);
	};
	var _elm_lang$html$Html_Attributes$readonly = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'readOnly', bool);
	};
	var _elm_lang$html$Html_Attributes$required = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'required', bool);
	};
	var _elm_lang$html$Html_Attributes$ismap = function (value) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'isMap', value);
	};
	var _elm_lang$html$Html_Attributes$download = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'download', bool);
	};
	var _elm_lang$html$Html_Attributes$reversed = function (bool) {
		return A2(_elm_lang$html$Html_Attributes$boolProperty, 'reversed', bool);
	};
	var _elm_lang$html$Html_Attributes$classList = function (list) {
		return _elm_lang$html$Html_Attributes$class(A2(_elm_lang$core$String$join, ' ', A2(_elm_lang$core$List$map, _elm_lang$core$Tuple$first, A2(_elm_lang$core$List$filter, _elm_lang$core$Tuple$second, list))));
	};
	var _elm_lang$html$Html_Attributes$style = _elm_lang$virtual_dom$VirtualDom$style;

	var _elm_lang$html$Html_Events$keyCode = A2(_elm_lang$core$Json_Decode$field, 'keyCode', _elm_lang$core$Json_Decode$int);
	var _elm_lang$html$Html_Events$targetChecked = A2(_elm_lang$core$Json_Decode$at, {
		ctor: '::',
		_0: 'target',
		_1: {
			ctor: '::',
			_0: 'checked',
			_1: { ctor: '[]' }
		}
	}, _elm_lang$core$Json_Decode$bool);
	var _elm_lang$html$Html_Events$targetValue = A2(_elm_lang$core$Json_Decode$at, {
		ctor: '::',
		_0: 'target',
		_1: {
			ctor: '::',
			_0: 'value',
			_1: { ctor: '[]' }
		}
	}, _elm_lang$core$Json_Decode$string);
	var _elm_lang$html$Html_Events$defaultOptions = _elm_lang$virtual_dom$VirtualDom$defaultOptions;
	var _elm_lang$html$Html_Events$onWithOptions = _elm_lang$virtual_dom$VirtualDom$onWithOptions;
	var _elm_lang$html$Html_Events$on = _elm_lang$virtual_dom$VirtualDom$on;
	var _elm_lang$html$Html_Events$onFocus = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'focus', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onBlur = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'blur', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onSubmitOptions = /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(_elm_lang$html$Html_Events$defaultOptions, { preventDefault: true });
	var _elm_lang$html$Html_Events$onSubmit = function (msg) {
		return A3(_elm_lang$html$Html_Events$onWithOptions, 'submit', _elm_lang$html$Html_Events$onSubmitOptions, _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onCheck = function (tagger) {
		return A2(_elm_lang$html$Html_Events$on, 'change', A2(_elm_lang$core$Json_Decode$map, tagger, _elm_lang$html$Html_Events$targetChecked));
	};
	var _elm_lang$html$Html_Events$onInput = function (tagger) {
		return A2(_elm_lang$html$Html_Events$on, 'input', A2(_elm_lang$core$Json_Decode$map, tagger, _elm_lang$html$Html_Events$targetValue));
	};
	var _elm_lang$html$Html_Events$onMouseOut = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'mouseout', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onMouseOver = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'mouseover', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onMouseLeave = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'mouseleave', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onMouseEnter = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'mouseenter', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onMouseUp = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'mouseup', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onMouseDown = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'mousedown', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onDoubleClick = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'dblclick', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$onClick = function (msg) {
		return A2(_elm_lang$html$Html_Events$on, 'click', _elm_lang$core$Json_Decode$succeed(msg));
	};
	var _elm_lang$html$Html_Events$Options = /*#__PURE__*/F2(function (a, b) {
		return { stopPropagation: a, preventDefault: b };
	});

	var _elm_lang$html$Html_Keyed$node = _elm_lang$virtual_dom$VirtualDom$keyedNode;
	var _elm_lang$html$Html_Keyed$ol = /*#__PURE__*/_elm_lang$html$Html_Keyed$node('ol');
	var _elm_lang$html$Html_Keyed$ul = /*#__PURE__*/_elm_lang$html$Html_Keyed$node('ul');

	var _elm_lang$html$Html_Lazy$lazy3 = _elm_lang$virtual_dom$VirtualDom$lazy3;
	var _elm_lang$html$Html_Lazy$lazy2 = _elm_lang$virtual_dom$VirtualDom$lazy2;
	var _elm_lang$html$Html_Lazy$lazy = _elm_lang$virtual_dom$VirtualDom$lazy;

	var _evancz$elm_todomvc$Todo$infoFooter = A2(_elm_lang$html$Html$footer, {
		ctor: '::',
		_0: _elm_lang$html$Html_Attributes$class('info'),
		_1: { ctor: '[]' }
	}, {
		ctor: '::',
		_0: A2(_elm_lang$html$Html$p, { ctor: '[]' }, {
			ctor: '::',
			_0: _elm_lang$html$Html$text('Double-click to edit a todo'),
			_1: { ctor: '[]' }
		}),
		_1: {
			ctor: '::',
			_0: A2(_elm_lang$html$Html$p, { ctor: '[]' }, {
				ctor: '::',
				_0: _elm_lang$html$Html$text('Written by '),
				_1: {
					ctor: '::',
					_0: A2(_elm_lang$html$Html$a, {
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$href('https://github.com/evancz'),
						_1: { ctor: '[]' }
					}, {
						ctor: '::',
						_0: _elm_lang$html$Html$text('Evan Czaplicki'),
						_1: { ctor: '[]' }
					}),
					_1: { ctor: '[]' }
				}
			}),
			_1: {
				ctor: '::',
				_0: A2(_elm_lang$html$Html$p, { ctor: '[]' }, {
					ctor: '::',
					_0: _elm_lang$html$Html$text('Part of '),
					_1: {
						ctor: '::',
						_0: A2(_elm_lang$html$Html$a, {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$href('http://todomvc.com'),
							_1: { ctor: '[]' }
						}, {
							ctor: '::',
							_0: _elm_lang$html$Html$text('TodoMVC'),
							_1: { ctor: '[]' }
						}),
						_1: { ctor: '[]' }
					}
				}),
				_1: { ctor: '[]' }
			}
		}
	});
	var _evancz$elm_todomvc$Todo$viewControlsCount = function (entriesLeft) {
		var item_ = _elm_lang$core$Native_Utils$iife_public$eq(entriesLeft, 1) ? ' item' : ' items';
		return A2(_elm_lang$html$Html$span, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('todo-count'),
			_1: { ctor: '[]' }
		}, {
			ctor: '::',
			_0: A2(_elm_lang$html$Html$strong, { ctor: '[]' }, {
				ctor: '::',
				_0: _elm_lang$html$Html$text(_elm_lang$core$Basics$toString(entriesLeft)),
				_1: { ctor: '[]' }
			}),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html$text(A2(_elm_lang$core$Basics_ops['++'], item_, ' left')),
				_1: { ctor: '[]' }
			}
		});
	};
	var _evancz$elm_todomvc$Todo$onEnter = function (msg) {
		var isEnter = function (code) {
			return _elm_lang$core$Native_Utils$iife_public$eq(code, 13) ? _elm_lang$core$Json_Decode$succeed(msg) : _elm_lang$core$Json_Decode$fail('not ENTER');
		};
		return A2(_elm_lang$html$Html_Events$on, 'keydown', A2(_elm_lang$core$Json_Decode$andThen, isEnter, _elm_lang$html$Html_Events$keyCode));
	};
	var _evancz$elm_todomvc$Todo$newEntry = /*#__PURE__*/F2(function (desc, id) {
		return { description: desc, completed: false, editing: false, id: id };
	});
	var _evancz$elm_todomvc$Todo$emptyModel = {
		entries: { ctor: '[]' },
		visibility: 'All',
		field: '',
		uid: 0
	};
	var _evancz$elm_todomvc$Todo$init = function (savedModel) {
		return A2(_elm_lang$core$Platform_Cmd_ops['!'], A2(_elm_lang$core$Maybe$withDefault, _evancz$elm_todomvc$Todo$emptyModel, savedModel), { ctor: '[]' });
	};
	var _evancz$elm_todomvc$Todo$setStorage = _elm_lang$core$Native_Platform$iife_public$outgoingPort('setStorage', function (v) {
		return {
			entries: _elm_lang$core$Native_List$iife_public$toArray(v.entries).map(function (v) {
				return { description: v.description, completed: v.completed, editing: v.editing, id: v.id };
			}),
			field: v.field,
			uid: v.uid,
			visibility: v.visibility
		};
	});
	var _evancz$elm_todomvc$Todo$Model = /*#__PURE__*/F4(function (a, b, c, d) {
		return { entries: a, field: b, uid: c, visibility: d };
	});
	var _evancz$elm_todomvc$Todo$Entry = /*#__PURE__*/F4(function (a, b, c, d) {
		return { description: a, completed: b, editing: c, id: d };
	});
	var _evancz$elm_todomvc$Todo$ChangeVisibility = function (a) {
		return { ctor: 'ChangeVisibility', _0: a };
	};
	var _evancz$elm_todomvc$Todo$visibilitySwap = /*#__PURE__*/F3(function (uri, visibility, actualVisibility) {
		return A2(_elm_lang$html$Html$li, {
			ctor: '::',
			_0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$ChangeVisibility(visibility)),
			_1: { ctor: '[]' }
		}, {
			ctor: '::',
			_0: A2(_elm_lang$html$Html$a, {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$href(uri),
				_1: {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$classList({
						ctor: '::',
						_0: {
							ctor: '_Tuple2',
							_0: 'selected',
							_1: _elm_lang$core$Native_Utils$iife_public$eq(visibility, actualVisibility)
						},
						_1: { ctor: '[]' }
					}),
					_1: { ctor: '[]' }
				}
			}, {
				ctor: '::',
				_0: _elm_lang$html$Html$text(visibility),
				_1: { ctor: '[]' }
			}),
			_1: { ctor: '[]' }
		});
	});
	var _evancz$elm_todomvc$Todo$viewControlsFilters = function (visibility) {
		return A2(_elm_lang$html$Html$ul, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('filters'),
			_1: { ctor: '[]' }
		}, {
			ctor: '::',
			_0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, '#/', 'All', visibility),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html$text(' '),
				_1: {
					ctor: '::',
					_0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, '#/active', 'Active', visibility),
					_1: {
						ctor: '::',
						_0: _elm_lang$html$Html$text(' '),
						_1: {
							ctor: '::',
							_0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, '#/completed', 'Completed', visibility),
							_1: { ctor: '[]' }
						}
					}
				}
			}
		});
	};
	var _evancz$elm_todomvc$Todo$CheckAll = function (a) {
		return { ctor: 'CheckAll', _0: a };
	};
	var _evancz$elm_todomvc$Todo$Check = /*#__PURE__*/F2(function (a, b) {
		return { ctor: 'Check', _0: a, _1: b };
	});
	var _evancz$elm_todomvc$Todo$DeleteComplete = { ctor: 'DeleteComplete' };
	var _evancz$elm_todomvc$Todo$viewControlsClear = function (entriesCompleted) {
		return A2(_elm_lang$html$Html$button, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('clear-completed'),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$hidden(_elm_lang$core$Native_Utils$iife_public$eq(entriesCompleted, 0)),
				_1: {
					ctor: '::',
					_0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$DeleteComplete),
					_1: { ctor: '[]' }
				}
			}
		}, {
			ctor: '::',
			_0: _elm_lang$html$Html$text(A2(_elm_lang$core$Basics_ops['++'], 'Clear completed (', A2(_elm_lang$core$Basics_ops['++'], _elm_lang$core$Basics$toString(entriesCompleted), ')'))),
			_1: { ctor: '[]' }
		});
	};
	var _evancz$elm_todomvc$Todo$viewControls = /*#__PURE__*/F2(function (visibility, entries) {
		var entriesCompleted = _elm_lang$core$List$length(A2(_elm_lang$core$List$filter, function (_) {
			return _.completed;
		}, entries));
		var entriesLeft = _elm_lang$core$List$length(entries) - entriesCompleted;
		return A2(_elm_lang$html$Html$footer, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('footer'),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$hidden(_elm_lang$core$List$isEmpty(entries)),
				_1: { ctor: '[]' }
			}
		}, {
			ctor: '::',
			_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsCount, entriesLeft),
			_1: {
				ctor: '::',
				_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsFilters, visibility),
				_1: {
					ctor: '::',
					_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsClear, entriesCompleted),
					_1: { ctor: '[]' }
				}
			}
		});
	});
	var _evancz$elm_todomvc$Todo$Delete = function (a) {
		return { ctor: 'Delete', _0: a };
	};
	var _evancz$elm_todomvc$Todo$Add = { ctor: 'Add' };
	var _evancz$elm_todomvc$Todo$UpdateEntry = /*#__PURE__*/F2(function (a, b) {
		return { ctor: 'UpdateEntry', _0: a, _1: b };
	});
	var _evancz$elm_todomvc$Todo$EditingEntry = /*#__PURE__*/F2(function (a, b) {
		return { ctor: 'EditingEntry', _0: a, _1: b };
	});
	var _evancz$elm_todomvc$Todo$viewEntry = function (todo) {
		return A2(_elm_lang$html$Html$li, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$classList({
				ctor: '::',
				_0: { ctor: '_Tuple2', _0: 'completed', _1: todo.completed },
				_1: {
					ctor: '::',
					_0: { ctor: '_Tuple2', _0: 'editing', _1: todo.editing },
					_1: { ctor: '[]' }
				}
			}),
			_1: { ctor: '[]' }
		}, {
			ctor: '::',
			_0: A2(_elm_lang$html$Html$div, {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$class('view'),
				_1: { ctor: '[]' }
			}, {
				ctor: '::',
				_0: A2(_elm_lang$html$Html$input, {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$class('toggle'),
					_1: {
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$type_('checkbox'),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$checked(todo.completed),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Events$onClick(A2(_evancz$elm_todomvc$Todo$Check, todo.id, !todo.completed)),
								_1: { ctor: '[]' }
							}
						}
					}
				}, { ctor: '[]' }),
				_1: {
					ctor: '::',
					_0: A2(_elm_lang$html$Html$label, {
						ctor: '::',
						_0: _elm_lang$html$Html_Events$onDoubleClick(A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, true)),
						_1: { ctor: '[]' }
					}, {
						ctor: '::',
						_0: _elm_lang$html$Html$text(todo.description),
						_1: { ctor: '[]' }
					}),
					_1: {
						ctor: '::',
						_0: A2(_elm_lang$html$Html$button, {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$class('destroy'),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$Delete(todo.id)),
								_1: { ctor: '[]' }
							}
						}, { ctor: '[]' }),
						_1: { ctor: '[]' }
					}
				}
			}),
			_1: {
				ctor: '::',
				_0: A2(_elm_lang$html$Html$input, {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$class('edit'),
					_1: {
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$value(todo.description),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$name('title'),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$id(A2(_elm_lang$core$Basics_ops['++'], 'todo-', _elm_lang$core$Basics$toString(todo.id))),
								_1: {
									ctor: '::',
									_0: _elm_lang$html$Html_Events$onInput(_evancz$elm_todomvc$Todo$UpdateEntry(todo.id)),
									_1: {
										ctor: '::',
										_0: _elm_lang$html$Html_Events$onBlur(A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, false)),
										_1: {
											ctor: '::',
											_0: _evancz$elm_todomvc$Todo$onEnter(A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, false)),
											_1: { ctor: '[]' }
										}
									}
								}
							}
						}
					}
				}, { ctor: '[]' }),
				_1: { ctor: '[]' }
			}
		});
	};
	var _evancz$elm_todomvc$Todo$viewKeyedEntry = function (todo) {
		return {
			ctor: '_Tuple2',
			_0: _elm_lang$core$Basics$toString(todo.id),
			_1: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewEntry, todo)
		};
	};
	var _evancz$elm_todomvc$Todo$viewEntries = /*#__PURE__*/F2(function (visibility, entries) {
		var cssVisibility = _elm_lang$core$List$isEmpty(entries) ? 'hidden' : 'visible';
		var allCompleted = A2(_elm_lang$core$List$all, function (_) {
			return _.completed;
		}, entries);
		var isVisible = function (todo) {
			var _p0 = visibility;
			switch (_p0) {
				case 'Completed':
					return todo.completed;
				case 'Active':
					return !todo.completed;
				default:
					return true;
			}
		};
		return A2(_elm_lang$html$Html$section, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('main'),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$style({
					ctor: '::',
					_0: { ctor: '_Tuple2', _0: 'visibility', _1: cssVisibility },
					_1: { ctor: '[]' }
				}),
				_1: { ctor: '[]' }
			}
		}, {
			ctor: '::',
			_0: A2(_elm_lang$html$Html$input, {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$class('toggle-all'),
				_1: {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$type_('checkbox'),
					_1: {
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$name('toggle'),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$checked(allCompleted),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$CheckAll(!allCompleted)),
								_1: { ctor: '[]' }
							}
						}
					}
				}
			}, { ctor: '[]' }),
			_1: {
				ctor: '::',
				_0: A2(_elm_lang$html$Html$label, {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$for('toggle-all'),
					_1: { ctor: '[]' }
				}, {
					ctor: '::',
					_0: _elm_lang$html$Html$text('Mark all as complete'),
					_1: { ctor: '[]' }
				}),
				_1: {
					ctor: '::',
					_0: A2(_elm_lang$html$Html_Keyed$ul, {
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$class('todo-list'),
						_1: { ctor: '[]' }
					}, A2(_elm_lang$core$List$map, _evancz$elm_todomvc$Todo$viewKeyedEntry, A2(_elm_lang$core$List$filter, isVisible, entries))),
					_1: { ctor: '[]' }
				}
			}
		});
	});
	var _evancz$elm_todomvc$Todo$UpdateField = function (a) {
		return { ctor: 'UpdateField', _0: a };
	};
	var _evancz$elm_todomvc$Todo$viewInput = function (task) {
		return A2(_elm_lang$html$Html$header, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('header'),
			_1: { ctor: '[]' }
		}, {
			ctor: '::',
			_0: A2(_elm_lang$html$Html$h1, { ctor: '[]' }, {
				ctor: '::',
				_0: _elm_lang$html$Html$text('todos'),
				_1: { ctor: '[]' }
			}),
			_1: {
				ctor: '::',
				_0: A2(_elm_lang$html$Html$input, {
					ctor: '::',
					_0: _elm_lang$html$Html_Attributes$class('new-todo'),
					_1: {
						ctor: '::',
						_0: _elm_lang$html$Html_Attributes$placeholder('What needs to be done?'),
						_1: {
							ctor: '::',
							_0: _elm_lang$html$Html_Attributes$autofocus(true),
							_1: {
								ctor: '::',
								_0: _elm_lang$html$Html_Attributes$value(task),
								_1: {
									ctor: '::',
									_0: _elm_lang$html$Html_Attributes$name('newTodo'),
									_1: {
										ctor: '::',
										_0: _elm_lang$html$Html_Events$onInput(_evancz$elm_todomvc$Todo$UpdateField),
										_1: {
											ctor: '::',
											_0: _evancz$elm_todomvc$Todo$onEnter(_evancz$elm_todomvc$Todo$Add),
											_1: { ctor: '[]' }
										}
									}
								}
							}
						}
					}
				}, { ctor: '[]' }),
				_1: { ctor: '[]' }
			}
		});
	};
	var _evancz$elm_todomvc$Todo$view = function (model) {
		return A2(_elm_lang$html$Html$div, {
			ctor: '::',
			_0: _elm_lang$html$Html_Attributes$class('todomvc-wrapper'),
			_1: {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$style({
					ctor: '::',
					_0: { ctor: '_Tuple2', _0: 'visibility', _1: 'hidden' },
					_1: { ctor: '[]' }
				}),
				_1: { ctor: '[]' }
			}
		}, {
			ctor: '::',
			_0: A2(_elm_lang$html$Html$section, {
				ctor: '::',
				_0: _elm_lang$html$Html_Attributes$class('todoapp'),
				_1: { ctor: '[]' }
			}, {
				ctor: '::',
				_0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewInput, model.field),
				_1: {
					ctor: '::',
					_0: A3(_elm_lang$html$Html_Lazy$lazy2, _evancz$elm_todomvc$Todo$viewEntries, model.visibility, model.entries),
					_1: {
						ctor: '::',
						_0: A3(_elm_lang$html$Html_Lazy$lazy2, _evancz$elm_todomvc$Todo$viewControls, model.visibility, model.entries),
						_1: { ctor: '[]' }
					}
				}
			}),
			_1: {
				ctor: '::',
				_0: _evancz$elm_todomvc$Todo$infoFooter,
				_1: { ctor: '[]' }
			}
		});
	};
	var _evancz$elm_todomvc$Todo$NoOp = { ctor: 'NoOp' };
	var _evancz$elm_todomvc$Todo$update = /*#__PURE__*/F2(function (msg, model) {
		var _p1 = msg;
		switch (_p1.ctor) {
			case 'NoOp':
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], model, { ctor: '[]' });
			case 'Add':
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, {
					uid: model.uid + 1,
					field: '',
					entries: _elm_lang$core$String$isEmpty(model.field) ? model.entries : A2(_elm_lang$core$Basics_ops['++'], model.entries, {
						ctor: '::',
						_0: A2(_evancz$elm_todomvc$Todo$newEntry, model.field, model.uid),
						_1: { ctor: '[]' }
					})
				}), { ctor: '[]' });
			case 'UpdateField':
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, { field: _p1._0 }), { ctor: '[]' });
			case 'EditingEntry':
				var _p3 = _p1._0;
				var focus = _elm_lang$dom$Dom$focus(A2(_elm_lang$core$Basics_ops['++'], 'todo-', _elm_lang$core$Basics$toString(_p3)));
				var updateEntry = function (t) {
					return _elm_lang$core$Native_Utils$iife_public$eq(t.id, _p3) ? /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(t, { editing: _p1._1 }) : t;
				};
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, {
					entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
				}), {
					ctor: '::',
					_0: A2(_elm_lang$core$Task$attempt, function (_p2) {
						return _evancz$elm_todomvc$Todo$NoOp;
					}, focus),
					_1: { ctor: '[]' }
				});
			case 'UpdateEntry':
				var updateEntry = function (t) {
					return _elm_lang$core$Native_Utils$iife_public$eq(t.id, _p1._0) ? /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(t, { description: _p1._1 }) : t;
				};
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, {
					entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
				}), { ctor: '[]' });
			case 'Delete':
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, {
					entries: A2(_elm_lang$core$List$filter, function (t) {
						return !_elm_lang$core$Native_Utils$iife_public$eq(t.id, _p1._0);
					}, model.entries)
				}), { ctor: '[]' });
			case 'DeleteComplete':
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, {
					entries: A2(_elm_lang$core$List$filter, function (_p4) {
						return !function (_) {
							return _.completed;
						}(_p4);
					}, model.entries)
				}), { ctor: '[]' });
			case 'Check':
				var updateEntry = function (t) {
					return _elm_lang$core$Native_Utils$iife_public$eq(t.id, _p1._0) ? /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(t, { completed: _p1._1 }) : t;
				};
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, {
					entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
				}), { ctor: '[]' });
			case 'CheckAll':
				var updateEntry = function (t) {
					return (/*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(t, { completed: _p1._0 })
					);
				};
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, {
					entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
				}), { ctor: '[]' });
			default:
				return A2(_elm_lang$core$Platform_Cmd_ops['!'], /*#__PURE__*/_elm_lang$core$Native_Utils$iife_public$update(model, { visibility: _p1._0 }), { ctor: '[]' });
		}
	});
	var _evancz$elm_todomvc$Todo$updateWithStorage = /*#__PURE__*/F2(function (msg, model) {
		var _p5 = A2(_evancz$elm_todomvc$Todo$update, msg, model);
		var newModel = _p5._0;
		var cmds = _p5._1;
		return {
			ctor: '_Tuple2',
			_0: newModel,
			_1: /*#__PURE__*/_elm_lang$core$Platform_Cmd$batch({
				ctor: '::',
				_0: _evancz$elm_todomvc$Todo$setStorage(newModel),
				_1: {
					ctor: '::',
					_0: cmds,
					_1: { ctor: '[]' }
				}
			})
		};
	});
	var _evancz$elm_todomvc$Todo$main = _elm_lang$html$Html$programWithFlags({
		init: _evancz$elm_todomvc$Todo$init,
		view: _evancz$elm_todomvc$Todo$view,
		update: _evancz$elm_todomvc$Todo$updateWithStorage,
		subscriptions: function (_p6) {
			return _elm_lang$core$Platform_Sub$none;
		}
	})(_elm_lang$core$Json_Decode$oneOf({
		ctor: '::',
		_0: _elm_lang$core$Json_Decode$null(_elm_lang$core$Maybe$Nothing),
		_1: {
			ctor: '::',
			_0: A2(_elm_lang$core$Json_Decode$map, _elm_lang$core$Maybe$Just, A2(_elm_lang$core$Json_Decode$andThen, function (entries) {
				return A2(_elm_lang$core$Json_Decode$andThen, function (field) {
					return A2(_elm_lang$core$Json_Decode$andThen, function (uid) {
						return A2(_elm_lang$core$Json_Decode$andThen, function (visibility) {
							return _elm_lang$core$Json_Decode$succeed({ entries: entries, field: field, uid: uid, visibility: visibility });
						}, A2(_elm_lang$core$Json_Decode$field, 'visibility', _elm_lang$core$Json_Decode$string));
					}, A2(_elm_lang$core$Json_Decode$field, 'uid', _elm_lang$core$Json_Decode$int));
				}, A2(_elm_lang$core$Json_Decode$field, 'field', _elm_lang$core$Json_Decode$string));
			}, A2(_elm_lang$core$Json_Decode$field, 'entries', _elm_lang$core$Json_Decode$list(A2(_elm_lang$core$Json_Decode$andThen, function (completed) {
				return A2(_elm_lang$core$Json_Decode$andThen, function (description) {
					return A2(_elm_lang$core$Json_Decode$andThen, function (editing) {
						return A2(_elm_lang$core$Json_Decode$andThen, function (id) {
							return _elm_lang$core$Json_Decode$succeed({ completed: completed, description: description, editing: editing, id: id });
						}, A2(_elm_lang$core$Json_Decode$field, 'id', _elm_lang$core$Json_Decode$int));
					}, A2(_elm_lang$core$Json_Decode$field, 'editing', _elm_lang$core$Json_Decode$bool));
				}, A2(_elm_lang$core$Json_Decode$field, 'description', _elm_lang$core$Json_Decode$string));
			}, A2(_elm_lang$core$Json_Decode$field, 'completed', _elm_lang$core$Json_Decode$bool)))))),
			_1: { ctor: '[]' }
		}
	}));

	var Elm = {};
	Elm['Todo'] = Elm['Todo'] || {};
	if (typeof _evancz$elm_todomvc$Todo$main !== 'undefined') {
		_evancz$elm_todomvc$Todo$main(Elm['Todo'], 'Todo', undefined);
	}

	if (typeof define === "function" && define['amd']) {
		define([], function () {
			return Elm;
		});
		return;
	}

	if (typeof module === "object") {
		module['exports'] = Elm;
		return;
	}

	var globalElm = this['Elm'];
	if (typeof globalElm === "undefined") {
		this['Elm'] = Elm;
		return;
	}

	for (var publicModule in Elm) {
		if (publicModule in globalElm) {
			throw new Error('There are two Elm modules called `' + publicModule + '` on this page! Rename one of them.');
		}
		globalElm[publicModule] = Elm[publicModule];
	}
}).call(this);

uglify-beautified

(function() {
    "use strict";
    function F2(fun) {
        function wrapper(a) {
            return function(b) {
                return fun(a, b);
            };
        }
        return wrapper.arity = 2, wrapper.func = fun, wrapper;
    }
    function F3(fun) {
        function wrapper(a) {
            return function(b) {
                return function(c) {
                    return fun(a, b, c);
                };
            };
        }
        return wrapper.arity = 3, wrapper.func = fun, wrapper;
    }
    function A2(fun, a, b) {
        return 2 === fun.arity ? fun.func(a, b) : fun(a)(b);
    }
    function A3(fun, a, b, c) {
        return 3 === fun.arity ? fun.func(a, b, c) : fun(a)(b)(c);
    }
    function A4(fun, a, b, c, d) {
        return 4 === fun.arity ? fun.func(a, b, c, d) : fun(a)(b)(c)(d);
    }
    function _elm_lang$core$Native_Array$iife_private$fromJSArray_(jsArray, h, from, to) {
        if (0 === h) return {
            ctor: "_Array",
            height: 0,
            table: jsArray.slice(from, to)
        };
        for (var step = Math.pow(_elm_lang$core$Native_Array$iife_private$M, h), table = new Array(Math.ceil((to - from) / step)), lengths = new Array(table.length), i = 0; i < table.length; i++) table[i] = _elm_lang$core$Native_Array$iife_private$fromJSArray_(jsArray, h - 1, from + i * step, Math.min(from + (i + 1) * step, to)), 
        lengths[i] = _elm_lang$core$Native_Array$iife_private$length(table[i]) + (i > 0 ? lengths[i - 1] : 0);
        return {
            ctor: "_Array",
            height: h,
            table: table,
            lengths: lengths
        };
    }
    function _elm_lang$core$Native_Array$iife_private$fromJSArray(jsArray) {
        return 0 === jsArray.length ? _elm_lang$core$Native_Array$iife_private$empty : _elm_lang$core$Native_Array$iife_private$fromJSArray_(jsArray, Math.floor(Math.log(jsArray.length) / Math.log(_elm_lang$core$Native_Array$iife_private$M)), 0, jsArray.length);
    }
    function _elm_lang$core$Native_Array$iife_private$toJSArray_(jsArray, i, a) {
        for (var t = 0; t < a.table.length; t++) if (0 === a.height) jsArray[i + t] = a.table[t]; else {
            var inc = 0 === t ? 0 : a.lengths[t - 1];
            _elm_lang$core$Native_Array$iife_private$toJSArray_(jsArray, i + inc, a.table[t]);
        }
    }
    function _elm_lang$core$Native_Array$iife_private$toJSArray(a) {
        var jsArray = new Array(_elm_lang$core$Native_Array$iife_private$length(a));
        return _elm_lang$core$Native_Array$iife_private$toJSArray_(jsArray, 0, a), jsArray;
    }
    function _elm_lang$core$Native_Array$iife_private$length(array) {
        return 0 === array.height ? array.table.length : array.lengths[array.lengths.length - 1];
    }
    function _elm_lang$core$Native_Array$iife_private$toList_(list, a) {
        for (var i = a.table.length - 1; i >= 0; i--) list = 0 === a.height ? _elm_lang$core$Native_List$iife_public$Cons(a.table[i], list) : _elm_lang$core$Native_Array$iife_private$toList_(list, a.table[i]);
        return list;
    }
    function _elm_lang$core$Native_Array$iife_private$toList(a) {
        return _elm_lang$core$Native_Array$iife_private$toList_(_elm_lang$core$Native_List$iife_public$Nil, a);
    }
    function _elm_lang$core$Native_Basics$iife_private$mod(a, b) {
        if (0 === b) throw new Error("Cannot perform mod 0. Division by zero error.");
        var r = a % b, m = 0 === a ? 0 : b > 0 ? a >= 0 ? r : r + b : -_elm_lang$core$Native_Basics$iife_private$mod(-a, -b);
        return m === b ? 0 : m;
    }
    function _elm_lang$core$Native_Basics$iife_private$div(a, b) {
        return a / b | 0;
    }
    function _elm_lang$core$Native_Utils$iife_private$addSlashes(str, isChar) {
        var s = str.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r").replace(/\v/g, "\\v").replace(/\0/g, "\\0");
        return isChar ? s.replace(/\'/g, "\\'") : s.replace(/\"/g, '\\"');
    }
    function _elm_lang$core$Native_Utils$iife_private$toString(v) {
        var type = typeof v;
        if ("function" === type) return "<function>";
        if ("boolean" === type) return v ? "True" : "False";
        if ("number" === type) return v + "";
        if (v instanceof String) return "'" + _elm_lang$core$Native_Utils$iife_private$addSlashes(v, !0) + "'";
        if ("string" === type) return '"' + _elm_lang$core$Native_Utils$iife_private$addSlashes(v, !1) + '"';
        if (null === v) return "null";
        if ("object" === type && "ctor" in v) {
            var ctorStarter = v.ctor.substring(0, 5);
            if ("_Tupl" === ctorStarter) {
                var output = [];
                for (var k in v) "ctor" !== k && output.push(_elm_lang$core$Native_Utils$iife_private$toString(v[k]));
                return "(" + output.join(",") + ")";
            }
            if ("_Task" === ctorStarter) return "<task>";
            if ("_Array" === v.ctor) {
                return "Array.fromList " + _elm_lang$core$Native_Utils$iife_private$toString(_elm_lang$core$Array$toList(v));
            }
            if ("<decoder>" === v.ctor) return "<decoder>";
            if ("_Process" === v.ctor) return "<process:" + v.id + ">";
            if ("::" === v.ctor) {
                var output = "[" + _elm_lang$core$Native_Utils$iife_private$toString(v._0);
                for (v = v._1; "::" === v.ctor; ) output += "," + _elm_lang$core$Native_Utils$iife_private$toString(v._0), 
                v = v._1;
                return output + "]";
            }
            if ("[]" === v.ctor) return "[]";
            if ("Set_elm_builtin" === v.ctor) return "Set.fromList " + _elm_lang$core$Native_Utils$iife_private$toString(_elm_lang$core$Set$toList(v));
            if ("RBNode_elm_builtin" === v.ctor || "RBEmpty_elm_builtin" === v.ctor) return "Dict.fromList " + _elm_lang$core$Native_Utils$iife_private$toString(_elm_lang$core$Dict$toList(v));
            var output = "";
            for (var i in v) if ("ctor" !== i) {
                var str = _elm_lang$core$Native_Utils$iife_private$toString(v[i]), c0 = str[0], parenless = "{" === c0 || "(" === c0 || "<" === c0 || '"' === c0 || str.indexOf(" ") < 0;
                output += " " + (parenless ? str : "(" + str + ")");
            }
            return v.ctor + output;
        }
        if ("object" === type) {
            if (v instanceof Date) return "<" + v.toString() + ">";
            if (v.elm_web_socket) return "<websocket>";
            var output = [];
            for (var k in v) output.push(k + " = " + _elm_lang$core$Native_Utils$iife_private$toString(v[k]));
            return 0 === output.length ? "{}" : "{ " + output.join(", ") + " }";
        }
        return "<internal structure>";
    }
    function _elm_lang$core$Native_Utils$iife_private$append(xs, ys) {
        if ("string" == typeof xs) return xs + ys;
        if ("[]" === xs.ctor) return ys;
        var root = _elm_lang$core$Native_Utils$iife_private$Cons(xs._0, _elm_lang$core$Native_Utils$iife_private$Nil), curr = root;
        for (xs = xs._1; "[]" !== xs.ctor; ) curr._1 = _elm_lang$core$Native_Utils$iife_private$Cons(xs._0, _elm_lang$core$Native_Utils$iife_private$Nil), 
        xs = xs._1, curr = curr._1;
        return curr._1 = ys, root;
    }
    function _elm_lang$core$Native_Utils$iife_private$Cons(hd, tl) {
        return {
            ctor: "::",
            _0: hd,
            _1: tl
        };
    }
    function _elm_lang$core$Native_Utils$iife_private$update(oldRecord, updatedFields) {
        var newRecord = {};
        for (var key in oldRecord) newRecord[key] = oldRecord[key];
        for (var key in updatedFields) newRecord[key] = updatedFields[key];
        return newRecord;
    }
    function _elm_lang$core$Native_Utils$iife_private$guid(_) {
        return _elm_lang$core$Native_Utils$iife_private$count++;
    }
    function _elm_lang$core$Native_Utils$iife_private$chr(c) {
        return new String(c);
    }
    function _elm_lang$core$Native_Utils$iife_private$Tuple2(x, y) {
        return {
            ctor: "_Tuple2",
            _0: x,
            _1: y
        };
    }
    function _elm_lang$core$Native_Utils$iife_private$cmp(x, y) {
        if ("object" != typeof x) return x === y ? _elm_lang$core$Native_Utils$iife_private$EQ : x < y ? _elm_lang$core$Native_Utils$iife_private$LT : _elm_lang$core$Native_Utils$iife_private$GT;
        if (x instanceof String) {
            var a = x.valueOf(), b = y.valueOf();
            return a === b ? _elm_lang$core$Native_Utils$iife_private$EQ : a < b ? _elm_lang$core$Native_Utils$iife_private$LT : _elm_lang$core$Native_Utils$iife_private$GT;
        }
        if ("::" === x.ctor || "[]" === x.ctor) {
            for (;"::" === x.ctor && "::" === y.ctor; ) {
                var ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._0, y._0);
                if (ord !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
                x = x._1, y = y._1;
            }
            return x.ctor === y.ctor ? _elm_lang$core$Native_Utils$iife_private$EQ : "[]" === x.ctor ? _elm_lang$core$Native_Utils$iife_private$LT : _elm_lang$core$Native_Utils$iife_private$GT;
        }
        if ("_Tuple" === x.ctor.slice(0, 6)) {
            var ord, n = x.ctor.slice(6) - 0;
            if (0 === n) return _elm_lang$core$Native_Utils$iife_private$EQ;
            if (n >= 1) {
                if ((ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._0, y._0)) !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
                if (n >= 2) {
                    if ((ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._1, y._1)) !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
                    if (n >= 3) {
                        if ((ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._2, y._2)) !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
                        if (n >= 4) {
                            if ((ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._3, y._3)) !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
                            if (n >= 5) {
                                if ((ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._4, y._4)) !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
                                if (n >= 6) {
                                    if ((ord = _elm_lang$core$Native_Utils$iife_private$cmp(x._5, y._5)) !== _elm_lang$core$Native_Utils$iife_private$EQ) return ord;
                                    if (n >= 7) throw new Error("Comparison error: cannot compare tuples with more than 6 elements.");
                                }
                            }
                        }
                    }
                }
            }
            return _elm_lang$core$Native_Utils$iife_private$EQ;
        }
        throw new Error("Comparison error: comparison is only defined on ints, floats, times, chars, strings, lists of comparable values, and tuples of comparable values.");
    }
    function _elm_lang$core$Native_Utils$iife_private$eqHelp(x, y, depth, stack) {
        if (depth > 100) return stack.push({
            x: x,
            y: y
        }), !0;
        if (x === y) return !0;
        if ("object" != typeof x) {
            if ("function" == typeof x) throw new Error('Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense. Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
            return !1;
        }
        if (null === x || null === y) return !1;
        if (x instanceof Date) return x.getTime() === y.getTime();
        if (!("ctor" in x)) {
            for (var key in x) if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(x[key], y[key], depth + 1, stack)) return !1;
            return !0;
        }
        if ("RBNode_elm_builtin" !== x.ctor && "RBEmpty_elm_builtin" !== x.ctor || (x = _elm_lang$core$Dict$toList(x), 
        y = _elm_lang$core$Dict$toList(y)), "Set_elm_builtin" === x.ctor && (x = _elm_lang$core$Set$toList(x), 
        y = _elm_lang$core$Set$toList(y)), "::" === x.ctor) {
            for (var a = x, b = y; "::" === a.ctor && "::" === b.ctor; ) {
                if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(a._0, b._0, depth + 1, stack)) return !1;
                a = a._1, b = b._1;
            }
            return a.ctor === b.ctor;
        }
        if ("_Array" === x.ctor) {
            var xs = _elm_lang$core$Native_Array$iife_public$toJSArray(x), ys = _elm_lang$core$Native_Array$iife_public$toJSArray(y);
            if (xs.length !== ys.length) return !1;
            for (var i = 0; i < xs.length; i++) if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(xs[i], ys[i], depth + 1, stack)) return !1;
            return !0;
        }
        if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(x.ctor, y.ctor, depth + 1, stack)) return !1;
        for (var key in x) if (!_elm_lang$core$Native_Utils$iife_private$eqHelp(x[key], y[key], depth + 1, stack)) return !1;
        return !0;
    }
    function _elm_lang$core$Native_Utils$iife_private$eq(x, y) {
        for (var pair, stack = [], isEqual = _elm_lang$core$Native_Utils$iife_private$eqHelp(x, y, 0, stack); isEqual && (pair = stack.pop()); ) isEqual = _elm_lang$core$Native_Utils$iife_private$eqHelp(pair.x, pair.y, 0, stack);
        return isEqual;
    }
    function _elm_lang$core$Native_List$iife_private$foldr(f, b, xs) {
        for (var arr = _elm_lang$core$Native_List$iife_private$toArray(xs), acc = b, i = arr.length; i--; ) acc = A2(f, arr[i], acc);
        return acc;
    }
    function _elm_lang$core$Native_List$iife_private$toArray(xs) {
        for (var out = []; "[]" !== xs.ctor; ) out.push(xs._0), xs = xs._1;
        return out;
    }
    function _elm_lang$core$Native_List$iife_private$Cons(hd, tl) {
        return {
            ctor: "::",
            _0: hd,
            _1: tl
        };
    }
    function _elm_lang$core$Native_Scheduler$iife_private$work() {
        for (var process, numSteps = 0; numSteps < _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS && (process = _elm_lang$core$Native_Scheduler$iife_private$workQueue.shift()); ) process.root && (numSteps = _elm_lang$core$Native_Scheduler$iife_private$step(numSteps, process));
        if (!process) return void (_elm_lang$core$Native_Scheduler$iife_private$working = !1);
        setTimeout(_elm_lang$core$Native_Scheduler$iife_private$work, 0);
    }
    function _elm_lang$core$Native_Scheduler$iife_private$enqueue(process) {
        _elm_lang$core$Native_Scheduler$iife_private$workQueue.push(process), _elm_lang$core$Native_Scheduler$iife_private$working || (setTimeout(_elm_lang$core$Native_Scheduler$iife_private$work, 0), 
        _elm_lang$core$Native_Scheduler$iife_private$working = !0);
    }
    function _elm_lang$core$Native_Scheduler$iife_private$step(numSteps, process) {
        for (;numSteps < _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS; ) {
            var ctor = process.root.ctor;
            if ("_Task_succeed" !== ctor) if ("_Task_fail" !== ctor) if ("_Task_andThen" !== ctor) if ("_Task_onError" !== ctor) {
                if ("_Task_nativeBinding" === ctor) {
                    process.root.cancel = process.root.callback(function(newRoot) {
                        process.root = newRoot, _elm_lang$core$Native_Scheduler$iife_private$enqueue(process);
                    });
                    break;
                }
                if ("_Task_receive" !== ctor) throw new Error(ctor);
                var mailbox = process.mailbox;
                if (0 === mailbox.length) break;
                process.root = process.root.callback(mailbox.shift()), ++numSteps;
            } else process.stack = {
                ctor: "_Task_onError",
                callback: process.root.callback,
                rest: process.stack
            }, process.root = process.root.task, ++numSteps; else process.stack = {
                ctor: "_Task_andThen",
                callback: process.root.callback,
                rest: process.stack
            }, process.root = process.root.task, ++numSteps; else {
                for (;process.stack && "_Task_andThen" === process.stack.ctor; ) process.stack = process.stack.rest;
                if (null === process.stack) break;
                process.root = process.stack.callback(process.root.value), process.stack = process.stack.rest, 
                ++numSteps;
            } else {
                for (;process.stack && "_Task_onError" === process.stack.ctor; ) process.stack = process.stack.rest;
                if (null === process.stack) break;
                process.root = process.stack.callback(process.root.value), process.stack = process.stack.rest, 
                ++numSteps;
            }
        }
        return numSteps < _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS ? numSteps + 1 : (_elm_lang$core$Native_Scheduler$iife_private$enqueue(process), 
        numSteps);
    }
    function _elm_lang$core$Native_Scheduler$iife_private$rawSend(process, msg) {
        process.mailbox.push(msg), _elm_lang$core$Native_Scheduler$iife_private$enqueue(process);
    }
    function _elm_lang$core$Native_Scheduler$iife_private$spawn(task) {
        return _elm_lang$core$Native_Scheduler$iife_private$nativeBinding(function(callback) {
            callback(_elm_lang$core$Native_Scheduler$iife_private$succeed(_elm_lang$core$Native_Scheduler$iife_private$rawSpawn(task)));
        });
    }
    function _elm_lang$core$Native_Scheduler$iife_private$rawSpawn(task) {
        var process = {
            ctor: "_Process",
            id: _elm_lang$core$Native_Utils$iife_public$guid(),
            root: task,
            stack: null,
            mailbox: []
        };
        return _elm_lang$core$Native_Scheduler$iife_private$enqueue(process), process;
    }
    function _elm_lang$core$Native_Scheduler$iife_private$receive(callback) {
        return {
            ctor: "_Task_receive",
            callback: callback
        };
    }
    function _elm_lang$core$Native_Scheduler$iife_private$onError(callback, task) {
        return {
            ctor: "_Task_onError",
            callback: callback,
            task: task
        };
    }
    function _elm_lang$core$Native_Scheduler$iife_private$andThen(callback, task) {
        return {
            ctor: "_Task_andThen",
            callback: callback,
            task: task
        };
    }
    function _elm_lang$core$Native_Scheduler$iife_private$nativeBinding(callback) {
        return {
            ctor: "_Task_nativeBinding",
            callback: callback,
            cancel: null
        };
    }
    function _elm_lang$core$Native_Scheduler$iife_private$fail(error) {
        return {
            ctor: "_Task_fail",
            value: error
        };
    }
    function _elm_lang$core$Native_Scheduler$iife_private$succeed(value) {
        return {
            ctor: "_Task_succeed",
            value: value
        };
    }
    function _elm_lang$core$Native_Platform$iife_private$setupIncomingPort(name, callback) {
        function preInitOnEffects(router, subList, state) {
            for (var postInitResult = postInitOnEffects(router, subList, state), i = 0; i < sentBeforeInit.length; i++) postInitSend(sentBeforeInit[i]);
            return sentBeforeInit = null, currentSend = postInitSend, currentOnEffects = postInitOnEffects, 
            postInitResult;
        }
        function postInitOnEffects(router, subList, state) {
            return subs = subList, init;
        }
        function onEffects(router, subList, state) {
            return currentOnEffects(router, subList, state);
        }
        function preInitSend(value) {
            sentBeforeInit.push(value);
        }
        function postInitSend(value) {
            for (var temp = subs; "[]" !== temp.ctor; ) callback(temp._0(value)), temp = temp._1;
        }
        function send(incomingValue) {
            var result = A2(_elm_lang$core$Json_Decode$decodeValue, converter, incomingValue);
            if ("Err" === result.ctor) throw new Error("Trying to send an unexpected type of value through port `" + name + "`:\n" + result._0);
            currentSend(result._0);
        }
        var sentBeforeInit = [], subs = _elm_lang$core$Native_List$iife_public$Nil, converter = _elm_lang$core$Native_Platform$iife_private$effectManagers[name].converter, currentOnEffects = preInitOnEffects, currentSend = preInitSend, init = _elm_lang$core$Native_Scheduler$iife_public$succeed(null);
        return _elm_lang$core$Native_Platform$iife_private$effectManagers[name].init = init, 
        _elm_lang$core$Native_Platform$iife_private$effectManagers[name].onEffects = F3(onEffects), 
        {
            send: send
        };
    }
    function _elm_lang$core$Native_Platform$iife_private$setupOutgoingPort(name) {
        function onEffects(router, cmdList, state) {
            for (;"[]" !== cmdList.ctor; ) {
                for (var currentSubs = subs, value = converter(cmdList._0), i = 0; i < currentSubs.length; i++) currentSubs[i](value);
                cmdList = cmdList._1;
            }
            return init;
        }
        function subscribe(callback) {
            subs.push(callback);
        }
        function unsubscribe(callback) {
            subs = subs.slice();
            var index = subs.indexOf(callback);
            index >= 0 && subs.splice(index, 1);
        }
        var subs = [], converter = _elm_lang$core$Native_Platform$iife_private$effectManagers[name].converter, init = _elm_lang$core$Native_Scheduler$iife_public$succeed(null);
        return _elm_lang$core$Native_Platform$iife_private$effectManagers[name].init = init, 
        _elm_lang$core$Native_Platform$iife_private$effectManagers[name].onEffects = F3(onEffects), 
        {
            subscribe: subscribe,
            unsubscribe: unsubscribe
        };
    }
    function _elm_lang$core$Native_Platform$iife_private$outgoingPort(name, converter) {
        return _elm_lang$core$Native_Platform$iife_private$checkPortName(name), _elm_lang$core$Native_Platform$iife_private$effectManagers[name] = {
            tag: "cmd",
            cmdMap: _elm_lang$core$Native_Platform$iife_private$outgoingPortMap,
            converter: converter,
            isForeign: !0
        }, _elm_lang$core$Native_Platform$iife_private$leaf(name);
    }
    function _elm_lang$core$Native_Platform$iife_private$checkPortName(name) {
        if (name in _elm_lang$core$Native_Platform$iife_private$effectManagers) throw new Error("There can only be one port named `" + name + "`, but your program has multiple.");
    }
    function _elm_lang$core$Native_Platform$iife_private$insert(isCmd, newEffect, effects) {
        return effects = effects || {
            cmds: _elm_lang$core$Native_List$iife_public$Nil,
            subs: _elm_lang$core$Native_List$iife_public$Nil
        }, isCmd ? (effects.cmds = _elm_lang$core$Native_List$iife_public$Cons(newEffect, effects.cmds), 
        effects) : (effects.subs = _elm_lang$core$Native_List$iife_public$Cons(newEffect, effects.subs), 
        effects);
    }
    function _elm_lang$core$Native_Platform$iife_private$toEffect(isCmd, home, taggers, value) {
        function applyTaggers(x) {
            for (var temp = taggers; temp; ) x = temp.tagger(x), temp = temp.rest;
            return x;
        }
        return A2(isCmd ? _elm_lang$core$Native_Platform$iife_private$effectManagers[home].cmdMap : _elm_lang$core$Native_Platform$iife_private$effectManagers[home].subMap, applyTaggers, value);
    }
    function _elm_lang$core$Native_Platform$iife_private$gatherEffects(isCmd, bag, effectsDict, taggers) {
        switch (bag.type) {
          case "leaf":
            var home = bag.home, effect = _elm_lang$core$Native_Platform$iife_private$toEffect(isCmd, home, taggers, bag.value);
            return void (effectsDict[home] = _elm_lang$core$Native_Platform$iife_private$insert(isCmd, effect, effectsDict[home]));

          case "node":
            for (var list = bag.branches; "[]" !== list.ctor; ) _elm_lang$core$Native_Platform$iife_private$gatherEffects(isCmd, list._0, effectsDict, taggers), 
            list = list._1;
            return;

          case "map":
            return void _elm_lang$core$Native_Platform$iife_private$gatherEffects(isCmd, bag.tree, effectsDict, {
                tagger: bag.tagger,
                rest: taggers
            });
        }
    }
    function _elm_lang$core$Native_Platform$iife_private$dispatchEffects(managers, cmdBag, subBag) {
        var effectsDict = {};
        _elm_lang$core$Native_Platform$iife_private$gatherEffects(!0, cmdBag, effectsDict, null), 
        _elm_lang$core$Native_Platform$iife_private$gatherEffects(!1, subBag, effectsDict, null);
        for (var home in managers) {
            var fx = home in effectsDict ? effectsDict[home] : {
                cmds: _elm_lang$core$Native_List$iife_public$Nil,
                subs: _elm_lang$core$Native_List$iife_public$Nil
            };
            _elm_lang$core$Native_Scheduler$iife_public$rawSend(managers[home], {
                ctor: "fx",
                _0: fx
            });
        }
    }
    function _elm_lang$core$Native_Platform$iife_private$batch(list) {
        return {
            type: "node",
            branches: list
        };
    }
    function _elm_lang$core$Native_Platform$iife_private$leaf(home) {
        return function(value) {
            return {
                type: "leaf",
                home: home,
                value: value
            };
        };
    }
    function _elm_lang$core$Native_Platform$iife_private$spawnLoop(init, onMessage) {
        function loop(state) {
            var handleMsg = _elm_lang$core$Native_Scheduler$iife_public$receive(function(msg) {
                return onMessage(msg, state);
            });
            return A2(andThen, loop, handleMsg);
        }
        var andThen = _elm_lang$core$Native_Scheduler$iife_public$andThen, task = A2(andThen, loop, init);
        return _elm_lang$core$Native_Scheduler$iife_public$rawSpawn(task);
    }
    function _elm_lang$core$Native_Platform$iife_private$sendToApp(router, msg) {
        return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function(callback) {
            router.main(msg), callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(_elm_lang$core$Native_Utils$iife_public$Tuple0));
        });
    }
    function _elm_lang$core$Native_Platform$iife_private$makeManager(info, callback) {
        function onMessage(msg, state) {
            if ("self" === msg.ctor) return A3(onSelfMsg, router, msg._0, state);
            var fx = msg._0;
            switch (tag) {
              case "cmd":
                return A3(onEffects, router, fx.cmds, state);

              case "sub":
                return A3(onEffects, router, fx.subs, state);

              case "fx":
                return A4(onEffects, router, fx.cmds, fx.subs, state);
            }
        }
        var router = {
            main: callback,
            self: void 0
        }, tag = info.tag, onEffects = info.onEffects, onSelfMsg = info.onSelfMsg, process = _elm_lang$core$Native_Platform$iife_private$spawnLoop(info.init, onMessage);
        return router.self = process, process;
    }
    function _elm_lang$core$Native_Platform$iife_private$setupEffects(managers, callback) {
        var ports;
        for (var key in _elm_lang$core$Native_Platform$iife_private$effectManagers) {
            var manager = _elm_lang$core$Native_Platform$iife_private$effectManagers[key];
            manager.isForeign && (ports = ports || {}, ports[key] = "cmd" === manager.tag ? _elm_lang$core$Native_Platform$iife_private$setupOutgoingPort(key) : _elm_lang$core$Native_Platform$iife_private$setupIncomingPort(key, callback)), 
            managers[key] = _elm_lang$core$Native_Platform$iife_private$makeManager(manager, callback);
        }
        return ports;
    }
    function _elm_lang$core$Native_Platform$iife_private$initialize(init, update, subscriptions, renderer) {
        function onMessage(msg, model) {
            return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function(callback) {
                var results = A2(update, msg, model);
                model = results._0, updateView(model);
                var cmds = results._1, subs = subscriptions(model);
                _elm_lang$core$Native_Platform$iife_private$dispatchEffects(managers, cmds, subs), 
                callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(model));
            });
        }
        function enqueue(msg) {
            _elm_lang$core$Native_Scheduler$iife_public$rawSend(mainProcess, msg);
        }
        var updateView, managers = {}, initApp = _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function(callback) {
            var model = init._0;
            updateView = renderer(enqueue, model);
            var cmds = init._1, subs = subscriptions(model);
            _elm_lang$core$Native_Platform$iife_private$dispatchEffects(managers, cmds, subs), 
            callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(model));
        }), mainProcess = _elm_lang$core$Native_Platform$iife_private$spawnLoop(initApp, onMessage), ports = _elm_lang$core$Native_Platform$iife_private$setupEffects(managers, enqueue);
        return ports ? {
            ports: ports
        } : {};
    }
    function _elm_lang$core$Native_String$iife_private$join(sep, strs) {
        return _elm_lang$core$Native_List$iife_public$toArray(strs).join(sep);
    }
    function _elm_lang$core$Native_String$iife_private$isEmpty(str) {
        return 0 === str.length;
    }
    function _elm_lang$core$Native_Json$iife_private$identity(value) {
        return value;
    }
    function _elm_lang$core$Native_Json$iife_private$listEquality(aDecoders, bDecoders) {
        var len = aDecoders.length;
        if (len !== bDecoders.length) return !1;
        for (var i = 0; i < len; i++) if (!_elm_lang$core$Native_Json$iife_private$equality(aDecoders[i], bDecoders[i])) return !1;
        return !0;
    }
    function _elm_lang$core$Native_Json$iife_private$equality(a, b) {
        if (a === b) return !0;
        if (a.tag !== b.tag) return !1;
        switch (a.tag) {
          case "succeed":
          case "fail":
            return a.msg === b.msg;

          case "bool":
          case "int":
          case "float":
          case "string":
          case "value":
            return !0;

          case "null":
            return a.value === b.value;

          case "list":
          case "array":
          case "maybe":
          case "key-value":
            return _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

          case "field":
            return a.field === b.field && _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

          case "index":
            return a.index === b.index && _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

          case "map-many":
            return a.func === b.func && _elm_lang$core$Native_Json$iife_private$listEquality(a.decoders, b.decoders);

          case "andThen":
            return a.callback === b.callback && _elm_lang$core$Native_Json$iife_private$equality(a.decoder, b.decoder);

          case "oneOf":
            return _elm_lang$core$Native_Json$iife_private$listEquality(a.decoders, b.decoders);
        }
    }
    function _elm_lang$core$Native_Json$iife_private$runHelp(decoder, value) {
        switch (decoder.tag) {
          case "bool":
            return "boolean" == typeof value ? _elm_lang$core$Native_Json$iife_private$ok(value) : _elm_lang$core$Native_Json$iife_private$badPrimitive("a Bool", value);

          case "int":
            return "number" != typeof value ? _elm_lang$core$Native_Json$iife_private$badPrimitive("an Int", value) : -2147483647 < value && value < 2147483647 && (0 | value) === value ? _elm_lang$core$Native_Json$iife_private$ok(value) : !isFinite(value) || value % 1 ? _elm_lang$core$Native_Json$iife_private$badPrimitive("an Int", value) : _elm_lang$core$Native_Json$iife_private$ok(value);

          case "float":
            return "number" == typeof value ? _elm_lang$core$Native_Json$iife_private$ok(value) : _elm_lang$core$Native_Json$iife_private$badPrimitive("a Float", value);

          case "string":
            return "string" == typeof value ? _elm_lang$core$Native_Json$iife_private$ok(value) : value instanceof String ? _elm_lang$core$Native_Json$iife_private$ok(value + "") : _elm_lang$core$Native_Json$iife_private$badPrimitive("a String", value);

          case "null":
            return null === value ? _elm_lang$core$Native_Json$iife_private$ok(decoder.value) : _elm_lang$core$Native_Json$iife_private$badPrimitive("null", value);

          case "value":
            return _elm_lang$core$Native_Json$iife_private$ok(value);

          case "list":
            if (!(value instanceof Array)) return _elm_lang$core$Native_Json$iife_private$badPrimitive("a List", value);
            for (var list = _elm_lang$core$Native_List$iife_public$Nil, i = value.length; i--; ) {
                var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[i]);
                if ("ok" !== result.tag) return _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(i, result);
                list = _elm_lang$core$Native_List$iife_public$Cons(result.value, list);
            }
            return _elm_lang$core$Native_Json$iife_private$ok(list);

          case "array":
            if (!(value instanceof Array)) return _elm_lang$core$Native_Json$iife_private$badPrimitive("an Array", value);
            for (var len = value.length, array = new Array(len), i = len; i--; ) {
                var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[i]);
                if ("ok" !== result.tag) return _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(i, result);
                array[i] = result.value;
            }
            return _elm_lang$core$Native_Json$iife_private$ok(_elm_lang$core$Native_Array$iife_public$fromJSArray(array));

          case "maybe":
            var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value);
            return _elm_lang$core$Native_Json$iife_private$ok("ok" === result.tag ? _elm_lang$core$Maybe$Just(result.value) : _elm_lang$core$Maybe$Nothing);

          case "field":
            var field = decoder.field;
            if ("object" != typeof value || null === value || !(field in value)) return _elm_lang$core$Native_Json$iife_private$badPrimitive("an object with a field named `" + field + "`", value);
            var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[field]);
            return "ok" === result.tag ? result : _elm_lang$core$Native_Json$iife_private$badField(field, result);

          case "index":
            var index = decoder.index;
            if (!(value instanceof Array)) return _elm_lang$core$Native_Json$iife_private$badPrimitive("an array", value);
            if (index >= value.length) return _elm_lang$core$Native_Json$iife_private$badPrimitive("a longer array. Need index " + index + " but there are only " + value.length + " entries", value);
            var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[index]);
            return "ok" === result.tag ? result : _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(index, result);

          case "key-value":
            if ("object" != typeof value || null === value || value instanceof Array) return _elm_lang$core$Native_Json$iife_private$badPrimitive("an object", value);
            var keyValuePairs = _elm_lang$core$Native_List$iife_public$Nil;
            for (var key in value) {
                var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value[key]);
                if ("ok" !== result.tag) return _elm_lang$core$Native_Json$iife_private$badField(key, result);
                var pair = _elm_lang$core$Native_Utils$iife_public$Tuple2(key, result.value);
                keyValuePairs = _elm_lang$core$Native_List$iife_public$Cons(pair, keyValuePairs);
            }
            return _elm_lang$core$Native_Json$iife_private$ok(keyValuePairs);

          case "map-many":
            for (var answer = decoder.func, decoders = decoder.decoders, i = 0; i < decoders.length; i++) {
                var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoders[i], value);
                if ("ok" !== result.tag) return result;
                answer = answer(result.value);
            }
            return _elm_lang$core$Native_Json$iife_private$ok(answer);

          case "andThen":
            var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder.decoder, value);
            return "ok" !== result.tag ? result : _elm_lang$core$Native_Json$iife_private$runHelp(decoder.callback(result.value), value);

          case "oneOf":
            for (var errors = [], temp = decoder.decoders; "[]" !== temp.ctor; ) {
                var result = _elm_lang$core$Native_Json$iife_private$runHelp(temp._0, value);
                if ("ok" === result.tag) return result;
                errors.push(result), temp = temp._1;
            }
            return _elm_lang$core$Native_Json$iife_private$badOneOf(errors);

          case "fail":
            return _elm_lang$core$Native_Json$iife_private$bad(decoder.msg);

          case "succeed":
            return _elm_lang$core$Native_Json$iife_private$ok(decoder.msg);
        }
    }
    function _elm_lang$core$Native_Json$iife_private$run(decoder, value) {
        var result = _elm_lang$core$Native_Json$iife_private$runHelp(decoder, value);
        return "ok" === result.tag ? _elm_lang$core$Result$Ok(result.value) : _elm_lang$core$Result$Err(_elm_lang$core$Native_Json$iife_private$badToString(result));
    }
    function _elm_lang$core$Native_Json$iife_private$jsToString(value) {
        return void 0 === value ? "undefined" : JSON.stringify(value);
    }
    function _elm_lang$core$Native_Json$iife_private$badToString(problem) {
        for (var context = "_"; problem; ) switch (problem.tag) {
          case "primitive":
            return "Expecting " + problem.type + ("_" === context ? "" : " at " + context) + " but instead got: " + _elm_lang$core$Native_Json$iife_private$jsToString(problem.value);

          case "index":
            context += "[" + problem.index + "]", problem = problem.rest;
            break;

          case "field":
            context += "." + problem.field, problem = problem.rest;
            break;

          case "oneOf":
            for (var problems = problem.problems, i = 0; i < problems.length; i++) problems[i] = _elm_lang$core$Native_Json$iife_private$badToString(problems[i]);
            return "I ran into the following problems" + ("_" === context ? "" : " at " + context) + ":\n\n" + problems.join("\n");

          case "fail":
            return "I ran into a `fail` decoder" + ("_" === context ? "" : " at " + context) + ": " + problem.msg;
        }
    }
    function _elm_lang$core$Native_Json$iife_private$bad(msg) {
        return {
            tag: "fail",
            msg: msg
        };
    }
    function _elm_lang$core$Native_Json$iife_private$badOneOf(problems) {
        return {
            tag: "oneOf",
            problems: problems
        };
    }
    function _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(index, nestedProblems) {
        return {
            tag: "index",
            index: index,
            rest: nestedProblems
        };
    }
    function _elm_lang$core$Native_Json$iife_private$badField(field, nestedProblems) {
        return {
            tag: "field",
            field: field,
            rest: nestedProblems
        };
    }
    function _elm_lang$core$Native_Json$iife_private$_elm_lang$core$Native_Json$iife_private$badIndex(index, nestedProblems) {
        return {
            tag: "index",
            index: index,
            rest: nestedProblems
        };
    }
    function _elm_lang$core$Native_Json$iife_private$badPrimitive(type, value) {
        return {
            tag: "primitive",
            type: type,
            value: value
        };
    }
    function _elm_lang$core$Native_Json$iife_private$ok(value) {
        return {
            tag: "ok",
            value: value
        };
    }
    function _elm_lang$core$Native_Json$iife_private$map1(f, d1) {
        return _elm_lang$core$Native_Json$iife_private$mapMany(f, [ d1 ]);
    }
    function _elm_lang$core$Native_Json$iife_private$oneOf(decoders) {
        return {
            ctor: "<decoder>",
            tag: "oneOf",
            decoders: decoders
        };
    }
    function _elm_lang$core$Native_Json$iife_private$andThen(callback, decoder) {
        return {
            ctor: "<decoder>",
            tag: "andThen",
            decoder: decoder,
            callback: callback
        };
    }
    function _elm_lang$core$Native_Json$iife_private$mapMany(f, decoders) {
        return {
            ctor: "<decoder>",
            tag: "map-many",
            func: f,
            decoders: decoders
        };
    }
    function _elm_lang$core$Native_Json$iife_private$decodeField(field, decoder) {
        return {
            ctor: "<decoder>",
            tag: "field",
            field: field,
            decoder: decoder
        };
    }
    function _elm_lang$core$Native_Json$iife_private$decodeNull(value) {
        return {
            ctor: "<decoder>",
            tag: "null",
            value: value
        };
    }
    function _elm_lang$core$Native_Json$iife_private$decodeContainer(tag, decoder) {
        return {
            ctor: "<decoder>",
            tag: tag,
            decoder: decoder
        };
    }
    function _elm_lang$core$Native_Json$iife_private$decodePrimitive(tag) {
        return {
            ctor: "<decoder>",
            tag: tag
        };
    }
    function _elm_lang$core$Native_Json$iife_private$fail(msg) {
        return {
            ctor: "<decoder>",
            tag: "fail",
            msg: msg
        };
    }
    function _elm_lang$core$Native_Json$iife_private$succeed(msg) {
        return {
            ctor: "<decoder>",
            tag: "succeed",
            msg: msg
        };
    }
    function _elm_lang$dom$Native_Dom$iife_private$focus(id) {
        return _elm_lang$dom$Native_Dom$iife_private$withNode(id, function(node) {
            return node.focus(), _elm_lang$core$Native_Utils$iife_public$Tuple0;
        });
    }
    function _elm_lang$dom$Native_Dom$iife_private$withNode(id, doStuff) {
        return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function(callback) {
            _elm_lang$dom$Native_Dom$iife_private$rAF(function() {
                var node = document.getElementById(id);
                if (null === node) return void callback(_elm_lang$core$Native_Scheduler$iife_public$fail({
                    ctor: "NotFound",
                    _0: id
                }));
                callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(doStuff(node)));
            });
        });
    }
    function _elm_lang$dom$Native_Dom$iife_private$on(node) {
        return function(eventName, decoder, toTask) {
            return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function(callback) {
                function performTask(event) {
                    var result = A2(_elm_lang$core$Json_Decode$decodeValue, decoder, event);
                    "Ok" === result.ctor && _elm_lang$core$Native_Scheduler$iife_public$rawSpawn(toTask(result._0));
                }
                return node.addEventListener(eventName, performTask), function() {
                    node.removeEventListener(eventName, performTask);
                };
            });
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeIgnorer(overlayNode) {
        return function(event) {
            if ("keydown" !== event.type || !event.metaKey || 82 !== event.which) {
                for (var isScroll = "scroll" === event.type || "wheel" === event.type, node = event.target; null !== node; ) {
                    if ("elm-overlay-message-details" === node.className && isScroll) return;
                    if (node === overlayNode && !isScroll) return;
                    node = node.parentNode;
                }
                event.stopPropagation(), event.preventDefault();
            }
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverseHelp(verbEventListener, handler, eventNames) {
        for (var i = 0; i < eventNames.length; i++) document.body[verbEventListener](eventNames[i], handler, !0);
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverse(verbEventListener, ignorer, blocking) {
        switch (blocking) {
          case "Normal":
            return;

          case "Pause":
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverseHelp(verbEventListener, ignorer, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$mostEvents);

          case "Message":
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverseHelp(verbEventListener, ignorer, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$allEvents);
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$wrapViewIn(appEventNode, overlayNode, viewIn) {
        var overflow, ignorer = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeIgnorer(overlayNode), blocking = "Normal", normalTagger = appEventNode.tagger, blockTagger = function() {};
        return function(model) {
            var tuple = viewIn(model), newBlocking = tuple._0.ctor;
            return appEventNode.tagger = "Normal" === newBlocking ? normalTagger : blockTagger, 
            blocking !== newBlocking && (_elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverse("removeEventListener", ignorer, blocking), 
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$traverse("addEventListener", ignorer, newBlocking), 
            "Normal" === blocking && (overflow = document.body.style.overflow, document.body.style.overflow = "hidden"), 
            "Normal" === newBlocking && (document.body.style.overflow = overflow), blocking = newBlocking), 
            tuple._1;
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$openDebugWindow(moduleName, popoutRef, virtualNode, eventNode) {
        function close() {
            popoutRef.doc = void 0, debugWindow.close();
        }
        var x = screen.width - 900, y = screen.height - 360, debugWindow = window.open("", "", "width=900,height=360,left=" + x + ",top=" + y);
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = debugWindow.document, 
        popoutRef.doc = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.title = "Debugger - " + moduleName, 
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.body.style.margin = "0", 
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.body.style.padding = "0";
        var domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(virtualNode, eventNode);
        return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.body.appendChild(domNode), 
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.addEventListener("keydown", function(event) {
            event.metaKey && 82 === event.which && window.location.reload(), 38 === event.which && (eventNode.tagger({
                ctor: "Up"
            }), event.preventDefault()), 40 === event.which && (eventNode.tagger({
                ctor: "Down"
            }), event.preventDefault());
        }), window.addEventListener("unload", close), debugWindow.addEventListener("unload", function() {
            popoutRef.doc = void 0, window.removeEventListener("unload", close), eventNode.tagger({
                ctor: "Close"
            });
        }), _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = document, domNode;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeDebugStepper(initialModel, view, eventNode, parentNode, moduleName, popoutRef) {
        var curr, domNode;
        return function(model) {
            if (model.isDebuggerOpen) {
                if (!popoutRef.doc) return curr = view(model), void (domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$openDebugWindow(moduleName, popoutRef, curr, eventNode));
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = popoutRef.doc;
                var next = view(model), patches = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diff(curr, next);
                domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatches(domNode, curr, patches, eventNode), 
                curr = next, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = document;
            }
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugRenderer(moduleName, parentNode, popoutRef, view, viewIn, viewOut) {
        return function(tagger, initialModel) {
            var appEventNode = {
                tagger: tagger,
                parent: void 0
            }, eventNode = {
                tagger: tagger,
                parent: void 0
            }, appVirtualNode = view(initialModel), appNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(appVirtualNode, appEventNode);
            parentNode.appendChild(appNode);
            var appStepper = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(appNode, view, appVirtualNode, appEventNode), overVirtualNode = viewIn(initialModel)._1, overNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(overVirtualNode, eventNode);
            parentNode.appendChild(overNode);
            var wrappedViewIn = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$wrapViewIn(appEventNode, overNode, viewIn), overStepper = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(overNode, wrappedViewIn, overVirtualNode, eventNode), debugStepper = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeDebugStepper(initialModel, viewOut, eventNode, parentNode, moduleName, popoutRef);
            return function(model) {
                appStepper(model), overStepper(model), debugStepper(model);
            };
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$scrollTask(popoutRef) {
        return _elm_lang$core$Native_Scheduler$iife_public$nativeBinding(function(callback) {
            var doc = popoutRef.doc;
            if (doc) {
                var msgs = doc.getElementsByClassName("debugger-sidebar-messages")[0];
                msgs && (msgs.scrollTop = msgs.scrollHeight);
            }
            callback(_elm_lang$core$Native_Scheduler$iife_public$succeed(_elm_lang$core$Native_Utils$iife_public$Tuple0));
        });
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugSetup(impl, object, moduleName, flagChecker) {
        object.fullscreen = function(flags) {
            var popoutRef = {
                doc: void 0
            };
            return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, document.body), impl.update(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$scrollTask(popoutRef)), impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugRenderer(moduleName, document.body, popoutRef, impl.view, impl.viewIn, impl.viewOut));
        }, object.embed = function(node, flags) {
            var popoutRef = {
                doc: void 0
            };
            return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, node), impl.update(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$scrollTask(popoutRef)), impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugRenderer(moduleName, node, popoutRef, impl.view, impl.viewIn, impl.viewOut));
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(domNode, view, initialVirtualNode, eventNode) {
        function updateIfNeeded() {
            switch (state) {
              case "NO_REQUEST":
                throw new Error("Unexpected draw callback.\nPlease report this to <https://github.com/elm-lang/virtual-dom/issues>.");

              case "PENDING_REQUEST":
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$rAF(updateIfNeeded), state = "EXTRA_REQUEST";
                var nextNode = view(nextModel), patches = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diff(currNode, nextNode);
                return domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatches(domNode, currNode, patches, eventNode), 
                void (currNode = nextNode);

              case "EXTRA_REQUEST":
                return void (state = "NO_REQUEST");
            }
        }
        var nextModel, state = "NO_REQUEST", currNode = initialVirtualNode;
        return function(model) {
            "NO_REQUEST" === state && _elm_lang$virtual_dom$Native_VirtualDom$iife_private$rAF(updateIfNeeded), 
            state = "PENDING_REQUEST", nextModel = model;
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalRenderer(parentNode, view) {
        return function(tagger, initialModel) {
            var eventNode = {
                tagger: tagger,
                parent: void 0
            }, initialVirtualNode = view(initialModel), domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(initialVirtualNode, eventNode);
            return parentNode.appendChild(domNode), _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeStepper(domNode, view, initialVirtualNode, eventNode);
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalSetup(impl, object, moduleName, flagChecker) {
        object.embed = function(node, flags) {
            for (;node.lastChild; ) node.removeChild(node.lastChild);
            return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, node), impl.update, impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalRenderer(node, impl.view));
        }, object.fullscreen = function(flags) {
            return _elm_lang$core$Native_Platform$iife_public$initialize(flagChecker(impl.init, flags, document.body), impl.update, impl.subscriptions, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalRenderer(document.body, impl.view));
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$crash(errorMessage, domNode) {
        throw domNode && (domNode.innerHTML = '<div style="padding-left:1em;"><h2 style="font-weight:normal;"><b>Oops!</b> Something went wrong when starting your Elm program.</h2><pre style="padding-left:1em;">' + errorMessage + "</pre></div>"), 
        new Error(errorMessage);
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$checkYesFlags(flagDecoder, moduleName) {
        return function(init, flags, domNode) {
            if (void 0 === flagDecoder) {
                var errorMessage = "Are you trying to sneak a Never value into Elm? Trickster!\nIt looks like " + moduleName + ".main is defined with `programWithFlags` but has type `Program Never`.\nUse `program` instead if you do not want flags.";
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$crash(errorMessage, domNode);
            }
            var result = A2(_elm_lang$core$Native_Json$iife_public$run, flagDecoder, flags);
            if ("Ok" === result.ctor) return init(result._0);
            var errorMessage = "Trying to initialize the `" + moduleName + "` module with an unexpected flag.\nI tried to convert it to an Elm value, but ran into this problem:\n\n" + result._0;
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$crash(errorMessage, domNode);
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeProgram(flagChecker) {
        return F2(function(debugWrap, impl) {
            return function(flagDecoder) {
                return function(object, moduleName, debugMetadata) {
                    var checker = flagChecker(flagDecoder, moduleName);
                    void 0 === debugMetadata ? _elm_lang$virtual_dom$Native_VirtualDom$iife_private$normalSetup(impl, object, moduleName, checker) : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$debugSetup(A2(debugWrap, debugMetadata, impl), object, moduleName, checker);
                };
            };
        });
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorderEndInsertsHelp(endInserts, patch) {
        if (void 0 !== endInserts) {
            for (var frag = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createDocumentFragment(), i = 0; i < endInserts.length; i++) {
                var insert = endInserts[i], entry = insert.entry;
                frag.appendChild("move" === entry.tag ? entry.data : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(entry.vnode, patch.eventNode));
            }
            return frag;
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorder(domNode, patch) {
        var data = patch.data, frag = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorderEndInsertsHelp(data.endInserts, patch);
        domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(domNode, data.patches);
        for (var inserts = data.inserts, i = 0; i < inserts.length; i++) {
            var insert = inserts[i], entry = insert.entry, node = "move" === entry.tag ? entry.data : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(entry.vnode, patch.eventNode);
            domNode.insertBefore(node, domNode.childNodes[insert.index]);
        }
        return void 0 !== frag && domNode.appendChild(frag), domNode;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchRedraw(domNode, vNode, eventNode) {
        var parentNode = domNode.parentNode, newNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(vNode, eventNode);
        return void 0 === newNode.elm_event_node_ref && (newNode.elm_event_node_ref = domNode.elm_event_node_ref), 
        parentNode && newNode !== domNode && parentNode.replaceChild(newNode, domNode), 
        newNode;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatch(domNode, patch) {
        switch (patch.type) {
          case "p-redraw":
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchRedraw(domNode, patch.data, patch.eventNode);

          case "p-facts":
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, patch.eventNode, patch.data), 
            domNode;

          case "p-text":
            return domNode.replaceData(0, domNode.length, patch.data), domNode;

          case "p-thunk":
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(domNode, patch.data);

          case "p-tagger":
            return void 0 !== domNode.elm_event_node_ref ? domNode.elm_event_node_ref.tagger = patch.data : domNode.elm_event_node_ref = {
                tagger: patch.data,
                parent: patch.eventNode
            }, domNode;

          case "p-remove-last":
            for (var i = patch.data; i--; ) domNode.removeChild(domNode.lastChild);
            return domNode;

          case "p-append":
            for (var newNodes = patch.data, i = 0; i < newNodes.length; i++) domNode.appendChild(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(newNodes[i], patch.eventNode));
            return domNode;

          case "p-remove":
            var data = patch.data;
            if (void 0 === data) return domNode.parentNode.removeChild(domNode), domNode;
            var entry = data.entry;
            return void 0 !== entry.index && domNode.parentNode.removeChild(domNode), entry.data = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(domNode, data.patches), 
            domNode;

          case "p-reorder":
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchReorder(domNode, patch);

          case "p-custom":
            var impl = patch.data;
            return impl.applyPatch(domNode, impl.data);

          default:
            throw new Error("Ran into an unknown patch!");
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(rootDomNode, patches) {
        for (var i = 0; i < patches.length; i++) {
            var patch = patches[i], localDomNode = patch.domNode, newNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatch(localDomNode, patch);
            localDomNode === rootDomNode && (rootDomNode = newNode);
        }
        return rootDomNode;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatches(rootDomNode, oldVirtualNode, patches, eventNode) {
        return 0 === patches.length ? rootDomNode : (_elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode), 
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyPatchesHelp(rootDomNode, patches));
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode) {
        for (var patch = patches[i], index = patch.index; index === low; ) {
            var patchType = patch.type;
            if ("p-thunk" === patchType) _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodes(domNode, vNode.node, patch.data, eventNode); else if ("p-reorder" === patchType) {
                patch.domNode = domNode, patch.eventNode = eventNode;
                var subPatches = patch.data.patches;
                subPatches.length > 0 && _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
            } else if ("p-remove" === patchType) {
                patch.domNode = domNode, patch.eventNode = eventNode;
                var data = patch.data;
                if (void 0 !== data) {
                    data.entry.data = domNode;
                    var subPatches = data.patches;
                    subPatches.length > 0 && _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
                }
            } else patch.domNode = domNode, patch.eventNode = eventNode;
            if (i++, !(patch = patches[i]) || (index = patch.index) > high) return i;
        }
        switch (vNode.type) {
          case "tagger":
            for (var subNode = vNode.node; "tagger" === subNode.type; ) subNode = subNode.node;
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);

          case "node":
            for (var vChildren = vNode.children, childNodes = domNode.childNodes, j = 0; j < vChildren.length; j++) {
                low++;
                var vChild = vChildren[j], nextLow = low + (vChild.descendantsCount || 0);
                if (low <= index && index <= nextLow && (i = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode), 
                !(patch = patches[i]) || (index = patch.index) > high)) return i;
                low = nextLow;
            }
            return i;

          case "keyed-node":
            for (var vChildren = vNode.children, childNodes = domNode.childNodes, j = 0; j < vChildren.length; j++) {
                low++;
                var vChild = vChildren[j]._1, nextLow = low + (vChild.descendantsCount || 0);
                if (low <= index && index <= nextLow && (i = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode), 
                !(patch = patches[i]) || (index = patch.index) > high)) return i;
                low = nextLow;
            }
            return i;

          case "text":
          case "thunk":
            throw new Error("should never traverse `text` or `thunk` nodes like this");
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodes(domNode, vNode, patches, eventNode) {
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.descendantsCount, eventNode);
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, key, vnode, index) {
        var entry = changes[key];
        if (void 0 === entry) {
            var patch = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-remove", index, void 0);
            return localPatches.push(patch), void (changes[key] = {
                tag: "remove",
                vnode: vnode,
                index: index,
                data: patch
            });
        }
        if ("insert" === entry.tag) {
            entry.tag = "move";
            var subPatches = [];
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(vnode, entry.vnode, subPatches, index);
            var patch = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-remove", index, {
                patches: subPatches,
                entry: entry
            });
            return void localPatches.push(patch);
        }
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, key + _elm_lang$virtual_dom$Native_VirtualDom$iife_private$POSTFIX, vnode, index);
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, key, vnode, bIndex, inserts) {
        var entry = changes[key];
        if (void 0 === entry) return entry = {
            tag: "insert",
            vnode: vnode,
            index: bIndex,
            data: void 0
        }, inserts.push({
            index: bIndex,
            entry: entry
        }), void (changes[key] = entry);
        if ("remove" === entry.tag) {
            inserts.push({
                index: bIndex,
                entry: entry
            }), entry.tag = "move";
            var subPatches = [];
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(entry.vnode, vnode, subPatches, entry.index), 
            entry.index = bIndex, void (entry.data.data = {
                patches: subPatches,
                entry: entry
            });
        }
        _elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, key + _elm_lang$virtual_dom$Native_VirtualDom$iife_private$POSTFIX, vnode, bIndex, inserts);
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffKeyedChildren(aParent, bParent, patches, rootIndex) {
        for (var localPatches = [], changes = {}, inserts = [], aChildren = aParent.children, bChildren = bParent.children, aLen = aChildren.length, bLen = bChildren.length, aIndex = 0, bIndex = 0, index = rootIndex; aIndex < aLen && bIndex < bLen; ) {
            var a = aChildren[aIndex], b = bChildren[bIndex], aKey = a._0, bKey = b._0, aNode = a._1, bNode = b._1;
            if (aKey !== bKey) {
                var aLookAhead = aIndex + 1 < aLen, bLookAhead = bIndex + 1 < bLen;
                if (aLookAhead) var aNext = aChildren[aIndex + 1], aNextKey = aNext._0, aNextNode = aNext._1, oldMatch = bKey === aNextKey;
                if (bLookAhead) var bNext = bChildren[bIndex + 1], bNextKey = bNext._0, bNextNode = bNext._1, newMatch = aKey === bNextKey;
                if (aLookAhead && bLookAhead && newMatch && oldMatch) index++, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNode, bNextNode, localPatches, index), 
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, aKey, bNode, bIndex, inserts), 
                index += aNode.descendantsCount || 0, index++, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, aKey, aNextNode, index), 
                index += aNextNode.descendantsCount || 0, aIndex += 2, bIndex += 2; else if (bLookAhead && newMatch) index++, 
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, bKey, bNode, bIndex, inserts), 
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNode, bNextNode, localPatches, index), 
                index += aNode.descendantsCount || 0, aIndex += 1, bIndex += 2; else if (aLookAhead && oldMatch) index++, 
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, aKey, aNode, index), 
                index += aNode.descendantsCount || 0, index++, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNextNode, bNode, localPatches, index), 
                index += aNextNode.descendantsCount || 0, aIndex += 2, bIndex += 1; else {
                    if (!aLookAhead || !bLookAhead || aNextKey !== bNextKey) break;
                    index++, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, aKey, aNode, index), 
                    _elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, bKey, bNode, bIndex, inserts), 
                    index += aNode.descendantsCount || 0, index++, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNextNode, bNextNode, localPatches, index), 
                    index += aNextNode.descendantsCount || 0, aIndex += 2, bIndex += 2;
                }
            } else index++, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aNode, bNode, localPatches, index), 
            index += aNode.descendantsCount || 0, aIndex++, bIndex++;
        }
        for (;aIndex < aLen; ) {
            index++;
            var a = aChildren[aIndex], aNode = a._1;
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$removeNode(changes, localPatches, a._0, aNode, index), 
            index += aNode.descendantsCount || 0, aIndex++;
        }
        for (var endInserts; bIndex < bLen; ) {
            endInserts = endInserts || [];
            var b = bChildren[bIndex];
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$insertNode(changes, localPatches, b._0, b._1, void 0, endInserts), 
            bIndex++;
        }
        (localPatches.length > 0 || inserts.length > 0 || void 0 !== endInserts) && patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-reorder", rootIndex, {
            patches: localPatches,
            inserts: inserts,
            endInserts: endInserts
        }));
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffChildren(aParent, bParent, patches, rootIndex) {
        var aChildren = aParent.children, bChildren = bParent.children, aLen = aChildren.length, bLen = bChildren.length;
        aLen > bLen ? patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-remove-last", rootIndex, aLen - bLen)) : aLen < bLen && patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-append", rootIndex, bChildren.slice(aLen)));
        for (var index = rootIndex, minLen = aLen < bLen ? aLen : bLen, i = 0; i < minLen; i++) {
            index++;
            var aChild = aChildren[i];
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aChild, bChildren[i], patches, index), 
            index += aChild.descendantsCount || 0;
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a, b, category) {
        var diff;
        for (var aKey in a) if (aKey !== _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY && aKey !== _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY && aKey !== _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY && aKey !== _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY) if (aKey in b) {
            var aValue = a[aKey], bValue = b[aKey];
            aValue === bValue && "value" !== aKey || category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY && _elm_lang$virtual_dom$Native_VirtualDom$iife_private$equalEvents(aValue, bValue) || (diff = diff || {}, 
            diff[aKey] = bValue);
        } else diff = diff || {}, diff[aKey] = void 0 === category ? "string" == typeof a[aKey] ? "" : null : category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY ? "" : category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY || category === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY ? void 0 : {
            namespace: a[aKey].namespace,
            value: void 0
        }; else {
            var subDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a[aKey], b[aKey] || {}, aKey);
            subDiff && (diff = diff || {}, diff[aKey] = subDiff);
        }
        for (var bKey in b) bKey in a || (diff = diff || {}, diff[bKey] = b[bKey]);
        return diff;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$pairwiseRefEqual(as, bs) {
        for (var i = 0; i < as.length; i++) if (as[i] !== bs[i]) return !1;
        return !0;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(a, b, patches, index) {
        if (a !== b) {
            var aType = a.type, bType = b.type;
            if (aType !== bType) return void patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-redraw", index, b));
            switch (bType) {
              case "thunk":
                for (var aArgs = a.args, bArgs = b.args, i = aArgs.length, same = a.func === b.func && i === bArgs.length; same && i--; ) same = aArgs[i] === bArgs[i];
                if (same) return void (b.node = a.node);
                b.node = b.thunk();
                var subPatches = [];
                return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(a.node, b.node, subPatches, 0), 
                void (subPatches.length > 0 && patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-thunk", index, subPatches)));

              case "tagger":
                for (var aTaggers = a.tagger, bTaggers = b.tagger, nesting = !1, aSubNode = a.node; "tagger" === aSubNode.type; ) nesting = !0, 
                "object" != typeof aTaggers ? aTaggers = [ aTaggers, aSubNode.tagger ] : aTaggers.push(aSubNode.tagger), 
                aSubNode = aSubNode.node;
                for (var bSubNode = b.node; "tagger" === bSubNode.type; ) nesting = !0, "object" != typeof bTaggers ? bTaggers = [ bTaggers, bSubNode.tagger ] : bTaggers.push(bSubNode.tagger), 
                bSubNode = bSubNode.node;
                return nesting && aTaggers.length !== bTaggers.length ? void patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-redraw", index, b)) : ((nesting ? _elm_lang$virtual_dom$Native_VirtualDom$iife_private$pairwiseRefEqual(aTaggers, bTaggers) : aTaggers === bTaggers) || patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-tagger", index, bTaggers)), 
                void _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(aSubNode, bSubNode, patches, index + 1));

              case "text":
                if (a.text !== b.text) return void patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-text", index, b.text));
                return;

              case "node":
                if (a.tag !== b.tag || a.namespace !== b.namespace) return void patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-redraw", index, b));
                var factsDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a.facts, b.facts);
                return void 0 !== factsDiff && patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-facts", index, factsDiff)), 
                void _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffChildren(a, b, patches, index);

              case "keyed-node":
                if (a.tag !== b.tag || a.namespace !== b.namespace) return void patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-redraw", index, b));
                var factsDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a.facts, b.facts);
                return void 0 !== factsDiff && patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-facts", index, factsDiff)), 
                void _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffKeyedChildren(a, b, patches, index);

              case "custom":
                if (a.impl !== b.impl) return void patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-redraw", index, b));
                var factsDiff = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffFacts(a.facts, b.facts);
                void 0 !== factsDiff && patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-facts", index, factsDiff));
                var patch = b.impl.diff(a, b);
                if (patch) return void patches.push(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch("p-custom", index, patch));
                return;
            }
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makePatch(type, index, data) {
        return {
            index: index,
            type: type,
            data: data,
            domNode: void 0,
            eventNode: void 0
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diff(a, b) {
        var patches = [];
        return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$diffHelp(a, b, patches, 0), 
        patches;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrsNS(domNode, nsAttrs) {
        for (var key in nsAttrs) {
            var pair = nsAttrs[key], namespace = pair.namespace, value = pair.value;
            void 0 === value ? domNode.removeAttributeNS(namespace, key) : domNode.setAttributeNS(namespace, key, value);
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrs(domNode, attrs) {
        for (var key in attrs) {
            var value = attrs[key];
            void 0 === value ? domNode.removeAttribute(key) : domNode.setAttribute(key, value);
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeEventHandler(eventNode, info) {
        function eventHandler(event) {
            var info = eventHandler.info, value = A2(_elm_lang$core$Native_Json$iife_public$run, info.decoder, event);
            if ("Ok" === value.ctor) {
                var options = info.options;
                options.stopPropagation && event.stopPropagation(), options.preventDefault && event.preventDefault();
                for (var message = value._0, currentEventNode = eventNode; currentEventNode; ) {
                    var tagger = currentEventNode.tagger;
                    if ("function" == typeof tagger) message = tagger(message); else for (var i = tagger.length; i--; ) message = tagger[i](message);
                    currentEventNode = currentEventNode.parent;
                }
            }
        }
        return eventHandler.info = info, eventHandler;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyEvents(domNode, eventNode, events) {
        var allHandlers = domNode.elm_handlers || {};
        for (var key in events) {
            var handler = allHandlers[key], value = events[key];
            if (void 0 === value) domNode.removeEventListener(key, handler), allHandlers[key] = void 0; else if (void 0 === handler) {
                var handler = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeEventHandler(eventNode, value);
                domNode.addEventListener(key, handler), allHandlers[key] = handler;
            } else handler.info = value;
        }
        domNode.elm_handlers = allHandlers;
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyStyles(domNode, styles) {
        var domNodeStyle = domNode.style;
        for (var key in styles) domNodeStyle[key] = styles[key];
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, facts) {
        for (var key in facts) {
            var value = facts[key];
            switch (key) {
              case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY:
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyStyles(domNode, value);
                break;

              case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY:
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyEvents(domNode, eventNode, value);
                break;

              case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY:
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrs(domNode, value);
                break;

              case _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY:
                _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyAttrsNS(domNode, value);
                break;

              case "value":
                domNode[key] !== value && (domNode[key] = value);
                break;

              default:
                domNode[key] = value;
            }
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(vNode, eventNode) {
        switch (vNode.type) {
          case "thunk":
            return vNode.node || (vNode.node = vNode.thunk()), _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(vNode.node, eventNode);

          case "tagger":
            for (var subNode = vNode.node, tagger = vNode.tagger; "tagger" === subNode.type; ) "object" != typeof tagger ? tagger = [ tagger, subNode.tagger ] : tagger.push(subNode.tagger), 
            subNode = subNode.node;
            var subEventRoot = {
                tagger: tagger,
                parent: eventNode
            }, domNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(subNode, subEventRoot);
            return domNode.elm_event_node_ref = subEventRoot, domNode;

          case "text":
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createTextNode(vNode.text);

          case "node":
            var domNode = vNode.namespace ? _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElementNS(vNode.namespace, vNode.tag) : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElement(vNode.tag);
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, vNode.facts);
            for (var children = vNode.children, i = 0; i < children.length; i++) domNode.appendChild(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(children[i], eventNode));
            return domNode;

          case "keyed-node":
            var domNode = vNode.namespace ? _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElementNS(vNode.namespace, vNode.tag) : _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc.createElement(vNode.tag);
            _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, vNode.facts);
            for (var children = vNode.children, i = 0; i < children.length; i++) domNode.appendChild(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$render(children[i]._1, eventNode));
            return domNode;

          case "custom":
            var domNode = vNode.impl.render(vNode.model);
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$applyFacts(domNode, eventNode, vNode.facts), 
            domNode;
        }
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$equalEvents(a, b) {
        return (a.options === b.options || a.options.stopPropagation === b.options.stopPropagation && a.options.preventDefault === b.options.preventDefault) && _elm_lang$core$Native_Json$iife_public$equality(a.decoder, b.decoder);
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$on(name, options, decoder) {
        return {
            key: _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY,
            realKey: name,
            value: {
                options: options,
                decoder: decoder
            }
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$property(key, value) {
        return {
            key: key,
            value: value
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$style(value) {
        return {
            key: _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY,
            value: value
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$organizeFacts(factList) {
        for (var namespace, facts = {}; "[]" !== factList.ctor; ) {
            var entry = factList._0, key = entry.key;
            if (key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY || key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY || key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY) {
                var subFacts = facts[key] || {};
                subFacts[entry.realKey] = entry.value, facts[key] = subFacts;
            } else if (key === _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY) {
                for (var styles = facts[key] || {}, styleList = entry.value; "[]" !== styleList.ctor; ) {
                    var style = styleList._0;
                    styles[style._0] = style._1, styleList = styleList._1;
                }
                facts[key] = styles;
            } else if ("namespace" === key) namespace = entry.value; else if ("className" === key) {
                var classes = facts[key];
                facts[key] = void 0 === classes ? entry.value : classes + " " + entry.value;
            } else facts[key] = entry.value;
            factList = factList._1;
        }
        return {
            facts: facts,
            namespace: namespace
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy2(fn, a, b) {
        return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$thunk(fn, [ a, b ], function() {
            return A2(fn, a, b);
        });
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy(fn, a) {
        return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$thunk(fn, [ a ], function() {
            return fn(a);
        });
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$thunk(func, args, thunk) {
        return {
            type: "thunk",
            func: func,
            args: args,
            thunk: thunk,
            node: void 0
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$keyedNode(tag, factList, kidList) {
        for (var organized = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$organizeFacts(factList), namespace = organized.namespace, facts = organized.facts, children = [], descendantsCount = 0; "[]" !== kidList.ctor; ) {
            var kid = kidList._0;
            descendantsCount += kid._1.descendantsCount || 0, children.push(kid), kidList = kidList._1;
        }
        return descendantsCount += children.length, {
            type: "keyed-node",
            tag: tag,
            facts: facts,
            children: children,
            namespace: namespace,
            descendantsCount: descendantsCount
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$nodeHelp(tag, factList, kidList) {
        for (var organized = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$organizeFacts(factList), namespace = organized.namespace, facts = organized.facts, children = [], descendantsCount = 0; "[]" !== kidList.ctor; ) {
            var kid = kidList._0;
            descendantsCount += kid.descendantsCount || 0, children.push(kid), kidList = kidList._1;
        }
        return descendantsCount += children.length, {
            type: "node",
            tag: tag,
            facts: facts,
            children: children,
            namespace: namespace,
            descendantsCount: descendantsCount
        };
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$node(tag) {
        return F2(function(factList, kidList) {
            return _elm_lang$virtual_dom$Native_VirtualDom$iife_private$nodeHelp(tag, factList, kidList);
        });
    }
    function _elm_lang$virtual_dom$Native_VirtualDom$iife_private$text(string) {
        return {
            type: "text",
            text: string
        };
    }
    var _elm_lang$core$Native_Array$iife_private$M = 32, _elm_lang$core$Native_Array$iife_private$empty = {
        ctor: "_Array",
        height: 0,
        table: []
    }, _elm_lang$core$Native_Array$iife_public$toList = _elm_lang$core$Native_Array$iife_private$toList, _elm_lang$core$Native_Array$iife_public$toJSArray = _elm_lang$core$Native_Array$iife_private$toJSArray, _elm_lang$core$Native_Array$iife_public$fromJSArray = _elm_lang$core$Native_Array$iife_private$fromJSArray, _elm_lang$core$Native_Basics = {}, _elm_lang$core$Native_Basics$iife_public$div = F2(_elm_lang$core$Native_Basics$iife_private$div), _elm_lang$core$Native_Basics$iife_public$mod = F2(_elm_lang$core$Native_Basics$iife_private$mod), _elm_lang$core$Native_Utils$iife_private$LT = (Math.PI, 
    Math.E, Math.cos, Math.sin, Math.tan, Math.acos, Math.asin, Math.atan, Math.atan2, 
    Math.sqrt, Math.ceil, Math.floor, Math.round, isNaN, -1), _elm_lang$core$Native_Utils$iife_private$EQ = 0, _elm_lang$core$Native_Utils$iife_private$GT = 1, _elm_lang$core$Native_Utils$iife_private$Tuple0 = {
        ctor: "_Tuple0"
    }, _elm_lang$core$Native_Utils$iife_private$count = 0, _elm_lang$core$Native_Utils$iife_private$Nil = {
        ctor: "[]"
    }, _elm_lang$core$Native_Utils$iife_public$eq = _elm_lang$core$Native_Utils$iife_private$eq, _elm_lang$core$Native_Utils$iife_public$cmp = _elm_lang$core$Native_Utils$iife_private$cmp, _elm_lang$core$Native_Utils$iife_public$Tuple0 = _elm_lang$core$Native_Utils$iife_private$Tuple0, _elm_lang$core$Native_Utils$iife_public$Tuple2 = _elm_lang$core$Native_Utils$iife_private$Tuple2, _elm_lang$core$Native_Utils$iife_public$chr = _elm_lang$core$Native_Utils$iife_private$chr, _elm_lang$core$Native_Utils$iife_public$update = _elm_lang$core$Native_Utils$iife_private$update, _elm_lang$core$Native_Utils$iife_public$guid = _elm_lang$core$Native_Utils$iife_private$guid, _elm_lang$core$Native_Utils$iife_public$append = F2(_elm_lang$core$Native_Utils$iife_private$append), _elm_lang$core$Native_Utils$iife_public$toString = _elm_lang$core$Native_Utils$iife_private$toString, _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["<|"] = F2(function(f, x) {
        return f(x);
    });
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["|>"] = F2(function(x, f) {
        return f(x);
    });
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops[">>"] = F3(function(f, g, x) {
        return g(f(x));
    });
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["<<"] = F3(function(g, f, x) {
        return g(f(x));
    });
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["++"] = _elm_lang$core$Native_Utils$iife_public$append;
    var _elm_lang$core$Basics$toString = _elm_lang$core$Native_Utils$iife_public$toString, _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["||"] = _elm_lang$core$Native_Basics.or;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["&&"] = _elm_lang$core$Native_Basics.and;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops[">="] = _elm_lang$core$Native_Basics.ge;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["<="] = _elm_lang$core$Native_Basics.le;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops[">"] = _elm_lang$core$Native_Basics.gt;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["<"] = _elm_lang$core$Native_Basics.lt;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["/="] = _elm_lang$core$Native_Basics.neq;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["=="] = _elm_lang$core$Native_Basics.eq;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["^"] = _elm_lang$core$Native_Basics.exp;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["%"] = _elm_lang$core$Native_Basics$iife_public$mod;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["//"] = _elm_lang$core$Native_Basics$iife_public$div;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["/"] = _elm_lang$core$Native_Basics.floatDiv;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["*"] = _elm_lang$core$Native_Basics.mul;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["-"] = _elm_lang$core$Native_Basics.sub;
    var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {};
    _elm_lang$core$Basics_ops["+"] = _elm_lang$core$Native_Basics.add;
    var _elm_lang$core$Maybe$withDefault = F2(function($default, maybe) {
        var _p0 = maybe;
        return "Just" === _p0.ctor ? _p0._0 : $default;
    }), _elm_lang$core$Maybe$Nothing = {
        ctor: "Nothing"
    }, _elm_lang$core$Maybe$Just = function(a) {
        return {
            ctor: "Just",
            _0: a
        };
    }, _elm_lang$core$Native_List$iife_private$Nil = {
        ctor: "[]"
    }, _elm_lang$core$Native_List$iife_public$Nil = _elm_lang$core$Native_List$iife_private$Nil, _elm_lang$core$Native_List$iife_public$Cons = _elm_lang$core$Native_List$iife_private$Cons, _elm_lang$core$Native_List$iife_public$cons = F2(_elm_lang$core$Native_List$iife_private$Cons), _elm_lang$core$Native_List$iife_public$toArray = _elm_lang$core$Native_List$iife_private$toArray, _elm_lang$core$Native_List$iife_public$foldr = F3(_elm_lang$core$Native_List$iife_private$foldr), _elm_lang$core$List$any = F2(function(isOkay, list) {
        for (;;) {
            var _p1 = list;
            if ("[]" === _p1.ctor) return !1;
            if (isOkay(_p1._0)) return !0;
            var _v4 = isOkay, _v5 = _p1._1;
            isOkay = _v4, list = _v5;
        }
    }), _elm_lang$core$List$all = F2(function(isOkay, list) {
        return !A2(_elm_lang$core$List$any, function(_p2) {
            return !isOkay(_p2);
        }, list);
    }), _elm_lang$core$List$foldr = _elm_lang$core$Native_List$iife_public$foldr, _elm_lang$core$List$foldl = F3(function(func, acc, list) {
        for (;;) {
            var _p3 = list;
            if ("[]" === _p3.ctor) return acc;
            var _v7 = func, _v8 = A2(func, _p3._0, acc), _v9 = _p3._1;
            func = _v7, acc = _v8, list = _v9;
        }
    }), _elm_lang$core$List$length = function(xs) {
        return A3(_elm_lang$core$List$foldl, F2(function(_p4, i) {
            return i + 1;
        }), 0, xs);
    }, _elm_lang$core$List$isEmpty = function(xs) {
        return "[]" === xs.ctor;
    }, _elm_lang$core$List_ops = _elm_lang$core$List_ops || {};
    _elm_lang$core$List_ops["::"] = _elm_lang$core$Native_List$iife_public$cons;
    var _elm_lang$core$List$map = F2(function(f, xs) {
        return A3(_elm_lang$core$List$foldr, F2(function(x, acc) {
            return {
                ctor: "::",
                _0: f(x),
                _1: acc
            };
        }), {
            ctor: "[]"
        }, xs);
    }), _elm_lang$core$List$filter = F2(function(pred, xs) {
        return A3(_elm_lang$core$List$foldr, F2(function(front, back) {
            return pred(front) ? {
                ctor: "::",
                _0: front,
                _1: back
            } : back;
        }), {
            ctor: "[]"
        }, xs);
    }), _elm_lang$core$Array$toList = _elm_lang$core$Native_Array$iife_public$toList, _elm_lang$core$Native_Char$iife_public$toCode = function(c) {
        return c.charCodeAt(0);
    }, _elm_lang$core$Char$toCode = _elm_lang$core$Native_Char$iife_public$toCode, _elm_lang$core$Char$isBetween = F3(function(low, high, $char) {
        var code = _elm_lang$core$Char$toCode($char);
        return _elm_lang$core$Native_Utils$iife_public$cmp(code, _elm_lang$core$Char$toCode(low)) > -1 && _elm_lang$core$Native_Utils$iife_public$cmp(code, _elm_lang$core$Char$toCode(high)) < 1;
    }), _elm_lang$core$Native_Scheduler$iife_private$MAX_STEPS = (A2(_elm_lang$core$Char$isBetween, _elm_lang$core$Native_Utils$iife_public$chr("A"), _elm_lang$core$Native_Utils$iife_public$chr("Z")), 
    A2(_elm_lang$core$Char$isBetween, _elm_lang$core$Native_Utils$iife_public$chr("a"), _elm_lang$core$Native_Utils$iife_public$chr("z")), 
    A2(_elm_lang$core$Char$isBetween, _elm_lang$core$Native_Utils$iife_public$chr("0"), _elm_lang$core$Native_Utils$iife_public$chr("9")), 
    A2(_elm_lang$core$Char$isBetween, _elm_lang$core$Native_Utils$iife_public$chr("0"), _elm_lang$core$Native_Utils$iife_public$chr("7")), 
    1e4), _elm_lang$core$Native_Scheduler$iife_private$working = !1, _elm_lang$core$Native_Scheduler$iife_private$workQueue = [], _elm_lang$core$Native_Scheduler$iife_public$succeed = _elm_lang$core$Native_Scheduler$iife_private$succeed, _elm_lang$core$Native_Scheduler$iife_public$fail = _elm_lang$core$Native_Scheduler$iife_private$fail, _elm_lang$core$Native_Scheduler$iife_public$nativeBinding = _elm_lang$core$Native_Scheduler$iife_private$nativeBinding, _elm_lang$core$Native_Scheduler$iife_public$andThen = F2(_elm_lang$core$Native_Scheduler$iife_private$andThen), _elm_lang$core$Native_Scheduler$iife_public$onError = F2(_elm_lang$core$Native_Scheduler$iife_private$onError), _elm_lang$core$Native_Scheduler$iife_public$receive = _elm_lang$core$Native_Scheduler$iife_private$receive, _elm_lang$core$Native_Scheduler$iife_public$spawn = _elm_lang$core$Native_Scheduler$iife_private$spawn, _elm_lang$core$Native_Scheduler$iife_public$rawSpawn = _elm_lang$core$Native_Scheduler$iife_private$rawSpawn, _elm_lang$core$Native_Scheduler$iife_public$rawSend = _elm_lang$core$Native_Scheduler$iife_private$rawSend, _elm_lang$core$Native_Platform$iife_private$effectManagers = {}, _elm_lang$core$Native_Platform$iife_private$outgoingPortMap = F2(function(tagger, value) {
        return value;
    }), _elm_lang$core$Native_Platform$iife_public$sendToApp = F2(_elm_lang$core$Native_Platform$iife_private$sendToApp), _elm_lang$core$Native_Platform$iife_public$effectManagers = _elm_lang$core$Native_Platform$iife_private$effectManagers, _elm_lang$core$Native_Platform$iife_public$outgoingPort = _elm_lang$core$Native_Platform$iife_private$outgoingPort, _elm_lang$core$Native_Platform$iife_public$initialize = _elm_lang$core$Native_Platform$iife_private$initialize, _elm_lang$core$Native_Platform$iife_public$leaf = _elm_lang$core$Native_Platform$iife_private$leaf, _elm_lang$core$Native_Platform$iife_public$batch = _elm_lang$core$Native_Platform$iife_private$batch, _elm_lang$core$Platform_Cmd$batch = _elm_lang$core$Native_Platform$iife_public$batch, _elm_lang$core$Platform_Cmd_ops = _elm_lang$core$Platform_Cmd_ops || {};
    _elm_lang$core$Platform_Cmd_ops["!"] = F2(function(model, commands) {
        return {
            ctor: "_Tuple2",
            _0: model,
            _1: _elm_lang$core$Platform_Cmd$batch(commands)
        };
    });
    var _elm_lang$core$Platform_Sub$batch = _elm_lang$core$Native_Platform$iife_public$batch, _elm_lang$core$Platform_Sub$none = _elm_lang$core$Platform_Sub$batch({
        ctor: "[]"
    }), _elm_lang$core$Platform$sendToApp = _elm_lang$core$Native_Platform$iife_public$sendToApp, _elm_lang$core$Result$Err = function(a) {
        return {
            ctor: "Err",
            _0: a
        };
    }, _elm_lang$core$Result$Ok = function(a) {
        return {
            ctor: "Ok",
            _0: a
        };
    }, _elm_lang$core$Task$onError = _elm_lang$core$Native_Scheduler$iife_public$onError, _elm_lang$core$Task$andThen = _elm_lang$core$Native_Scheduler$iife_public$andThen, _elm_lang$core$Task$spawnCmd = F2(function(router, _p0) {
        var _p1 = _p0;
        return _elm_lang$core$Native_Scheduler$iife_public$spawn(A2(_elm_lang$core$Task$andThen, _elm_lang$core$Platform$sendToApp(router), _p1._0));
    }), _elm_lang$core$Task$succeed = _elm_lang$core$Native_Scheduler$iife_public$succeed, _elm_lang$core$Task$map = F2(function(func, taskA) {
        return A2(_elm_lang$core$Task$andThen, function(a) {
            return _elm_lang$core$Task$succeed(func(a));
        }, taskA);
    }), _elm_lang$core$Task$map2 = F3(function(func, taskA, taskB) {
        return A2(_elm_lang$core$Task$andThen, function(a) {
            return A2(_elm_lang$core$Task$andThen, function(b) {
                return _elm_lang$core$Task$succeed(A2(func, a, b));
            }, taskB);
        }, taskA);
    }), _elm_lang$core$Task$sequence = function(tasks) {
        var _p3 = tasks;
        return "[]" === _p3.ctor ? _elm_lang$core$Task$succeed({
            ctor: "[]"
        }) : A3(_elm_lang$core$Task$map2, F2(function(x, y) {
            return {
                ctor: "::",
                _0: x,
                _1: y
            };
        }), _p3._0, _elm_lang$core$Task$sequence(_p3._1));
    }, _elm_lang$core$Task$onEffects = F3(function(router, commands, state) {
        return A2(_elm_lang$core$Task$map, function(_p4) {
            return {
                ctor: "_Tuple0"
            };
        }, _elm_lang$core$Task$sequence(A2(_elm_lang$core$List$map, _elm_lang$core$Task$spawnCmd(router), commands)));
    }), _elm_lang$core$Task$init = _elm_lang$core$Task$succeed({
        ctor: "_Tuple0"
    }), _elm_lang$core$Task$onSelfMsg = F3(function(_p7, _p6, _p5) {
        return _elm_lang$core$Task$succeed({
            ctor: "_Tuple0"
        });
    }), _elm_lang$core$Task$command = _elm_lang$core$Native_Platform$iife_public$leaf("Task"), _elm_lang$core$Task$Perform = function(a) {
        return {
            ctor: "Perform",
            _0: a
        };
    }, _elm_lang$core$Task$attempt = F2(function(resultToMessage, task) {
        return _elm_lang$core$Task$command(_elm_lang$core$Task$Perform(A2(_elm_lang$core$Task$onError, function(_p8) {
            return _elm_lang$core$Task$succeed(resultToMessage(_elm_lang$core$Result$Err(_p8)));
        }, A2(_elm_lang$core$Task$andThen, function(_p9) {
            return _elm_lang$core$Task$succeed(resultToMessage(_elm_lang$core$Result$Ok(_p9)));
        }, task))));
    }), _elm_lang$core$Task$cmdMap = F2(function(tagger, _p10) {
        return _elm_lang$core$Task$Perform(A2(_elm_lang$core$Task$map, tagger, _p10._0));
    });
    _elm_lang$core$Native_Platform$iife_public$effectManagers.Task = {
        pkg: "elm-lang/core",
        init: _elm_lang$core$Task$init,
        onEffects: _elm_lang$core$Task$onEffects,
        onSelfMsg: _elm_lang$core$Task$onSelfMsg,
        tag: "cmd",
        cmdMap: _elm_lang$core$Task$cmdMap
    };
    var _elm_lang$core$Native_String$iife_public$isEmpty = _elm_lang$core$Native_String$iife_private$isEmpty, _elm_lang$core$Native_String$iife_public$join = F2(_elm_lang$core$Native_String$iife_private$join), _elm_lang$core$String$join = _elm_lang$core$Native_String$iife_public$join, _elm_lang$core$String$isEmpty = _elm_lang$core$Native_String$iife_public$isEmpty, _elm_lang$core$Dict$foldr = F3(function(f, acc, t) {
        for (;;) {
            var _p0 = t;
            if ("RBEmpty_elm_builtin" === _p0.ctor) return acc;
            var _v1 = f, _v2 = A3(f, _p0._1, _p0._2, A3(_elm_lang$core$Dict$foldr, f, acc, _p0._4)), _v3 = _p0._3;
            f = _v1, acc = _v2, t = _v3;
        }
    }), _elm_lang$core$Dict$toList = function(dict) {
        return A3(_elm_lang$core$Dict$foldr, F3(function(key, value, list) {
            return {
                ctor: "::",
                _0: {
                    ctor: "_Tuple2",
                    _0: key,
                    _1: value
                },
                _1: list
            };
        }), {
            ctor: "[]"
        }, dict);
    }, _elm_lang$core$Native_Json$iife_public$run = F2(_elm_lang$core$Native_Json$iife_private$run), _elm_lang$core$Native_Json$iife_public$decodeNull = _elm_lang$core$Native_Json$iife_private$decodeNull, _elm_lang$core$Native_Json$iife_public$decodePrimitive = _elm_lang$core$Native_Json$iife_private$decodePrimitive, _elm_lang$core$Native_Json$iife_public$decodeContainer = F2(_elm_lang$core$Native_Json$iife_private$decodeContainer), _elm_lang$core$Native_Json$iife_public$decodeField = F2(_elm_lang$core$Native_Json$iife_private$decodeField), _elm_lang$core$Native_Json$iife_public$map1 = F2(_elm_lang$core$Native_Json$iife_private$map1), _elm_lang$core$Native_Json$iife_public$andThen = F2(_elm_lang$core$Native_Json$iife_private$andThen), _elm_lang$core$Native_Json$iife_public$fail = _elm_lang$core$Native_Json$iife_private$fail, _elm_lang$core$Native_Json$iife_public$succeed = _elm_lang$core$Native_Json$iife_private$succeed, _elm_lang$core$Native_Json$iife_public$oneOf = _elm_lang$core$Native_Json$iife_private$oneOf, _elm_lang$core$Native_Json$iife_public$identity = _elm_lang$core$Native_Json$iife_private$identity, _elm_lang$core$Native_Json$iife_public$equality = _elm_lang$core$Native_Json$iife_private$equality, _elm_lang$core$Json_Encode$bool = _elm_lang$core$Native_Json$iife_public$identity, _elm_lang$core$Json_Encode$string = _elm_lang$core$Native_Json$iife_public$identity, _elm_lang$core$Json_Decode$null = _elm_lang$core$Native_Json$iife_public$decodeNull, _elm_lang$core$Json_Decode$andThen = _elm_lang$core$Native_Json$iife_public$andThen, _elm_lang$core$Json_Decode$fail = _elm_lang$core$Native_Json$iife_public$fail, _elm_lang$core$Json_Decode$succeed = _elm_lang$core$Native_Json$iife_public$succeed, _elm_lang$core$Json_Decode$decodeValue = _elm_lang$core$Native_Json$iife_public$run, _elm_lang$core$Json_Decode$map = _elm_lang$core$Native_Json$iife_public$map1, _elm_lang$core$Json_Decode$oneOf = _elm_lang$core$Native_Json$iife_public$oneOf, _elm_lang$core$Json_Decode$field = _elm_lang$core$Native_Json$iife_public$decodeField, _elm_lang$core$Json_Decode$at = F2(function(fields, decoder) {
        return A3(_elm_lang$core$List$foldr, _elm_lang$core$Json_Decode$field, decoder, fields);
    }), _elm_lang$core$Json_Decode$int = _elm_lang$core$Native_Json$iife_public$decodePrimitive("int"), _elm_lang$core$Json_Decode$bool = _elm_lang$core$Native_Json$iife_public$decodePrimitive("bool"), _elm_lang$core$Json_Decode$string = _elm_lang$core$Native_Json$iife_public$decodePrimitive("string"), _elm_lang$core$Tuple$second = function(_p4) {
        return _p4._1;
    }, _elm_lang$core$Tuple$first = function(_p6) {
        return _p6._0;
    }, _elm_lang$dom$Native_Dom$iife_private$fakeNode = {
        addEventListener: function() {},
        removeEventListener: function() {}
    }, _elm_lang$dom$Native_Dom$iife_private$rAF = ("undefined" != typeof document && document, 
    "undefined" != typeof window && window, "undefined" != typeof requestAnimationFrame ? requestAnimationFrame : function(callback) {
        callback();
    }), _elm_lang$dom$Native_Dom$iife_public$focus = _elm_lang$dom$Native_Dom$iife_private$focus, _elm_lang$dom$Dom$focus = _elm_lang$dom$Native_Dom$iife_public$focus, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$STYLE_KEY = "STYLE", _elm_lang$virtual_dom$Native_VirtualDom$iife_private$EVENT_KEY = "EVENT", _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_KEY = "ATTR", _elm_lang$virtual_dom$Native_VirtualDom$iife_private$ATTR_NS_KEY = "ATTR_NS", _elm_lang$virtual_dom$Native_VirtualDom$iife_private$localDoc = "undefined" != typeof document ? document : {}, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$POSTFIX = "_elmW6BL", _elm_lang$virtual_dom$Native_VirtualDom$iife_private$programWithFlags = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$makeProgram(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$checkYesFlags), _elm_lang$virtual_dom$Native_VirtualDom$iife_private$rAF = "undefined" != typeof requestAnimationFrame ? requestAnimationFrame : function(callback) {
        setTimeout(callback, 1e3 / 60);
    }, _elm_lang$virtual_dom$Native_VirtualDom$iife_private$mostEvents = [ "click", "dblclick", "mousemove", "mouseup", "mousedown", "mouseenter", "mouseleave", "touchstart", "touchend", "touchcancel", "touchmove", "pointerdown", "pointerup", "pointerover", "pointerout", "pointerenter", "pointerleave", "pointermove", "pointercancel", "dragstart", "drag", "dragend", "dragenter", "dragover", "dragleave", "drop", "keyup", "keydown", "keypress", "input", "change", "focus", "blur" ], _elm_lang$virtual_dom$Native_VirtualDom$iife_private$allEvents = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$mostEvents.concat("wheel", "scroll"), _elm_lang$virtual_dom$Native_VirtualDom$iife_public$node = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$node, _elm_lang$virtual_dom$Native_VirtualDom$iife_public$text = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$text, _elm_lang$virtual_dom$Native_VirtualDom$iife_public$on = F3(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$on), _elm_lang$virtual_dom$Native_VirtualDom$iife_public$style = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$style, _elm_lang$virtual_dom$Native_VirtualDom$iife_public$property = F2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$property), _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy = F2(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy), _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy2 = F3(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$lazy2), _elm_lang$virtual_dom$Native_VirtualDom$iife_public$keyedNode = F3(_elm_lang$virtual_dom$Native_VirtualDom$iife_private$keyedNode), _elm_lang$virtual_dom$Native_VirtualDom$iife_public$programWithFlags = _elm_lang$virtual_dom$Native_VirtualDom$iife_private$programWithFlags, _elm_lang$virtual_dom$VirtualDom$programWithFlags = function(impl) {
        return A2(_elm_lang$virtual_dom$Native_VirtualDom$iife_public$programWithFlags, void 0, impl);
    }, _elm_lang$virtual_dom$VirtualDom$keyedNode = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$keyedNode, _elm_lang$virtual_dom$VirtualDom$lazy2 = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy2, _elm_lang$virtual_dom$VirtualDom$lazy = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$lazy, _elm_lang$virtual_dom$VirtualDom$defaultOptions = {
        stopPropagation: !1,
        preventDefault: !1
    }, _elm_lang$virtual_dom$VirtualDom$onWithOptions = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$on, _elm_lang$virtual_dom$VirtualDom$on = F2(function(eventName, decoder) {
        return A3(_elm_lang$virtual_dom$VirtualDom$onWithOptions, eventName, _elm_lang$virtual_dom$VirtualDom$defaultOptions, decoder);
    }), _elm_lang$virtual_dom$VirtualDom$style = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$style, _elm_lang$virtual_dom$VirtualDom$property = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$property, _elm_lang$virtual_dom$VirtualDom$text = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$text, _elm_lang$virtual_dom$VirtualDom$node = _elm_lang$virtual_dom$Native_VirtualDom$iife_public$node, _elm_lang$html$Html$programWithFlags = _elm_lang$virtual_dom$VirtualDom$programWithFlags, _elm_lang$html$Html$text = _elm_lang$virtual_dom$VirtualDom$text, _elm_lang$html$Html$node = _elm_lang$virtual_dom$VirtualDom$node, _elm_lang$html$Html$section = _elm_lang$html$Html$node("section"), _elm_lang$html$Html$h1 = _elm_lang$html$Html$node("h1"), _elm_lang$html$Html$header = _elm_lang$html$Html$node("header"), _elm_lang$html$Html$footer = _elm_lang$html$Html$node("footer"), _elm_lang$html$Html$p = _elm_lang$html$Html$node("p"), _elm_lang$html$Html$ul = _elm_lang$html$Html$node("ul"), _elm_lang$html$Html$li = _elm_lang$html$Html$node("li"), _elm_lang$html$Html$div = _elm_lang$html$Html$node("div"), _elm_lang$html$Html$a = _elm_lang$html$Html$node("a"), _elm_lang$html$Html$strong = _elm_lang$html$Html$node("strong"), _elm_lang$html$Html$span = _elm_lang$html$Html$node("span"), _elm_lang$html$Html$label = _elm_lang$html$Html$node("label"), _elm_lang$html$Html$input = _elm_lang$html$Html$node("input"), _elm_lang$html$Html$button = _elm_lang$html$Html$node("button"), _elm_lang$html$Html_Attributes$property = _elm_lang$virtual_dom$VirtualDom$property, _elm_lang$html$Html_Attributes$stringProperty = F2(function(name, string) {
        return A2(_elm_lang$html$Html_Attributes$property, name, _elm_lang$core$Json_Encode$string(string));
    }), _elm_lang$html$Html_Attributes$class = function(name) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "className", name);
    }, _elm_lang$html$Html_Attributes$id = function(name) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "id", name);
    }, _elm_lang$html$Html_Attributes$type_ = function(value) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "type", value);
    }, _elm_lang$html$Html_Attributes$value = function(value) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "value", value);
    }, _elm_lang$html$Html_Attributes$placeholder = function(value) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "placeholder", value);
    }, _elm_lang$html$Html_Attributes$name = function(value) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "name", value);
    }, _elm_lang$html$Html_Attributes$for = function(value) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "htmlFor", value);
    }, _elm_lang$html$Html_Attributes$href = function(value) {
        return A2(_elm_lang$html$Html_Attributes$stringProperty, "href", value);
    }, _elm_lang$html$Html_Attributes$boolProperty = F2(function(name, bool) {
        return A2(_elm_lang$html$Html_Attributes$property, name, _elm_lang$core$Json_Encode$bool(bool));
    }), _elm_lang$html$Html_Attributes$hidden = function(bool) {
        return A2(_elm_lang$html$Html_Attributes$boolProperty, "hidden", bool);
    }, _elm_lang$html$Html_Attributes$checked = function(bool) {
        return A2(_elm_lang$html$Html_Attributes$boolProperty, "checked", bool);
    }, _elm_lang$html$Html_Attributes$autofocus = function(bool) {
        return A2(_elm_lang$html$Html_Attributes$boolProperty, "autofocus", bool);
    }, _elm_lang$html$Html_Attributes$classList = function(list) {
        return _elm_lang$html$Html_Attributes$class(A2(_elm_lang$core$String$join, " ", A2(_elm_lang$core$List$map, _elm_lang$core$Tuple$first, A2(_elm_lang$core$List$filter, _elm_lang$core$Tuple$second, list))));
    }, _elm_lang$html$Html_Attributes$style = _elm_lang$virtual_dom$VirtualDom$style, _elm_lang$html$Html_Events$keyCode = A2(_elm_lang$core$Json_Decode$field, "keyCode", _elm_lang$core$Json_Decode$int), _elm_lang$html$Html_Events$targetValue = (A2(_elm_lang$core$Json_Decode$at, {
        ctor: "::",
        _0: "target",
        _1: {
            ctor: "::",
            _0: "checked",
            _1: {
                ctor: "[]"
            }
        }
    }, _elm_lang$core$Json_Decode$bool), A2(_elm_lang$core$Json_Decode$at, {
        ctor: "::",
        _0: "target",
        _1: {
            ctor: "::",
            _0: "value",
            _1: {
                ctor: "[]"
            }
        }
    }, _elm_lang$core$Json_Decode$string)), _elm_lang$html$Html_Events$on = _elm_lang$virtual_dom$VirtualDom$on, _elm_lang$html$Html_Events$onBlur = function(msg) {
        return A2(_elm_lang$html$Html_Events$on, "blur", _elm_lang$core$Json_Decode$succeed(msg));
    }, _elm_lang$html$Html_Events$onInput = function(tagger) {
        return A2(_elm_lang$html$Html_Events$on, "input", A2(_elm_lang$core$Json_Decode$map, tagger, _elm_lang$html$Html_Events$targetValue));
    }, _elm_lang$html$Html_Events$onDoubleClick = function(msg) {
        return A2(_elm_lang$html$Html_Events$on, "dblclick", _elm_lang$core$Json_Decode$succeed(msg));
    }, _elm_lang$html$Html_Events$onClick = function(msg) {
        return A2(_elm_lang$html$Html_Events$on, "click", _elm_lang$core$Json_Decode$succeed(msg));
    }, _elm_lang$html$Html_Keyed$node = _elm_lang$virtual_dom$VirtualDom$keyedNode, _elm_lang$html$Html_Keyed$ul = _elm_lang$html$Html_Keyed$node("ul"), _elm_lang$html$Html_Lazy$lazy2 = _elm_lang$virtual_dom$VirtualDom$lazy2, _elm_lang$html$Html_Lazy$lazy = _elm_lang$virtual_dom$VirtualDom$lazy, _evancz$elm_todomvc$Todo$infoFooter = A2(_elm_lang$html$Html$footer, {
        ctor: "::",
        _0: _elm_lang$html$Html_Attributes$class("info"),
        _1: {
            ctor: "[]"
        }
    }, {
        ctor: "::",
        _0: A2(_elm_lang$html$Html$p, {
            ctor: "[]"
        }, {
            ctor: "::",
            _0: _elm_lang$html$Html$text("Double-click to edit a todo"),
            _1: {
                ctor: "[]"
            }
        }),
        _1: {
            ctor: "::",
            _0: A2(_elm_lang$html$Html$p, {
                ctor: "[]"
            }, {
                ctor: "::",
                _0: _elm_lang$html$Html$text("Written by "),
                _1: {
                    ctor: "::",
                    _0: A2(_elm_lang$html$Html$a, {
                        ctor: "::",
                        _0: _elm_lang$html$Html_Attributes$href("https://github.com/evancz"),
                        _1: {
                            ctor: "[]"
                        }
                    }, {
                        ctor: "::",
                        _0: _elm_lang$html$Html$text("Evan Czaplicki"),
                        _1: {
                            ctor: "[]"
                        }
                    }),
                    _1: {
                        ctor: "[]"
                    }
                }
            }),
            _1: {
                ctor: "::",
                _0: A2(_elm_lang$html$Html$p, {
                    ctor: "[]"
                }, {
                    ctor: "::",
                    _0: _elm_lang$html$Html$text("Part of "),
                    _1: {
                        ctor: "::",
                        _0: A2(_elm_lang$html$Html$a, {
                            ctor: "::",
                            _0: _elm_lang$html$Html_Attributes$href("http://todomvc.com"),
                            _1: {
                                ctor: "[]"
                            }
                        }, {
                            ctor: "::",
                            _0: _elm_lang$html$Html$text("TodoMVC"),
                            _1: {
                                ctor: "[]"
                            }
                        }),
                        _1: {
                            ctor: "[]"
                        }
                    }
                }),
                _1: {
                    ctor: "[]"
                }
            }
        }
    }), _evancz$elm_todomvc$Todo$viewControlsCount = function(entriesLeft) {
        var item_ = _elm_lang$core$Native_Utils$iife_public$eq(entriesLeft, 1) ? " item" : " items";
        return A2(_elm_lang$html$Html$span, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$class("todo-count"),
            _1: {
                ctor: "[]"
            }
        }, {
            ctor: "::",
            _0: A2(_elm_lang$html$Html$strong, {
                ctor: "[]"
            }, {
                ctor: "::",
                _0: _elm_lang$html$Html$text(_elm_lang$core$Basics$toString(entriesLeft)),
                _1: {
                    ctor: "[]"
                }
            }),
            _1: {
                ctor: "::",
                _0: _elm_lang$html$Html$text(A2(_elm_lang$core$Basics_ops["++"], item_, " left")),
                _1: {
                    ctor: "[]"
                }
            }
        });
    }, _evancz$elm_todomvc$Todo$onEnter = function(msg) {
        return A2(_elm_lang$html$Html_Events$on, "keydown", A2(_elm_lang$core$Json_Decode$andThen, function(code) {
            return _elm_lang$core$Native_Utils$iife_public$eq(code, 13) ? _elm_lang$core$Json_Decode$succeed(msg) : _elm_lang$core$Json_Decode$fail("not ENTER");
        }, _elm_lang$html$Html_Events$keyCode));
    }, _evancz$elm_todomvc$Todo$newEntry = F2(function(desc, id) {
        return {
            description: desc,
            completed: !1,
            editing: !1,
            id: id
        };
    }), _evancz$elm_todomvc$Todo$emptyModel = {
        entries: {
            ctor: "[]"
        },
        visibility: "All",
        field: "",
        uid: 0
    }, _evancz$elm_todomvc$Todo$init = function(savedModel) {
        return A2(_elm_lang$core$Platform_Cmd_ops["!"], A2(_elm_lang$core$Maybe$withDefault, _evancz$elm_todomvc$Todo$emptyModel, savedModel), {
            ctor: "[]"
        });
    }, _evancz$elm_todomvc$Todo$setStorage = _elm_lang$core$Native_Platform$iife_public$outgoingPort("setStorage", function(v) {
        return {
            entries: _elm_lang$core$Native_List$iife_public$toArray(v.entries).map(function(v) {
                return {
                    description: v.description,
                    completed: v.completed,
                    editing: v.editing,
                    id: v.id
                };
            }),
            field: v.field,
            uid: v.uid,
            visibility: v.visibility
        };
    }), _evancz$elm_todomvc$Todo$ChangeVisibility = function(a) {
        return {
            ctor: "ChangeVisibility",
            _0: a
        };
    }, _evancz$elm_todomvc$Todo$visibilitySwap = F3(function(uri, visibility, actualVisibility) {
        return A2(_elm_lang$html$Html$li, {
            ctor: "::",
            _0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$ChangeVisibility(visibility)),
            _1: {
                ctor: "[]"
            }
        }, {
            ctor: "::",
            _0: A2(_elm_lang$html$Html$a, {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$href(uri),
                _1: {
                    ctor: "::",
                    _0: _elm_lang$html$Html_Attributes$classList({
                        ctor: "::",
                        _0: {
                            ctor: "_Tuple2",
                            _0: "selected",
                            _1: _elm_lang$core$Native_Utils$iife_public$eq(visibility, actualVisibility)
                        },
                        _1: {
                            ctor: "[]"
                        }
                    }),
                    _1: {
                        ctor: "[]"
                    }
                }
            }, {
                ctor: "::",
                _0: _elm_lang$html$Html$text(visibility),
                _1: {
                    ctor: "[]"
                }
            }),
            _1: {
                ctor: "[]"
            }
        });
    }), _evancz$elm_todomvc$Todo$viewControlsFilters = function(visibility) {
        return A2(_elm_lang$html$Html$ul, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$class("filters"),
            _1: {
                ctor: "[]"
            }
        }, {
            ctor: "::",
            _0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, "#/", "All", visibility),
            _1: {
                ctor: "::",
                _0: _elm_lang$html$Html$text(" "),
                _1: {
                    ctor: "::",
                    _0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, "#/active", "Active", visibility),
                    _1: {
                        ctor: "::",
                        _0: _elm_lang$html$Html$text(" "),
                        _1: {
                            ctor: "::",
                            _0: A3(_evancz$elm_todomvc$Todo$visibilitySwap, "#/completed", "Completed", visibility),
                            _1: {
                                ctor: "[]"
                            }
                        }
                    }
                }
            }
        });
    }, _evancz$elm_todomvc$Todo$CheckAll = function(a) {
        return {
            ctor: "CheckAll",
            _0: a
        };
    }, _evancz$elm_todomvc$Todo$Check = F2(function(a, b) {
        return {
            ctor: "Check",
            _0: a,
            _1: b
        };
    }), _evancz$elm_todomvc$Todo$DeleteComplete = {
        ctor: "DeleteComplete"
    }, _evancz$elm_todomvc$Todo$viewControlsClear = function(entriesCompleted) {
        return A2(_elm_lang$html$Html$button, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$class("clear-completed"),
            _1: {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$hidden(_elm_lang$core$Native_Utils$iife_public$eq(entriesCompleted, 0)),
                _1: {
                    ctor: "::",
                    _0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$DeleteComplete),
                    _1: {
                        ctor: "[]"
                    }
                }
            }
        }, {
            ctor: "::",
            _0: _elm_lang$html$Html$text(A2(_elm_lang$core$Basics_ops["++"], "Clear completed (", A2(_elm_lang$core$Basics_ops["++"], _elm_lang$core$Basics$toString(entriesCompleted), ")"))),
            _1: {
                ctor: "[]"
            }
        });
    }, _evancz$elm_todomvc$Todo$viewControls = F2(function(visibility, entries) {
        var entriesCompleted = _elm_lang$core$List$length(A2(_elm_lang$core$List$filter, function(_) {
            return _.completed;
        }, entries)), entriesLeft = _elm_lang$core$List$length(entries) - entriesCompleted;
        return A2(_elm_lang$html$Html$footer, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$class("footer"),
            _1: {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$hidden(_elm_lang$core$List$isEmpty(entries)),
                _1: {
                    ctor: "[]"
                }
            }
        }, {
            ctor: "::",
            _0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsCount, entriesLeft),
            _1: {
                ctor: "::",
                _0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsFilters, visibility),
                _1: {
                    ctor: "::",
                    _0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewControlsClear, entriesCompleted),
                    _1: {
                        ctor: "[]"
                    }
                }
            }
        });
    }), _evancz$elm_todomvc$Todo$Delete = function(a) {
        return {
            ctor: "Delete",
            _0: a
        };
    }, _evancz$elm_todomvc$Todo$Add = {
        ctor: "Add"
    }, _evancz$elm_todomvc$Todo$UpdateEntry = F2(function(a, b) {
        return {
            ctor: "UpdateEntry",
            _0: a,
            _1: b
        };
    }), _evancz$elm_todomvc$Todo$EditingEntry = F2(function(a, b) {
        return {
            ctor: "EditingEntry",
            _0: a,
            _1: b
        };
    }), _evancz$elm_todomvc$Todo$viewEntry = function(todo) {
        return A2(_elm_lang$html$Html$li, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$classList({
                ctor: "::",
                _0: {
                    ctor: "_Tuple2",
                    _0: "completed",
                    _1: todo.completed
                },
                _1: {
                    ctor: "::",
                    _0: {
                        ctor: "_Tuple2",
                        _0: "editing",
                        _1: todo.editing
                    },
                    _1: {
                        ctor: "[]"
                    }
                }
            }),
            _1: {
                ctor: "[]"
            }
        }, {
            ctor: "::",
            _0: A2(_elm_lang$html$Html$div, {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$class("view"),
                _1: {
                    ctor: "[]"
                }
            }, {
                ctor: "::",
                _0: A2(_elm_lang$html$Html$input, {
                    ctor: "::",
                    _0: _elm_lang$html$Html_Attributes$class("toggle"),
                    _1: {
                        ctor: "::",
                        _0: _elm_lang$html$Html_Attributes$type_("checkbox"),
                        _1: {
                            ctor: "::",
                            _0: _elm_lang$html$Html_Attributes$checked(todo.completed),
                            _1: {
                                ctor: "::",
                                _0: _elm_lang$html$Html_Events$onClick(A2(_evancz$elm_todomvc$Todo$Check, todo.id, !todo.completed)),
                                _1: {
                                    ctor: "[]"
                                }
                            }
                        }
                    }
                }, {
                    ctor: "[]"
                }),
                _1: {
                    ctor: "::",
                    _0: A2(_elm_lang$html$Html$label, {
                        ctor: "::",
                        _0: _elm_lang$html$Html_Events$onDoubleClick(A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, !0)),
                        _1: {
                            ctor: "[]"
                        }
                    }, {
                        ctor: "::",
                        _0: _elm_lang$html$Html$text(todo.description),
                        _1: {
                            ctor: "[]"
                        }
                    }),
                    _1: {
                        ctor: "::",
                        _0: A2(_elm_lang$html$Html$button, {
                            ctor: "::",
                            _0: _elm_lang$html$Html_Attributes$class("destroy"),
                            _1: {
                                ctor: "::",
                                _0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$Delete(todo.id)),
                                _1: {
                                    ctor: "[]"
                                }
                            }
                        }, {
                            ctor: "[]"
                        }),
                        _1: {
                            ctor: "[]"
                        }
                    }
                }
            }),
            _1: {
                ctor: "::",
                _0: A2(_elm_lang$html$Html$input, {
                    ctor: "::",
                    _0: _elm_lang$html$Html_Attributes$class("edit"),
                    _1: {
                        ctor: "::",
                        _0: _elm_lang$html$Html_Attributes$value(todo.description),
                        _1: {
                            ctor: "::",
                            _0: _elm_lang$html$Html_Attributes$name("title"),
                            _1: {
                                ctor: "::",
                                _0: _elm_lang$html$Html_Attributes$id(A2(_elm_lang$core$Basics_ops["++"], "todo-", _elm_lang$core$Basics$toString(todo.id))),
                                _1: {
                                    ctor: "::",
                                    _0: _elm_lang$html$Html_Events$onInput(_evancz$elm_todomvc$Todo$UpdateEntry(todo.id)),
                                    _1: {
                                        ctor: "::",
                                        _0: _elm_lang$html$Html_Events$onBlur(A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, !1)),
                                        _1: {
                                            ctor: "::",
                                            _0: _evancz$elm_todomvc$Todo$onEnter(A2(_evancz$elm_todomvc$Todo$EditingEntry, todo.id, !1)),
                                            _1: {
                                                ctor: "[]"
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }, {
                    ctor: "[]"
                }),
                _1: {
                    ctor: "[]"
                }
            }
        });
    }, _evancz$elm_todomvc$Todo$viewKeyedEntry = function(todo) {
        return {
            ctor: "_Tuple2",
            _0: _elm_lang$core$Basics$toString(todo.id),
            _1: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewEntry, todo)
        };
    }, _evancz$elm_todomvc$Todo$viewEntries = F2(function(visibility, entries) {
        var cssVisibility = _elm_lang$core$List$isEmpty(entries) ? "hidden" : "visible", allCompleted = A2(_elm_lang$core$List$all, function(_) {
            return _.completed;
        }, entries), isVisible = function(todo) {
            switch (visibility) {
              case "Completed":
                return todo.completed;

              case "Active":
                return !todo.completed;

              default:
                return !0;
            }
        };
        return A2(_elm_lang$html$Html$section, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$class("main"),
            _1: {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$style({
                    ctor: "::",
                    _0: {
                        ctor: "_Tuple2",
                        _0: "visibility",
                        _1: cssVisibility
                    },
                    _1: {
                        ctor: "[]"
                    }
                }),
                _1: {
                    ctor: "[]"
                }
            }
        }, {
            ctor: "::",
            _0: A2(_elm_lang$html$Html$input, {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$class("toggle-all"),
                _1: {
                    ctor: "::",
                    _0: _elm_lang$html$Html_Attributes$type_("checkbox"),
                    _1: {
                        ctor: "::",
                        _0: _elm_lang$html$Html_Attributes$name("toggle"),
                        _1: {
                            ctor: "::",
                            _0: _elm_lang$html$Html_Attributes$checked(allCompleted),
                            _1: {
                                ctor: "::",
                                _0: _elm_lang$html$Html_Events$onClick(_evancz$elm_todomvc$Todo$CheckAll(!allCompleted)),
                                _1: {
                                    ctor: "[]"
                                }
                            }
                        }
                    }
                }
            }, {
                ctor: "[]"
            }),
            _1: {
                ctor: "::",
                _0: A2(_elm_lang$html$Html$label, {
                    ctor: "::",
                    _0: _elm_lang$html$Html_Attributes$for("toggle-all"),
                    _1: {
                        ctor: "[]"
                    }
                }, {
                    ctor: "::",
                    _0: _elm_lang$html$Html$text("Mark all as complete"),
                    _1: {
                        ctor: "[]"
                    }
                }),
                _1: {
                    ctor: "::",
                    _0: A2(_elm_lang$html$Html_Keyed$ul, {
                        ctor: "::",
                        _0: _elm_lang$html$Html_Attributes$class("todo-list"),
                        _1: {
                            ctor: "[]"
                        }
                    }, A2(_elm_lang$core$List$map, _evancz$elm_todomvc$Todo$viewKeyedEntry, A2(_elm_lang$core$List$filter, isVisible, entries))),
                    _1: {
                        ctor: "[]"
                    }
                }
            }
        });
    }), _evancz$elm_todomvc$Todo$UpdateField = function(a) {
        return {
            ctor: "UpdateField",
            _0: a
        };
    }, _evancz$elm_todomvc$Todo$viewInput = function(task) {
        return A2(_elm_lang$html$Html$header, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$class("header"),
            _1: {
                ctor: "[]"
            }
        }, {
            ctor: "::",
            _0: A2(_elm_lang$html$Html$h1, {
                ctor: "[]"
            }, {
                ctor: "::",
                _0: _elm_lang$html$Html$text("todos"),
                _1: {
                    ctor: "[]"
                }
            }),
            _1: {
                ctor: "::",
                _0: A2(_elm_lang$html$Html$input, {
                    ctor: "::",
                    _0: _elm_lang$html$Html_Attributes$class("new-todo"),
                    _1: {
                        ctor: "::",
                        _0: _elm_lang$html$Html_Attributes$placeholder("What needs to be done?"),
                        _1: {
                            ctor: "::",
                            _0: _elm_lang$html$Html_Attributes$autofocus(!0),
                            _1: {
                                ctor: "::",
                                _0: _elm_lang$html$Html_Attributes$value(task),
                                _1: {
                                    ctor: "::",
                                    _0: _elm_lang$html$Html_Attributes$name("newTodo"),
                                    _1: {
                                        ctor: "::",
                                        _0: _elm_lang$html$Html_Events$onInput(_evancz$elm_todomvc$Todo$UpdateField),
                                        _1: {
                                            ctor: "::",
                                            _0: _evancz$elm_todomvc$Todo$onEnter(_evancz$elm_todomvc$Todo$Add),
                                            _1: {
                                                ctor: "[]"
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }, {
                    ctor: "[]"
                }),
                _1: {
                    ctor: "[]"
                }
            }
        });
    }, _evancz$elm_todomvc$Todo$view = function(model) {
        return A2(_elm_lang$html$Html$div, {
            ctor: "::",
            _0: _elm_lang$html$Html_Attributes$class("todomvc-wrapper"),
            _1: {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$style({
                    ctor: "::",
                    _0: {
                        ctor: "_Tuple2",
                        _0: "visibility",
                        _1: "hidden"
                    },
                    _1: {
                        ctor: "[]"
                    }
                }),
                _1: {
                    ctor: "[]"
                }
            }
        }, {
            ctor: "::",
            _0: A2(_elm_lang$html$Html$section, {
                ctor: "::",
                _0: _elm_lang$html$Html_Attributes$class("todoapp"),
                _1: {
                    ctor: "[]"
                }
            }, {
                ctor: "::",
                _0: A2(_elm_lang$html$Html_Lazy$lazy, _evancz$elm_todomvc$Todo$viewInput, model.field),
                _1: {
                    ctor: "::",
                    _0: A3(_elm_lang$html$Html_Lazy$lazy2, _evancz$elm_todomvc$Todo$viewEntries, model.visibility, model.entries),
                    _1: {
                        ctor: "::",
                        _0: A3(_elm_lang$html$Html_Lazy$lazy2, _evancz$elm_todomvc$Todo$viewControls, model.visibility, model.entries),
                        _1: {
                            ctor: "[]"
                        }
                    }
                }
            }),
            _1: {
                ctor: "::",
                _0: _evancz$elm_todomvc$Todo$infoFooter,
                _1: {
                    ctor: "[]"
                }
            }
        });
    }, _evancz$elm_todomvc$Todo$NoOp = {
        ctor: "NoOp"
    }, _evancz$elm_todomvc$Todo$update = F2(function(msg, model) {
        var _p1 = msg;
        switch (_p1.ctor) {
          case "NoOp":
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], model, {
                ctor: "[]"
            });

          case "Add":
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                uid: model.uid + 1,
                field: "",
                entries: _elm_lang$core$String$isEmpty(model.field) ? model.entries : A2(_elm_lang$core$Basics_ops["++"], model.entries, {
                    ctor: "::",
                    _0: A2(_evancz$elm_todomvc$Todo$newEntry, model.field, model.uid),
                    _1: {
                        ctor: "[]"
                    }
                })
            }), {
                ctor: "[]"
            });

          case "UpdateField":
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                field: _p1._0
            }), {
                ctor: "[]"
            });

          case "EditingEntry":
            var _p3 = _p1._0, focus = _elm_lang$dom$Dom$focus(A2(_elm_lang$core$Basics_ops["++"], "todo-", _elm_lang$core$Basics$toString(_p3))), updateEntry = function(t) {
                return _elm_lang$core$Native_Utils$iife_public$eq(t.id, _p3) ? _elm_lang$core$Native_Utils$iife_public$update(t, {
                    editing: _p1._1
                }) : t;
            };
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
            }), {
                ctor: "::",
                _0: A2(_elm_lang$core$Task$attempt, function(_p2) {
                    return _evancz$elm_todomvc$Todo$NoOp;
                }, focus),
                _1: {
                    ctor: "[]"
                }
            });

          case "UpdateEntry":
            var updateEntry = function(t) {
                return _elm_lang$core$Native_Utils$iife_public$eq(t.id, _p1._0) ? _elm_lang$core$Native_Utils$iife_public$update(t, {
                    description: _p1._1
                }) : t;
            };
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
            }), {
                ctor: "[]"
            });

          case "Delete":
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                entries: A2(_elm_lang$core$List$filter, function(t) {
                    return !_elm_lang$core$Native_Utils$iife_public$eq(t.id, _p1._0);
                }, model.entries)
            }), {
                ctor: "[]"
            });

          case "DeleteComplete":
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                entries: A2(_elm_lang$core$List$filter, function(_p4) {
                    return !function(_) {
                        return _.completed;
                    }(_p4);
                }, model.entries)
            }), {
                ctor: "[]"
            });

          case "Check":
            var updateEntry = function(t) {
                return _elm_lang$core$Native_Utils$iife_public$eq(t.id, _p1._0) ? _elm_lang$core$Native_Utils$iife_public$update(t, {
                    completed: _p1._1
                }) : t;
            };
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
            }), {
                ctor: "[]"
            });

          case "CheckAll":
            var updateEntry = function(t) {
                return _elm_lang$core$Native_Utils$iife_public$update(t, {
                    completed: _p1._0
                });
            };
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                entries: A2(_elm_lang$core$List$map, updateEntry, model.entries)
            }), {
                ctor: "[]"
            });

          default:
            return A2(_elm_lang$core$Platform_Cmd_ops["!"], _elm_lang$core$Native_Utils$iife_public$update(model, {
                visibility: _p1._0
            }), {
                ctor: "[]"
            });
        }
    }), _evancz$elm_todomvc$Todo$updateWithStorage = F2(function(msg, model) {
        var _p5 = A2(_evancz$elm_todomvc$Todo$update, msg, model), newModel = _p5._0, cmds = _p5._1;
        return {
            ctor: "_Tuple2",
            _0: newModel,
            _1: _elm_lang$core$Platform_Cmd$batch({
                ctor: "::",
                _0: _evancz$elm_todomvc$Todo$setStorage(newModel),
                _1: {
                    ctor: "::",
                    _0: cmds,
                    _1: {
                        ctor: "[]"
                    }
                }
            })
        };
    }), _evancz$elm_todomvc$Todo$main = _elm_lang$html$Html$programWithFlags({
        init: _evancz$elm_todomvc$Todo$init,
        view: _evancz$elm_todomvc$Todo$view,
        update: _evancz$elm_todomvc$Todo$updateWithStorage,
        subscriptions: function(_p6) {
            return _elm_lang$core$Platform_Sub$none;
        }
    })(_elm_lang$core$Json_Decode$oneOf({
        ctor: "::",
        _0: _elm_lang$core$Json_Decode$null(_elm_lang$core$Maybe$Nothing),
        _1: {
            ctor: "::",
            _0: A2(_elm_lang$core$Json_Decode$map, _elm_lang$core$Maybe$Just, A2(_elm_lang$core$Json_Decode$andThen, function(entries) {
                return A2(_elm_lang$core$Json_Decode$andThen, function(field) {
                    return A2(_elm_lang$core$Json_Decode$andThen, function(uid) {
                        return A2(_elm_lang$core$Json_Decode$andThen, function(visibility) {
                            return _elm_lang$core$Json_Decode$succeed({
                                entries: entries,
                                field: field,
                                uid: uid,
                                visibility: visibility
                            });
                        }, A2(_elm_lang$core$Json_Decode$field, "visibility", _elm_lang$core$Json_Decode$string));
                    }, A2(_elm_lang$core$Json_Decode$field, "uid", _elm_lang$core$Json_Decode$int));
                }, A2(_elm_lang$core$Json_Decode$field, "field", _elm_lang$core$Json_Decode$string));
            }, A2(_elm_lang$core$Json_Decode$field, "entries", function(decoder) {
                return A2(_elm_lang$core$Native_Json$iife_public$decodeContainer, "list", decoder);
            }(A2(_elm_lang$core$Json_Decode$andThen, function(completed) {
                return A2(_elm_lang$core$Json_Decode$andThen, function(description) {
                    return A2(_elm_lang$core$Json_Decode$andThen, function(editing) {
                        return A2(_elm_lang$core$Json_Decode$andThen, function(id) {
                            return _elm_lang$core$Json_Decode$succeed({
                                completed: completed,
                                description: description,
                                editing: editing,
                                id: id
                            });
                        }, A2(_elm_lang$core$Json_Decode$field, "id", _elm_lang$core$Json_Decode$int));
                    }, A2(_elm_lang$core$Json_Decode$field, "editing", _elm_lang$core$Json_Decode$bool));
                }, A2(_elm_lang$core$Json_Decode$field, "description", _elm_lang$core$Json_Decode$string));
            }, A2(_elm_lang$core$Json_Decode$field, "completed", _elm_lang$core$Json_Decode$bool)))))),
            _1: {
                ctor: "[]"
            }
        }
    })), Elm = {};
    if (Elm.Todo = Elm.Todo || {}, void 0 !== _evancz$elm_todomvc$Todo$main && _evancz$elm_todomvc$Todo$main(Elm.Todo, "Todo", void 0), 
    "function" == typeof define && define.amd) return void define([], function() {
        return Elm;
    });
    if ("object" == typeof module) return void (module.exports = Elm);
    var globalElm = this.Elm;
    if (void 0 === globalElm) return void (this.Elm = Elm);
    for (var publicModule in Elm) {
        if (publicModule in globalElm) throw new Error("There are two Elm modules called `" + publicModule + "` on this page! Rename one of them.");
        globalElm[publicModule] = Elm[publicModule];
    }
}).call(this);

uglify-optimized.js

(function(){"use strict";function r(r){function t(t){return function(e){return r(t,e)}}return t.arity=2,t.func=r,t}function t(r){function t(t){return function(e){return function(n){return r(t,e,n)}}}return t.arity=3,t.func=r,t}function e(r,t,e){return 2===r.arity?r.func(t,e):r(t)(e)}function n(r,t,e,n){return 3===r.arity?r.func(t,e,n):r(t)(e)(n)}function o(r,t,e,n,o){return 4===r.arity?r.func(t,e,n,o):r(t)(e)(n)(o)}function c(r,t,e,n){if(0===t)return{ctor:"_Array",height:0,table:r.slice(e,n)};for(var o=Math.pow(xt,t),i=new Array(Math.ceil((n-e)/o)),a=new Array(i.length),u=0;u<i.length;u++)i[u]=c(r,t-1,e+u*o,Math.min(e+(u+1)*o,n)),a[u]=f(i[u])+(u>0?a[u-1]:0);return{ctor:"_Array",height:t,table:i,lengths:a}}function i(r){return 0===r.length?Ct:c(r,Math.floor(Math.log(r.length)/Math.log(xt)),0,r.length)}function a(r,t,e){for(var n=0;n<e.table.length;n++)if(0===e.height)r[t+n]=e.table[n];else{var o=0===n?0:e.lengths[n-1];a(r,t+o,e.table[n])}}function u(r){var t=new Array(f(r));return a(t,0,r),t}function f(r){return 0===r.height?r.table.length:r.lengths[r.lengths.length-1]}function d(r,t){for(var e=t.table.length-1;e>=0;e--)r=0===t.height?ee(t.table[e],r):d(r,t.table[e]);return r}function s(r){return d(te,r)}function l(r,t){if(0===t)throw new Error("Cannot perform mod 0. Division by zero error.");var e=r%t,n=0===r?0:t>0?r>=0?e:e+t:-l(-r,-t);return n===t?0:n}function v(r,t){return r/t|0}function _(r,t){var e=r.replace(/\\/g,"\\\\").replace(/\n/g,"\\n").replace(/\t/g,"\\t").replace(/\r/g,"\\r").replace(/\v/g,"\\v").replace(/\0/g,"\\0");return t?e.replace(/\'/g,"\\'"):e.replace(/\"/g,'\\"')}function p(r){var t=typeof r;if("function"===t)return"<function>";if("boolean"===t)return r?"True":"False";if("number"===t)return r+"";if(r instanceof String)return"'"+_(r,!0)+"'";if("string"===t)return'"'+_(r,!1)+'"';if(null===r)return"null";if("object"===t&&"ctor"in r){var e=r.ctor.substring(0,5);if("_Tupl"===e){var n=[];for(var o in r)"ctor"!==o&&n.push(p(r[o]));return"("+n.join(",")+")"}if("_Task"===e)return"<task>";if("_Array"===r.ctor){return"Array.fromList "+p(pe(r))}if("<decoder>"===r.ctor)return"<decoder>";if("_Process"===r.ctor)return"<process:"+r.id+">";if("::"===r.ctor){var n="["+p(r._0);for(r=r._1;"::"===r.ctor;)n+=","+p(r._0),r=r._1;return n+"]"}if("[]"===r.ctor)return"[]";if("Set_elm_builtin"===r.ctor)return"Set.fromList "+p(_elm_lang$core$Set$toList(r));if("RBNode_elm_builtin"===r.ctor||"RBEmpty_elm_builtin"===r.ctor)return"Dict.fromList "+p(ln(r));var n="";for(var c in r)if("ctor"!==c){var i=p(r[c]),a=i[0],u="{"===a||"("===a||"<"===a||'"'===a||i.indexOf(" ")<0;n+=" "+(u?i:"("+i+")")}return r.ctor+n}if("object"===t){if(r instanceof Date)return"<"+r.toString()+">";if(r.elm_web_socket)return"<websocket>";var n=[];for(var o in r)n.push(o+" = "+p(r[o]));return 0===n.length?"{}":"{ "+n.join(", ")+" }"}return"<internal structure>"}function g(r,t){if("string"==typeof r)return r+t;if("[]"===r.ctor)return t;var e=h(r._0,It),n=e;for(r=r._1;"[]"!==r.ctor;)n._1=h(r._0,It),r=r._1,n=n._1;return n._1=t,e}function h(r,t){return{ctor:"::",_0:r,_1:t}}function m(r,t){var e={};for(var n in r)e[n]=r[n];for(var n in t)e[n]=t[n];return e}function y(r){return Ut++}function b(r){return new String(r)}function k(r,t){return{ctor:"_Tuple2",_0:r,_1:t}}function w(r,t){if("object"!=typeof r)return r===t?Pt:r<t?Rt:jt;if(r instanceof String){var e=r.valueOf(),n=t.valueOf();return e===n?Pt:e<n?Rt:jt}if("::"===r.ctor||"[]"===r.ctor){for(;"::"===r.ctor&&"::"===t.ctor;){var o=w(r._0,t._0);if(o!==Pt)return o;r=r._1,t=t._1}return r.ctor===t.ctor?Pt:"[]"===r.ctor?Rt:jt}if("_Tuple"===r.ctor.slice(0,6)){var o,c=r.ctor.slice(6)-0;if(0===c)return Pt;if(c>=1){if((o=w(r._0,t._0))!==Pt)return o;if(c>=2){if((o=w(r._1,t._1))!==Pt)return o;if(c>=3){if((o=w(r._2,t._2))!==Pt)return o;if(c>=4){if((o=w(r._3,t._3))!==Pt)return o;if(c>=5){if((o=w(r._4,t._4))!==Pt)return o;if(c>=6){if((o=w(r._5,t._5))!==Pt)return o;if(c>=7)throw new Error("Comparison error: cannot compare tuples with more than 6 elements.")}}}}}}return Pt}throw new Error("Comparison error: comparison is only defined on ints, floats, times, chars, strings, lists of comparable values, and tuples of comparable values.")}function E(r,t,e,n){if(e>100)return n.push({x:r,y:t}),!0;if(r===t)return!0;if("object"!=typeof r){if("function"==typeof r)throw new Error('Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense. Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#== which describes why it is this way and what the better version will look like.');return!1}if(null===r||null===t)return!1;if(r instanceof Date)return r.getTime()===t.getTime();if(!("ctor"in r)){for(var o in r)if(!E(r[o],t[o],e+1,n))return!1;return!0}if("RBNode_elm_builtin"!==r.ctor&&"RBEmpty_elm_builtin"!==r.ctor||(r=ln(r),t=ln(t)),"Set_elm_builtin"===r.ctor&&(r=_elm_lang$core$Set$toList(r),t=_elm_lang$core$Set$toList(t)),"::"===r.ctor){for(var c=r,i=t;"::"===c.ctor&&"::"===i.ctor;){if(!E(c._0,i._0,e+1,n))return!1;c=c._1,i=i._1}return c.ctor===i.ctor}if("_Array"===r.ctor){var a=St(r),u=St(t);if(a.length!==u.length)return!1;for(var f=0;f<a.length;f++)if(!E(a[f],u[f],e+1,n))return!1;return!0}if(!E(r.ctor,t.ctor,e+1,n))return!1;for(var o in r)if(!E(r[o],t[o],e+1,n))return!1;return!0}function T(r,t){for(var e,n=[],o=E(r,t,0,n);o&&(e=n.pop());)o=E(e.x,e.y,0,n);return o}function N(r,t,n){for(var o=x(n),c=t,i=o.length;i--;)c=e(r,o[i],c);return c}function x(r){for(var t=[];"[]"!==r.ctor;)t.push(r._0),r=r._1;return t}function C(r,t){return{ctor:"::",_0:r,_1:t}}function A(){for(var r,t=0;t<ye&&(r=ke.shift());)r.root&&(t=M(t,r));if(!r)return void(be=!1);setTimeout(A,0)}function S(r){ke.push(r),be||(setTimeout(A,0),be=!0)}function M(r,t){for(;r<ye;){var e=t.root.ctor;if("_Task_succeed"!==e)if("_Task_fail"!==e)if("_Task_andThen"!==e)if("_Task_onError"!==e){if("_Task_nativeBinding"===e){t.root.cancel=t.root.callback(function(r){t.root=r,S(t)});break}if("_Task_receive"!==e)throw new Error(e);var n=t.mailbox;if(0===n.length)break;t.root=t.root.callback(n.shift()),++r}else t.stack={ctor:"_Task_onError",callback:t.root.callback,rest:t.stack},t.root=t.root.task,++r;else t.stack={ctor:"_Task_andThen",callback:t.root.callback,rest:t.stack},t.root=t.root.task,++r;else{for(;t.stack&&"_Task_andThen"===t.stack.ctor;)t.stack=t.stack.rest;if(null===t.stack)break;t.root=t.stack.callback(t.root.value),t.stack=t.stack.rest,++r}else{for(;t.stack&&"_Task_onError"===t.stack.ctor;)t.stack=t.stack.rest;if(null===t.stack)break;t.root=t.stack.callback(t.root.value),t.stack=t.stack.rest,++r}}return r<ye?r+1:(S(t),r)}function D(r,t){r.mailbox.push(t),S(r)}function O(r){return F(function(t){t(I(L(r)))})}function L(r){var t={ctor:"_Process",id:Wt(),root:r,stack:null,mailbox:[]};return S(t),t}function R(r){return{ctor:"_Task_receive",callback:r}}function P(r,t){return{ctor:"_Task_onError",callback:r,task:t}}function j(r,t){return{ctor:"_Task_andThen",callback:r,task:t}}function F(r){return{ctor:"_Task_nativeBinding",callback:r,cancel:null}}function U(r){return{ctor:"_Task_fail",value:r}}function I(r){return{ctor:"_Task_succeed",value:r}}function B(r,n){function o(r,t,e){for(var n=c(r,t,e),o=0;o<d.length;o++)u(d[o]);return d=null,_=u,v=c,n}function c(r,t,e){return s=t,p}function i(r,t,e){return v(r,t,e)}function a(r){d.push(r)}function u(r){for(var t=s;"[]"!==t.ctor;)n(t._0(r)),t=t._1}function f(t){var n=e(Dn,l,t);if("Err"===n.ctor)throw new Error("Trying to send an unexpected type of value through port `"+r+"`:\n"+n._0);_(n._0)}var d=[],s=te,l=De[r].converter,v=o,_=a,p=we(null);return De[r].init=p,De[r].onEffects=t(i),{send:f}}function $(r){function e(r,t,e){for(;"[]"!==t.ctor;){for(var n=c,o=i(t._0),u=0;u<n.length;u++)n[u](o);t=t._1}return a}function n(r){c.push(r)}function o(r){c=c.slice();var t=c.indexOf(r);t>=0&&c.splice(t,1)}var c=[],i=De[r].converter,a=we(null);return De[r].init=a,De[r].onEffects=t(e),{subscribe:n,unsubscribe:o}}function Q(r,t){return q(r),De[r]={tag:"cmd",cmdMap:Oe,converter:t,isForeign:!0},G(r)}function q(r){if(r in De)throw new Error("There can only be one port named `"+r+"`, but your program has multiple.")}function z(r,t,e){return e=e||{cmds:te,subs:te},r?(e.cmds=ee(t,e.cmds),e):(e.subs=ee(t,e.subs),e)}function K(r,t,n,o){function c(r){for(var t=n;t;)r=t.tagger(r),t=t.rest;return r}return e(r?De[t].cmdMap:De[t].subMap,c,o)}function W(r,t,e,n){switch(t.type){case"leaf":var o=t.home,c=K(r,o,n,t.value);return void(e[o]=z(r,c,e[o]));case"node":for(var i=t.branches;"[]"!==i.ctor;)W(r,i._0,e,n),i=i._1;return;case"map":return void W(r,t.tree,e,{tagger:t.tagger,rest:n})}}function J(r,t,e){var n={};W(!0,t,n,null),W(!1,e,n,null);for(var o in r){var c=o in n?n[o]:{cmds:te,subs:te};Me(r[o],{ctor:"fx",_0:c})}}function V(r){return{type:"node",branches:r}}function G(r){return function(t){return{type:"leaf",home:r,value:t}}}function H(r,t){function n(r){var c=Ce(function(e){return t(e,r)});return e(o,n,c)}var o=Ne,c=e(o,n,r);return Se(c)}function X(r,t){return Te(function(e){r.main(t),e(we(Qt))})}function Y(r,t){function e(r,t){if("self"===r.ctor)return n(u,c,r._0,t);var e=r._0;switch(i){case"cmd":return n(a,c,e.cmds,t);case"sub":return n(a,c,e.subs,t);case"fx":return o(a,c,e.cmds,e.subs,t)}}var c={main:t,self:void 0},i=r.tag,a=r.onEffects,u=r.onSelfMsg,f=H(r.init,e);return c.self=f,f}function Z(r,t){var e;for(var n in De){var o=De[n];o.isForeign&&(e=e||{},e[n]="cmd"===o.tag?$(n):B(n,t)),r[n]=Y(o,t)}return e}function rr(r,t,n,o){function c(r,o){return Te(function(c){var i=e(t,r,o);o=i._0,a(o);var f=i._1,d=n(o);J(u,f,d),c(we(o))})}function i(r){Me(d,r)}var a,u={},f=Te(function(t){var e=r._0;a=o(i,e);var c=r._1,f=n(e);J(u,c,f),t(we(e))}),d=H(f,c),s=Z(u,i);return s?{ports:s}:{}}function tr(r,t){return oe(t).join(r)}function er(r){return 0===r.length}function nr(r){return r}function or(r,t){var e=r.length;if(e!==t.length)return!1;for(var n=0;n<e;n++)if(!cr(r[n],t[n]))return!1;return!0}function cr(r,t){if(r===t)return!0;if(r.tag!==t.tag)return!1;switch(r.tag){case"succeed":case"fail":return r.msg===t.msg;case"bool":case"int":case"float":case"string":case"value":return!0;case"null":return r.value===t.value;case"list":case"array":case"maybe":case"key-value":return cr(r.decoder,t.decoder);case"field":return r.field===t.field&&cr(r.decoder,t.decoder);case"index":return r.index===t.index&&cr(r.decoder,t.decoder);case"map-many":return r.func===t.func&&or(r.decoders,t.decoders);case"andThen":return r.callback===t.callback&&cr(r.decoder,t.decoder);case"oneOf":return or(r.decoders,t.decoders)}}function ir(r,t){switch(r.tag){case"bool":return"boolean"==typeof t?pr(t):_r("a Bool",t);case"int":return"number"!=typeof t?_r("an Int",t):-2147483647<t&&t<2147483647&&(0|t)===t?pr(t):!isFinite(t)||t%1?_r("an Int",t):pr(t);case"float":return"number"==typeof t?pr(t):_r("a Float",t);case"string":return"string"==typeof t?pr(t):t instanceof String?pr(t+""):_r("a String",t);case"null":return null===t?pr(r.value):_r("null",t);case"value":return pr(t);case"list":if(!(t instanceof Array))return _r("a List",t);for(var e=te,n=t.length;n--;){var o=ir(r.decoder,t[n]);if("ok"!==o.tag)return lr(n,o);e=ee(o.value,e)}return pr(e);case"array":if(!(t instanceof Array))return _r("an Array",t);for(var c=t.length,i=new Array(c),n=c;n--;){var o=ir(r.decoder,t[n]);if("ok"!==o.tag)return lr(n,o);i[n]=o.value}return pr(Mt(i));case"maybe":var o=ir(r.decoder,t);return pr("ok"===o.tag?Zt(o.value):Yt);case"field":var a=r.field;if("object"!=typeof t||null===t||!(a in t))return _r("an object with a field named `"+a+"`",t);var o=ir(r.decoder,t[a]);return"ok"===o.tag?o:vr(a,o);case"index":var u=r.index;if(!(t instanceof Array))return _r("an array",t);if(u>=t.length)return _r("a longer array. Need index "+u+" but there are only "+t.length+" entries",t);var o=ir(r.decoder,t[u]);return"ok"===o.tag?o:lr(u,o);case"key-value":if("object"!=typeof t||null===t||t instanceof Array)return _r("an object",t);var f=te;for(var d in t){var o=ir(r.decoder,t[d]);if("ok"!==o.tag)return vr(d,o);var s=qt(d,o.value);f=ee(s,f)}return pr(f);case"map-many":for(var l=r.func,v=r.decoders,n=0;n<v.length;n++){var o=ir(v[n],t);if("ok"!==o.tag)return o;l=l(o.value)}return pr(l);case"andThen":var o=ir(r.decoder,t);return"ok"!==o.tag?o:ir(r.callback(o.value),t);case"oneOf":for(var _=[],p=r.decoders;"[]"!==p.ctor;){var o=ir(p._0,t);if("ok"===o.tag)return o;_.push(o),p=p._1}return sr(_);case"fail":return dr(r.msg);case"succeed":return pr(r.msg)}}function ar(r,t){var e=ir(r,t);return"ok"===e.tag?Ke(e.value):ze(fr(e))}function ur(r){return void 0===r?"undefined":JSON.stringify(r)}function fr(r){for(var t="_";r;)switch(r.tag){case"primitive":return"Expecting "+r.type+("_"===t?"":" at "+t)+" but instead got: "+ur(r.value);case"index":t+="["+r.index+"]",r=r.rest;break;case"field":t+="."+r.field,r=r.rest;break;case"oneOf":for(var e=r.problems,n=0;n<e.length;n++)e[n]=fr(e[n]);return"I ran into the following problems"+("_"===t?"":" at "+t)+":\n\n"+e.join("\n");case"fail":return"I ran into a `fail` decoder"+("_"===t?"":" at "+t)+": "+r.msg}}function dr(r){return{tag:"fail",msg:r}}function sr(r){return{tag:"oneOf",problems:r}}function lr(r,t){return{tag:"index",index:r,rest:t}}function vr(r,t){return{tag:"field",field:r,rest:t}}function lr(r,t){return{tag:"index",index:r,rest:t}}function _r(r,t){return{tag:"primitive",type:r,value:t}}function pr(r){return{tag:"ok",value:r}}function gr(r,t){return yr(r,[t])}function hr(r){return{ctor:"<decoder>",tag:"oneOf",decoders:r}}function mr(r,t){return{ctor:"<decoder>",tag:"andThen",decoder:t,callback:r}}function yr(r,t){return{ctor:"<decoder>",tag:"map-many",func:r,decoders:t}}function br(r,t){return{ctor:"<decoder>",tag:"field",field:r,decoder:t}}function kr(r){return{ctor:"<decoder>",tag:"null",value:r}}function wr(r,t){return{ctor:"<decoder>",tag:r,decoder:t}}function Er(r){return{ctor:"<decoder>",tag:r}}function Tr(r){return{ctor:"<decoder>",tag:"fail",msg:r}}function Nr(r){return{ctor:"<decoder>",tag:"succeed",msg:r}}function xr(r){return Cr(r,function(r){return r.focus(),Qt})}function Cr(r,t){return Te(function(e){Qn(function(){var n=document.getElementById(r);if(null===n)return void e(Ee({ctor:"NotFound",_0:r}));e(we(t(n)))})})}function Ar(r){return function(t,n,o){return Te(function(c){function i(r){var t=e(Dn,n,r);"Ok"===t.ctor&&Se(o(t._0))}return r.addEventListener(t,i),function(){r.removeEventListener(t,i)}})}}function Sr(r){return function(t){if("keydown"!==t.type||!t.metaKey||82!==t.which){for(var e="scroll"===t.type||"wheel"===t.type,n=t.target;null!==n;){if("elm-overlay-message-details"===n.className&&e)return;if(n===r&&!e)return;n=n.parentNode}t.stopPropagation(),t.preventDefault()}}}function Mr(r,t,e){for(var n=0;n<e.length;n++)document.body[r](e[n],t,!0)}function Dr(r,t,e){switch(e){case"Normal":return;case"Pause":return Mr(r,t,Zn);case"Message":return Mr(r,t,ro)}}function Or(r,t,e){var n,o=Sr(t),c="Normal",i=r.tagger,a=function(){};return function(t){var u=e(t),f=u._0.ctor;return r.tagger="Normal"===f?i:a,c!==f&&(Dr("removeEventListener",o,c),Dr("addEventListener",o,f),"Normal"===c&&(n=document.body.style.overflow,document.body.style.overflow="hidden"),"Normal"===f&&(document.body.style.overflow=n),c=f),u._1}}function Lr(r,t,e,n){function o(){t.doc=void 0,a.close()}var c=screen.width-900,i=screen.height-360,a=window.open("","","width=900,height=360,left="+c+",top="+i);Gn=a.document,t.doc=Gn,Gn.title="Debugger - "+r,Gn.body.style.margin="0",Gn.body.style.padding="0";var u=vt(e,n);return Gn.body.appendChild(u),Gn.addEventListener("keydown",function(r){r.metaKey&&82===r.which&&window.location.reload(),38===r.which&&(n.tagger({ctor:"Up"}),r.preventDefault()),40===r.which&&(n.tagger({ctor:"Down"}),r.preventDefault())}),window.addEventListener("unload",o),a.addEventListener("unload",function(){t.doc=void 0,window.removeEventListener("unload",o),n.tagger({ctor:"Close"})}),Gn=document,u}function Rr(r,t,e,n,o,c){var i,a;return function(r){if(r.isDebuggerOpen){if(!c.doc)return i=t(r),void(a=Lr(o,c,i,e));Gn=c.doc;var n=t(r),u=it(i,n);a=Gr(a,i,u,e),i=n,Gn=document}}}function Pr(r,t,e,n,o,c){return function(i,a){var u={tagger:i,parent:void 0},f={tagger:i,parent:void 0},d=n(a),s=vt(d,u);t.appendChild(s);var l=Ur(s,n,d,u),v=o(a)._1,_=vt(v,f);t.appendChild(_);var p=Or(u,_,o),g=Ur(_,p,v,f),h=Rr(a,c,f,t,r,e);return function(r){l(r),g(r),h(r)}}}function jr(r){return Te(function(t){var e=r.doc;if(e){var n=e.getElementsByClassName("debugger-sidebar-messages")[0];n&&(n.scrollTop=n.scrollHeight)}t(we(Qt))})}function Fr(r,t,e,n){t.fullscreen=function(t){var o={doc:void 0};return je(n(r.init,t,document.body),r.update(jr(o)),r.subscriptions,Pr(e,document.body,o,r.view,r.viewIn,r.viewOut))},t.embed=function(t,o){var c={doc:void 0};return je(n(r.init,o,t),r.update(jr(c)),r.subscriptions,Pr(e,t,c,r.view,r.viewIn,r.viewOut))}}function Ur(r,t,e,n){function o(){switch(i){case"NO_REQUEST":throw new Error("Unexpected draw callback.\nPlease report this to <https://github.com/elm-lang/virtual-dom/issues>.");case"PENDING_REQUEST":Yn(o),i="EXTRA_REQUEST";var e=t(c),u=it(a,e);return r=Gr(r,a,u,n),void(a=e);case"EXTRA_REQUEST":return void(i="NO_REQUEST")}}var c,i="NO_REQUEST",a=e;return function(r){"NO_REQUEST"===i&&Yn(o),i="PENDING_REQUEST",c=r}}function Ir(r,t){return function(e,n){var o={tagger:e,parent:void 0},c=t(n),i=vt(c,o);return r.appendChild(i),Ur(i,t,c,o)}}function Br(r,t,e,n){t.embed=function(t,e){for(;t.lastChild;)t.removeChild(t.lastChild);return je(n(r.init,e,t),r.update,r.subscriptions,Ir(t,r.view))},t.fullscreen=function(t){return je(n(r.init,t,document.body),r.update,r.subscriptions,Ir(document.body,r.view))}}function $r(r,t){throw t&&(t.innerHTML='<div style="padding-left:1em;"><h2 style="font-weight:normal;"><b>Oops!</b> Something went wrong when starting your Elm program.</h2><pre style="padding-left:1em;">'+r+"</pre></div>"),new Error(r)}function Qr(r,t){return function(n,o,c){if(void 0===r){var i="Are you trying to sneak a Never value into Elm? Trickster!\nIt looks like "+t+".main is defined with `programWithFlags` but has type `Program Never`.\nUse `program` instead if you do not want flags.";$r(i,c)}var a=e(vn,r,o);if("Ok"===a.ctor)return n(a._0);var i="Trying to initialize the `"+t+"` module with an unexpected flag.\nI tried to convert it to an Elm value, but ran into this problem:\n\n"+a._0;$r(i,c)}}function qr(t){return r(function(r,n){return function(o){return function(c,i,a){var u=t(o,i);void 0===a?Br(n,c,i,u):Fr(e(r,a,n),c,i,u)}}})}function zr(r,t){if(void 0!==r){for(var e=Gn.createDocumentFragment(),n=0;n<r.length;n++){var o=r[n],c=o.entry;e.appendChild("move"===c.tag?c.data:vt(c.vnode,t.eventNode))}return e}}function Kr(r,t){var e=t.data,n=zr(e.endInserts,t);r=Vr(r,e.patches);for(var o=e.inserts,c=0;c<o.length;c++){var i=o[c],a=i.entry,u="move"===a.tag?a.data:vt(a.vnode,t.eventNode);r.insertBefore(u,r.childNodes[i.index])}return void 0!==n&&r.appendChild(n),r}function Wr(r,t,e){var n=r.parentNode,o=vt(t,e);return void 0===o.elm_event_node_ref&&(o.elm_event_node_ref=r.elm_event_node_ref),n&&o!==r&&n.replaceChild(o,r),o}function Jr(r,t){switch(t.type){case"p-redraw":return Wr(r,t.data,t.eventNode);case"p-facts":return lt(r,t.eventNode,t.data),r;case"p-text":return r.replaceData(0,r.length,t.data),r;case"p-thunk":return Vr(r,t.data);case"p-tagger":return void 0!==r.elm_event_node_ref?r.elm_event_node_ref.tagger=t.data:r.elm_event_node_ref={tagger:t.data,parent:t.eventNode},r;case"p-remove-last":for(var e=t.data;e--;)r.removeChild(r.lastChild);return r;case"p-append":for(var n=t.data,e=0;e<n.length;e++)r.appendChild(vt(n[e],t.eventNode));return r;case"p-remove":var o=t.data;if(void 0===o)return r.parentNode.removeChild(r),r;var c=o.entry;return void 0!==c.index&&r.parentNode.removeChild(r),c.data=Vr(r,o.patches),r;case"p-reorder":return Kr(r,t);case"p-custom":var i=t.data;return i.applyPatch(r,i.data);default:throw new Error("Ran into an unknown patch!")}}function Vr(r,t){for(var e=0;e<t.length;e++){var n=t[e],o=n.domNode,c=Jr(o,n);o===r&&(r=c)}return r}function Gr(r,t,e,n){return 0===e.length?r:(Xr(r,t,e,n),Vr(r,e))}function Hr(r,t,e,n,o,c,i){for(var a=e[n],u=a.index;u===o;){var f=a.type;if("p-thunk"===f)Xr(r,t.node,a.data,i);else if("p-reorder"===f){a.domNode=r,a.eventNode=i;var d=a.data.patches;d.length>0&&Hr(r,t,d,0,o,c,i)}else if("p-remove"===f){a.domNode=r,a.eventNode=i;var s=a.data;if(void 0!==s){s.entry.data=r;var d=s.patches;d.length>0&&Hr(r,t,d,0,o,c,i)}}else a.domNode=r,a.eventNode=i;if(n++,!(a=e[n])||(u=a.index)>c)return n}switch(t.type){case"tagger":for(var l=t.node;"tagger"===l.type;)l=l.node;return Hr(r,l,e,n,o+1,c,r.elm_event_node_ref);case"node":for(var v=t.children,_=r.childNodes,p=0;p<v.length;p++){o++;var g=v[p],h=o+(g.descendantsCount||0);if(o<=u&&u<=h&&(n=Hr(_[p],g,e,n,o,h,i),!(a=e[n])||(u=a.index)>c))return n;o=h}return n;case"keyed-node":for(var v=t.children,_=r.childNodes,p=0;p<v.length;p++){o++;var g=v[p]._1,h=o+(g.descendantsCount||0);if(o<=u&&u<=h&&(n=Hr(_[p],g,e,n,o,h,i),!(a=e[n])||(u=a.index)>c))return n;o=h}return n;case"text":case"thunk":throw new Error("should never traverse `text` or `thunk` nodes like this")}}function Xr(r,t,e,n){Hr(r,t,e,0,0,t.descendantsCount,n)}function Yr(r,t,e,n,o){var c=r[e];if(void 0===c){var i=ct("p-remove",o,void 0);return t.push(i),void(r[e]={tag:"remove",vnode:n,index:o,data:i})}if("insert"===c.tag){c.tag="move";var a=[];ot(n,c.vnode,a,o);var i=ct("p-remove",o,{patches:a,entry:c});return void t.push(i)}Yr(r,t,e+Hn,n,o)}function Zr(r,t,e,n,o,c){var i=r[e];if(void 0===i)return i={tag:"insert",vnode:n,index:o,data:void 0},c.push({index:o,entry:i}),void(r[e]=i);if("remove"===i.tag){c.push({index:o,entry:i}),i.tag="move";var a=[];return ot(i.vnode,n,a,i.index),i.index=o,void(i.data.data={patches:a,entry:i})}Zr(r,t,e+Hn,n,o,c)}function rt(r,t,e,n){for(var o=[],c={},i=[],a=r.children,u=t.children,f=a.length,d=u.length,s=0,l=0,v=n;s<f&&l<d;){var _=a[s],p=u[l],g=_._0,h=p._0,m=_._1,y=p._1;if(g!==h){var b=s+1<f,k=l+1<d;if(b)var w=a[s+1],E=w._0,T=w._1,N=h===E;if(k)var x=u[l+1],C=x._0,A=x._1,S=g===C;if(b&&k&&S&&N)v++,ot(m,A,o,v),Zr(c,o,g,y,l,i),v+=m.descendantsCount||0,v++,Yr(c,o,g,T,v),v+=T.descendantsCount||0,s+=2,l+=2;else if(k&&S)v++,Zr(c,o,h,y,l,i),ot(m,A,o,v),v+=m.descendantsCount||0,s+=1,l+=2;else if(b&&N)v++,Yr(c,o,g,m,v),v+=m.descendantsCount||0,v++,ot(T,y,o,v),v+=T.descendantsCount||0,s+=2,l+=1;else{if(!b||!k||E!==C)break;v++,Yr(c,o,g,m,v),Zr(c,o,h,y,l,i),v+=m.descendantsCount||0,v++,ot(T,A,o,v),v+=T.descendantsCount||0,s+=2,l+=2}}else v++,ot(m,y,o,v),v+=m.descendantsCount||0,s++,l++}for(;s<f;){v++;var _=a[s],m=_._1;Yr(c,o,_._0,m,v),v+=m.descendantsCount||0,s++}for(var M;l<d;){M=M||[];var p=u[l];Zr(c,o,p._0,p._1,void 0,M),l++}(o.length>0||i.length>0||void 0!==M)&&e.push(ct("p-reorder",n,{patches:o,inserts:i,endInserts:M}))}function tt(r,t,e,n){var o=r.children,c=t.children,i=o.length,a=c.length;i>a?e.push(ct("p-remove-last",n,i-a)):i<a&&e.push(ct("p-append",n,c.slice(i)));for(var u=n,f=i<a?i:a,d=0;d<f;d++){u++;var s=o[d];ot(s,c[d],e,u),u+=s.descendantsCount||0}}function et(r,t,e){var n;for(var o in r)if(o!==Kn&&o!==Wn&&o!==Jn&&o!==Vn)if(o in t){var c=r[o],i=t[o];c===i&&"value"!==o||e===Wn&&_t(c,i)||(n=n||{},n[o]=i)}else n=n||{},n[o]=void 0===e?"string"==typeof r[o]?"":null:e===Kn?"":e===Wn||e===Jn?void 0:{namespace:r[o].namespace,value:void 0};else{var a=et(r[o],t[o]||{},o);a&&(n=n||{},n[o]=a)}for(var u in t)u in r||(n=n||{},n[u]=t[u]);return n}function nt(r,t){for(var e=0;e<r.length;e++)if(r[e]!==t[e])return!1;return!0}function ot(r,t,e,n){if(r!==t){var o=r.type,c=t.type;if(o!==c)return void e.push(ct("p-redraw",n,t));switch(c){case"thunk":for(var i=r.args,a=t.args,u=i.length,f=r.func===t.func&&u===a.length;f&&u--;)f=i[u]===a[u];if(f)return void(t.node=r.node);t.node=t.thunk();var d=[];return ot(r.node,t.node,d,0),void(d.length>0&&e.push(ct("p-thunk",n,d)));case"tagger":for(var s=r.tagger,l=t.tagger,v=!1,_=r.node;"tagger"===_.type;)v=!0,"object"!=typeof s?s=[s,_.tagger]:s.push(_.tagger),_=_.node;for(var p=t.node;"tagger"===p.type;)v=!0,"object"!=typeof l?l=[l,p.tagger]:l.push(p.tagger),p=p.node;return v&&s.length!==l.length?void e.push(ct("p-redraw",n,t)):((v?nt(s,l):s===l)||e.push(ct("p-tagger",n,l)),void ot(_,p,e,n+1));case"text":if(r.text!==t.text)return void e.push(ct("p-text",n,t.text));return;case"node":if(r.tag!==t.tag||r.namespace!==t.namespace)return void e.push(ct("p-redraw",n,t));var g=et(r.facts,t.facts);return void 0!==g&&e.push(ct("p-facts",n,g)),void tt(r,t,e,n);case"keyed-node":if(r.tag!==t.tag||r.namespace!==t.namespace)return void e.push(ct("p-redraw",n,t));var g=et(r.facts,t.facts);return void 0!==g&&e.push(ct("p-facts",n,g)),void rt(r,t,e,n);case"custom":if(r.impl!==t.impl)return void e.push(ct("p-redraw",n,t));var g=et(r.facts,t.facts);void 0!==g&&e.push(ct("p-facts",n,g));var h=t.impl.diff(r,t);if(h)return void e.push(ct("p-custom",n,h));return}}}function ct(r,t,e){return{index:t,type:r,data:e,domNode:void 0,eventNode:void 0}}function it(r,t){var e=[];return ot(r,t,e,0),e}function at(r,t){for(var e in t){var n=t[e],o=n.namespace,c=n.value;void 0===c?r.removeAttributeNS(o,e):r.setAttributeNS(o,e,c)}}function ut(r,t){for(var e in t){var n=t[e];void 0===n?r.removeAttribute(e):r.setAttribute(e,n)}}function ft(r,t){function n(t){var o=n.info,c=e(vn,o.decoder,t);if("Ok"===c.ctor){var i=o.options;i.stopPropagation&&t.stopPropagation(),i.preventDefault&&t.preventDefault();for(var a=c._0,u=r;u;){var f=u.tagger;if("function"==typeof f)a=f(a);else for(var d=f.length;d--;)a=f[d](a);u=u.parent}}}return n.info=t,n}function dt(r,t,e){var n=r.elm_handlers||{};for(var o in e){var c=n[o],i=e[o];if(void 0===i)r.removeEventListener(o,c),n[o]=void 0;else if(void 0===c){var c=ft(t,i);r.addEventListener(o,c),n[o]=c}else c.info=i}r.elm_handlers=n}function st(r,t){var e=r.style;for(var n in t)e[n]=t[n]}function lt(r,t,e){for(var n in e){var o=e[n];switch(n){case Kn:st(r,o);break;case Wn:dt(r,t,o);break;case Jn:ut(r,o);break;case Vn:at(r,o);break;case"value":r[n]!==o&&(r[n]=o);break;default:r[n]=o}}}function vt(r,t){switch(r.type){case"thunk":return r.node||(r.node=r.thunk()),vt(r.node,t);case"tagger":for(var e=r.node,n=r.tagger;"tagger"===e.type;)"object"!=typeof n?n=[n,e.tagger]:n.push(e.tagger),e=e.node;var o={tagger:n,parent:t},c=vt(e,o);return c.elm_event_node_ref=o,c;case"text":return Gn.createTextNode(r.text);case"node":var c=r.namespace?Gn.createElementNS(r.namespace,r.tag):Gn.createElement(r.tag);lt(c,t,r.facts);for(var i=r.children,a=0;a<i.length;a++)c.appendChild(vt(i[a],t));return c;case"keyed-node":var c=r.namespace?Gn.createElementNS(r.namespace,r.tag):Gn.createElement(r.tag);lt(c,t,r.facts);for(var i=r.children,a=0;a<i.length;a++)c.appendChild(vt(i[a]._1,t));return c;case"custom":var c=r.impl.render(r.model);return lt(c,t,r.facts),c}}function _t(r,t){return(r.options===t.options||r.options.stopPropagation===t.options.stopPropagation&&r.options.preventDefault===t.options.preventDefault)&&Tn(r.decoder,t.decoder)}function pt(r,t,e){return{key:Wn,realKey:r,value:{options:t,decoder:e}}}function gt(r,t){return{key:r,value:t}}function ht(r){return{key:Kn,value:r}}function mt(r){for(var t,e={};"[]"!==r.ctor;){var n=r._0,o=n.key;if(o===Jn||o===Vn||o===Wn){var c=e[o]||{};c[n.realKey]=n.value,e[o]=c}else if(o===Kn){for(var i=e[o]||{},a=n.value;"[]"!==a.ctor;){var u=a._0;i[u._0]=u._1,a=a._1}e[o]=i}else if("namespace"===o)t=n.value;else if("className"===o){var f=e[o];e[o]=void 0===f?n.value:f+" "+n.value}else e[o]=n.value;r=r._1}return{facts:e,namespace:t}}function yt(r,t,n){return kt(r,[t,n],function(){return e(r,t,n)})}function bt(r,t){return kt(r,[t],function(){return r(t)})}function kt(r,t,e){return{type:"thunk",func:r,args:t,thunk:e,node:void 0}}function wt(r,t,e){for(var n=mt(t),o=n.namespace,c=n.facts,i=[],a=0;"[]"!==e.ctor;){var u=e._0;a+=u._1.descendantsCount||0,i.push(u),e=e._1}return a+=i.length,{type:"keyed-node",tag:r,facts:c,children:i,namespace:o,descendantsCount:a}}function Et(r,t,e){for(var n=mt(t),o=n.namespace,c=n.facts,i=[],a=0;"[]"!==e.ctor;){var u=e._0;a+=u.descendantsCount||0,i.push(u),e=e._1}return a+=i.length,{type:"node",tag:r,facts:c,children:i,namespace:o,descendantsCount:a}}function Tt(t){return r(function(r,e){return Et(t,r,e)})}function Nt(r){return{type:"text",text:r}}var xt=32,Ct={ctor:"_Array",height:0,table:[]},At=s,St=u,Mt=i,Dt={},Ot=r(v),Lt=r(l),Rt=(Math.PI,Math.E,Math.cos,Math.sin,Math.tan,Math.acos,Math.asin,Math.atan,Math.atan2,Math.sqrt,Math.ceil,Math.floor,Math.round,isNaN,-1),Pt=0,jt=1,Ft={ctor:"_Tuple0"},Ut=0,It={ctor:"[]"},Bt=T,$t=w,Qt=Ft,qt=k,zt=b,Kt=m,Wt=y,Jt=r(g),Vt=p,Gt=Gt||{};Gt["<|"]=r(function(r,t){return r(t)});var Gt=Gt||{};Gt["|>"]=r(function(r,t){return t(r)});var Gt=Gt||{};Gt[">>"]=t(function(r,t,e){return t(r(e))});var Gt=Gt||{};Gt["<<"]=t(function(r,t,e){return r(t(e))});var Gt=Gt||{};Gt["++"]=Jt;var Ht=Vt,Gt=Gt||{};Gt["||"]=Dt.or;var Gt=Gt||{};Gt["&&"]=Dt.and;var Gt=Gt||{};Gt[">="]=Dt.ge;var Gt=Gt||{};Gt["<="]=Dt.le;var Gt=Gt||{};Gt[">"]=Dt.gt;var Gt=Gt||{};Gt["<"]=Dt.lt;var Gt=Gt||{};Gt["/="]=Dt.neq;var Gt=Gt||{};Gt["=="]=Dt.eq;var Gt=Gt||{};Gt["^"]=Dt.exp;var Gt=Gt||{};Gt["%"]=Lt;var Gt=Gt||{};Gt["//"]=Ot;var Gt=Gt||{};Gt["/"]=Dt.floatDiv;var Gt=Gt||{};Gt["*"]=Dt.mul;var Gt=Gt||{};Gt["-"]=Dt.sub;var Gt=Gt||{};Gt["+"]=Dt.add;var Xt=r(function(r,t){var e=t;return"Just"===e.ctor?e._0:r}),Yt={ctor:"Nothing"},Zt=function(r){return{ctor:"Just",_0:r}},re={ctor:"[]"},te=re,ee=C,ne=r(C),oe=x,ce=t(N),ie=r(function(r,t){for(;;){var e=t;if("[]"===e.ctor)return!1;if(r(e._0))return!0;var n=r,o=e._1;r=n,t=o}}),ae=r(function(r,t){return!e(ie,function(t){return!r(t)},t)}),ue=ce,fe=t(function(r,t,n){for(;;){var o=n;if("[]"===o.ctor)return t;var c=r,i=e(r,o._0,t),a=o._1;r=c,t=i,n=a}}),de=function(t){return n(fe,r(function(r,t){return t+1}),0,t)},se=function(r){return"[]"===r.ctor},le=le||{};le["::"]=ne;var ve=r(function(t,e){return n(ue,r(function(r,e){return{ctor:"::",_0:t(r),_1:e}}),{ctor:"[]"},e)}),_e=r(function(t,e){return n(ue,r(function(r,e){return t(r)?{ctor:"::",_0:r,_1:e}:e}),{ctor:"[]"},e)}),pe=At,ge=function(r){return r.charCodeAt(0)},he=ge,me=t(function(r,t,e){var n=he(e);return $t(n,he(r))>-1&&$t(n,he(t))<1}),ye=(e(me,zt("A"),zt("Z")),e(me,zt("a"),zt("z")),e(me,zt("0"),zt("9")),e(me,zt("0"),zt("7")),1e4),be=!1,ke=[],we=I,Ee=U,Te=F,Ne=r(j),xe=r(P),Ce=R,Ae=O,Se=L,Me=D,De={},Oe=r(function(r,t){return t}),Le=r(X),Re=De,Pe=Q,je=rr,Fe=G,Ue=V,Ie=Ue,Be=Be||{};Be["!"]=r(function(r,t){return{ctor:"_Tuple2",_0:r,_1:Ie(t)}});var $e=Ue,Qe=$e({ctor:"[]"}),qe=Le,ze=function(r){return{ctor:"Err",_0:r}},Ke=function(r){return{ctor:"Ok",_0:r}},We=xe,Je=Ne,Ve=r(function(r,t){var n=t;return Ae(e(Je,qe(r),n._0))}),Ge=we,He=r(function(r,t){return e(Je,function(t){return Ge(r(t))},t)}),Xe=t(function(r,t,n){return e(Je,function(t){return e(Je,function(n){return Ge(e(r,t,n))},n)},t)}),Ye=function(t){var e=t;return"[]"===e.ctor?Ge({ctor:"[]"}):n(Xe,r(function(r,t){return{ctor:"::",_0:r,_1:t}}),e._0,Ye(e._1))},Ze=t(function(r,t,n){return e(He,function(r){return{ctor:"_Tuple0"}},Ye(e(ve,Ve(r),t)))}),rn=Ge({ctor:"_Tuple0"}),tn=t(function(r,t,e){return Ge({ctor:"_Tuple0"})}),en=Fe("Task"),nn=function(r){return{ctor:"Perform",_0:r}},on=r(function(r,t){return en(nn(e(We,function(t){return Ge(r(ze(t)))},e(Je,function(t){return Ge(r(Ke(t)))},t))))}),cn=r(function(r,t){return nn(e(He,r,t._0))});Re.Task={pkg:"elm-lang/core",init:rn,onEffects:Ze,onSelfMsg:tn,tag:"cmd",cmdMap:cn};var an=er,un=r(tr),fn=un,dn=an,sn=t(function(r,t,e){for(;;){var o=e;if("RBEmpty_elm_builtin"===o.ctor)return t;var c=r,i=n(r,o._1,o._2,n(sn,r,t,o._4)),a=o._3;r=c,t=i,e=a}}),ln=function(r){return n(sn,t(function(r,t,e){return{ctor:"::",_0:{ctor:"_Tuple2",_0:r,_1:t},_1:e}}),{ctor:"[]"},r)},vn=r(ar),_n=kr,pn=Er,gn=r(wr),hn=r(br),mn=r(gr),yn=r(mr),bn=Tr,kn=Nr,wn=hr,En=nr,Tn=cr,Nn=En,xn=En,Cn=_n,An=yn,Sn=bn,Mn=kn,Dn=vn,On=mn,Ln=wn,Rn=hn,Pn=r(function(r,t){
return n(ue,Rn,t,r)}),jn=pn("int"),Fn=pn("bool"),Un=pn("string"),In=function(r){return r._1},Bn=function(r){return r._0},$n={addEventListener:function(){},removeEventListener:function(){}},Qn=("undefined"!=typeof document&&document,"undefined"!=typeof window&&window,"undefined"!=typeof requestAnimationFrame?requestAnimationFrame:function(r){r()}),qn=xr,zn=qn,Kn="STYLE",Wn="EVENT",Jn="ATTR",Vn="ATTR_NS",Gn="undefined"!=typeof document?document:{},Hn="_elmW6BL",Xn=qr(Qr),Yn="undefined"!=typeof requestAnimationFrame?requestAnimationFrame:function(r){setTimeout(r,1e3/60)},Zn=["click","dblclick","mousemove","mouseup","mousedown","mouseenter","mouseleave","touchstart","touchend","touchcancel","touchmove","pointerdown","pointerup","pointerover","pointerout","pointerenter","pointerleave","pointermove","pointercancel","dragstart","drag","dragend","dragenter","dragover","dragleave","drop","keyup","keydown","keypress","input","change","focus","blur"],ro=Zn.concat("wheel","scroll"),to=Tt,eo=Nt,no=t(pt),oo=ht,co=r(gt),io=r(bt),ao=t(yt),uo=t(wt),fo=Xn,so=function(r){return e(fo,void 0,r)},lo=uo,vo=ao,_o=io,po={stopPropagation:!1,preventDefault:!1},go=no,ho=r(function(r,t){return n(go,r,po,t)}),mo=oo,yo=co,bo=eo,ko=to,wo=so,Eo=bo,To=ko,No=To("section"),xo=To("h1"),Co=To("header"),Ao=To("footer"),So=To("p"),Mo=To("ul"),Do=To("li"),Oo=To("div"),Lo=To("a"),Ro=To("strong"),Po=To("span"),jo=To("label"),Fo=To("input"),Uo=To("button"),Io=yo,Bo=r(function(r,t){return e(Io,r,xn(t))}),$o=function(r){return e(Bo,"className",r)},Qo=function(r){return e(Bo,"id",r)},qo=function(r){return e(Bo,"type",r)},zo=function(r){return e(Bo,"value",r)},Ko=function(r){return e(Bo,"placeholder",r)},Wo=function(r){return e(Bo,"name",r)},Jo=function(r){return e(Bo,"htmlFor",r)},Vo=function(r){return e(Bo,"href",r)},Go=r(function(r,t){return e(Io,r,Nn(t))}),Ho=function(r){return e(Go,"hidden",r)},Xo=function(r){return e(Go,"checked",r)},Yo=function(r){return e(Go,"autofocus",r)},Zo=function(r){return $o(e(fn," ",e(ve,Bn,e(_e,In,r))))},rc=mo,tc=e(Rn,"keyCode",jn),ec=(e(Pn,{ctor:"::",_0:"target",_1:{ctor:"::",_0:"checked",_1:{ctor:"[]"}}},Fn),e(Pn,{ctor:"::",_0:"target",_1:{ctor:"::",_0:"value",_1:{ctor:"[]"}}},Un)),nc=ho,oc=function(r){return e(nc,"blur",Mn(r))},cc=function(r){return e(nc,"input",e(On,r,ec))},ic=function(r){return e(nc,"dblclick",Mn(r))},ac=function(r){return e(nc,"click",Mn(r))},uc=lo,fc=uc("ul"),dc=vo,sc=_o,lc=e(Ao,{ctor:"::",_0:$o("info"),_1:{ctor:"[]"}},{ctor:"::",_0:e(So,{ctor:"[]"},{ctor:"::",_0:Eo("Double-click to edit a todo"),_1:{ctor:"[]"}}),_1:{ctor:"::",_0:e(So,{ctor:"[]"},{ctor:"::",_0:Eo("Written by "),_1:{ctor:"::",_0:e(Lo,{ctor:"::",_0:Vo("https://github.com/evancz"),_1:{ctor:"[]"}},{ctor:"::",_0:Eo("Evan Czaplicki"),_1:{ctor:"[]"}}),_1:{ctor:"[]"}}}),_1:{ctor:"::",_0:e(So,{ctor:"[]"},{ctor:"::",_0:Eo("Part of "),_1:{ctor:"::",_0:e(Lo,{ctor:"::",_0:Vo("http://todomvc.com"),_1:{ctor:"[]"}},{ctor:"::",_0:Eo("TodoMVC"),_1:{ctor:"[]"}}),_1:{ctor:"[]"}}}),_1:{ctor:"[]"}}}}),vc=function(r){var t=Bt(r,1)?" item":" items";return e(Po,{ctor:"::",_0:$o("todo-count"),_1:{ctor:"[]"}},{ctor:"::",_0:e(Ro,{ctor:"[]"},{ctor:"::",_0:Eo(Ht(r)),_1:{ctor:"[]"}}),_1:{ctor:"::",_0:Eo(e(Gt["++"],t," left")),_1:{ctor:"[]"}}})},_c=function(r){return e(nc,"keydown",e(An,function(t){return Bt(t,13)?Mn(r):Sn("not ENTER")},tc))},pc=r(function(r,t){return{description:r,completed:!1,editing:!1,id:t}}),gc={entries:{ctor:"[]"},visibility:"All",field:"",uid:0},hc=function(r){return e(Be["!"],e(Xt,gc,r),{ctor:"[]"})},mc=Pe("setStorage",function(r){return{entries:oe(r.entries).map(function(r){return{description:r.description,completed:r.completed,editing:r.editing,id:r.id}}),field:r.field,uid:r.uid,visibility:r.visibility}}),yc=function(r){return{ctor:"ChangeVisibility",_0:r}},bc=t(function(r,t,n){return e(Do,{ctor:"::",_0:ac(yc(t)),_1:{ctor:"[]"}},{ctor:"::",_0:e(Lo,{ctor:"::",_0:Vo(r),_1:{ctor:"::",_0:Zo({ctor:"::",_0:{ctor:"_Tuple2",_0:"selected",_1:Bt(t,n)},_1:{ctor:"[]"}}),_1:{ctor:"[]"}}},{ctor:"::",_0:Eo(t),_1:{ctor:"[]"}}),_1:{ctor:"[]"}})}),kc=function(r){return e(Mo,{ctor:"::",_0:$o("filters"),_1:{ctor:"[]"}},{ctor:"::",_0:n(bc,"#/","All",r),_1:{ctor:"::",_0:Eo(" "),_1:{ctor:"::",_0:n(bc,"#/active","Active",r),_1:{ctor:"::",_0:Eo(" "),_1:{ctor:"::",_0:n(bc,"#/completed","Completed",r),_1:{ctor:"[]"}}}}}})},wc=function(r){return{ctor:"CheckAll",_0:r}},Ec=r(function(r,t){return{ctor:"Check",_0:r,_1:t}}),Tc={ctor:"DeleteComplete"},Nc=function(r){return e(Uo,{ctor:"::",_0:$o("clear-completed"),_1:{ctor:"::",_0:Ho(Bt(r,0)),_1:{ctor:"::",_0:ac(Tc),_1:{ctor:"[]"}}}},{ctor:"::",_0:Eo(e(Gt["++"],"Clear completed (",e(Gt["++"],Ht(r),")"))),_1:{ctor:"[]"}})},xc=r(function(r,t){var n=de(e(_e,function(r){return r.completed},t)),o=de(t)-n;return e(Ao,{ctor:"::",_0:$o("footer"),_1:{ctor:"::",_0:Ho(se(t)),_1:{ctor:"[]"}}},{ctor:"::",_0:e(sc,vc,o),_1:{ctor:"::",_0:e(sc,kc,r),_1:{ctor:"::",_0:e(sc,Nc,n),_1:{ctor:"[]"}}}})}),Cc=function(r){return{ctor:"Delete",_0:r}},Ac={ctor:"Add"},Sc=r(function(r,t){return{ctor:"UpdateEntry",_0:r,_1:t}}),Mc=r(function(r,t){return{ctor:"EditingEntry",_0:r,_1:t}}),Dc=function(r){return e(Do,{ctor:"::",_0:Zo({ctor:"::",_0:{ctor:"_Tuple2",_0:"completed",_1:r.completed},_1:{ctor:"::",_0:{ctor:"_Tuple2",_0:"editing",_1:r.editing},_1:{ctor:"[]"}}}),_1:{ctor:"[]"}},{ctor:"::",_0:e(Oo,{ctor:"::",_0:$o("view"),_1:{ctor:"[]"}},{ctor:"::",_0:e(Fo,{ctor:"::",_0:$o("toggle"),_1:{ctor:"::",_0:qo("checkbox"),_1:{ctor:"::",_0:Xo(r.completed),_1:{ctor:"::",_0:ac(e(Ec,r.id,!r.completed)),_1:{ctor:"[]"}}}}},{ctor:"[]"}),_1:{ctor:"::",_0:e(jo,{ctor:"::",_0:ic(e(Mc,r.id,!0)),_1:{ctor:"[]"}},{ctor:"::",_0:Eo(r.description),_1:{ctor:"[]"}}),_1:{ctor:"::",_0:e(Uo,{ctor:"::",_0:$o("destroy"),_1:{ctor:"::",_0:ac(Cc(r.id)),_1:{ctor:"[]"}}},{ctor:"[]"}),_1:{ctor:"[]"}}}}),_1:{ctor:"::",_0:e(Fo,{ctor:"::",_0:$o("edit"),_1:{ctor:"::",_0:zo(r.description),_1:{ctor:"::",_0:Wo("title"),_1:{ctor:"::",_0:Qo(e(Gt["++"],"todo-",Ht(r.id))),_1:{ctor:"::",_0:cc(Sc(r.id)),_1:{ctor:"::",_0:oc(e(Mc,r.id,!1)),_1:{ctor:"::",_0:_c(e(Mc,r.id,!1)),_1:{ctor:"[]"}}}}}}}},{ctor:"[]"}),_1:{ctor:"[]"}}})},Oc=function(r){return{ctor:"_Tuple2",_0:Ht(r.id),_1:e(sc,Dc,r)}},Lc=r(function(r,t){var n=se(t)?"hidden":"visible",o=e(ae,function(r){return r.completed},t),c=function(t){switch(r){case"Completed":return t.completed;case"Active":return!t.completed;default:return!0}};return e(No,{ctor:"::",_0:$o("main"),_1:{ctor:"::",_0:rc({ctor:"::",_0:{ctor:"_Tuple2",_0:"visibility",_1:n},_1:{ctor:"[]"}}),_1:{ctor:"[]"}}},{ctor:"::",_0:e(Fo,{ctor:"::",_0:$o("toggle-all"),_1:{ctor:"::",_0:qo("checkbox"),_1:{ctor:"::",_0:Wo("toggle"),_1:{ctor:"::",_0:Xo(o),_1:{ctor:"::",_0:ac(wc(!o)),_1:{ctor:"[]"}}}}}},{ctor:"[]"}),_1:{ctor:"::",_0:e(jo,{ctor:"::",_0:Jo("toggle-all"),_1:{ctor:"[]"}},{ctor:"::",_0:Eo("Mark all as complete"),_1:{ctor:"[]"}}),_1:{ctor:"::",_0:e(fc,{ctor:"::",_0:$o("todo-list"),_1:{ctor:"[]"}},e(ve,Oc,e(_e,c,t))),_1:{ctor:"[]"}}}})}),Rc=function(r){return{ctor:"UpdateField",_0:r}},Pc=function(r){return e(Co,{ctor:"::",_0:$o("header"),_1:{ctor:"[]"}},{ctor:"::",_0:e(xo,{ctor:"[]"},{ctor:"::",_0:Eo("todos"),_1:{ctor:"[]"}}),_1:{ctor:"::",_0:e(Fo,{ctor:"::",_0:$o("new-todo"),_1:{ctor:"::",_0:Ko("What needs to be done?"),_1:{ctor:"::",_0:Yo(!0),_1:{ctor:"::",_0:zo(r),_1:{ctor:"::",_0:Wo("newTodo"),_1:{ctor:"::",_0:cc(Rc),_1:{ctor:"::",_0:_c(Ac),_1:{ctor:"[]"}}}}}}}},{ctor:"[]"}),_1:{ctor:"[]"}}})},jc=function(r){return e(Oo,{ctor:"::",_0:$o("todomvc-wrapper"),_1:{ctor:"::",_0:rc({ctor:"::",_0:{ctor:"_Tuple2",_0:"visibility",_1:"hidden"},_1:{ctor:"[]"}}),_1:{ctor:"[]"}}},{ctor:"::",_0:e(No,{ctor:"::",_0:$o("todoapp"),_1:{ctor:"[]"}},{ctor:"::",_0:e(sc,Pc,r.field),_1:{ctor:"::",_0:n(dc,Lc,r.visibility,r.entries),_1:{ctor:"::",_0:n(dc,xc,r.visibility,r.entries),_1:{ctor:"[]"}}}}),_1:{ctor:"::",_0:lc,_1:{ctor:"[]"}}})},Fc={ctor:"NoOp"},Uc=r(function(r,t){var n=r;switch(n.ctor){case"NoOp":return e(Be["!"],t,{ctor:"[]"});case"Add":return e(Be["!"],Kt(t,{uid:t.uid+1,field:"",entries:dn(t.field)?t.entries:e(Gt["++"],t.entries,{ctor:"::",_0:e(pc,t.field,t.uid),_1:{ctor:"[]"}})}),{ctor:"[]"});case"UpdateField":return e(Be["!"],Kt(t,{field:n._0}),{ctor:"[]"});case"EditingEntry":var o=n._0,c=zn(e(Gt["++"],"todo-",Ht(o))),i=function(r){return Bt(r.id,o)?Kt(r,{editing:n._1}):r};return e(Be["!"],Kt(t,{entries:e(ve,i,t.entries)}),{ctor:"::",_0:e(on,function(r){return Fc},c),_1:{ctor:"[]"}});case"UpdateEntry":var i=function(r){return Bt(r.id,n._0)?Kt(r,{description:n._1}):r};return e(Be["!"],Kt(t,{entries:e(ve,i,t.entries)}),{ctor:"[]"});case"Delete":return e(Be["!"],Kt(t,{entries:e(_e,function(r){return!Bt(r.id,n._0)},t.entries)}),{ctor:"[]"});case"DeleteComplete":return e(Be["!"],Kt(t,{entries:e(_e,function(r){return!function(r){return r.completed}(r)},t.entries)}),{ctor:"[]"});case"Check":var i=function(r){return Bt(r.id,n._0)?Kt(r,{completed:n._1}):r};return e(Be["!"],Kt(t,{entries:e(ve,i,t.entries)}),{ctor:"[]"});case"CheckAll":var i=function(r){return Kt(r,{completed:n._0})};return e(Be["!"],Kt(t,{entries:e(ve,i,t.entries)}),{ctor:"[]"});default:return e(Be["!"],Kt(t,{visibility:n._0}),{ctor:"[]"})}}),Ic=r(function(r,t){var n=e(Uc,r,t),o=n._0,c=n._1;return{ctor:"_Tuple2",_0:o,_1:Ie({ctor:"::",_0:mc(o),_1:{ctor:"::",_0:c,_1:{ctor:"[]"}}})}}),Bc=wo({init:hc,view:jc,update:Ic,subscriptions:function(r){return Qe}})(Ln({ctor:"::",_0:Cn(Yt),_1:{ctor:"::",_0:e(On,Zt,e(An,function(r){return e(An,function(t){return e(An,function(n){return e(An,function(e){return Mn({entries:r,field:t,uid:n,visibility:e})},e(Rn,"visibility",Un))},e(Rn,"uid",jn))},e(Rn,"field",Un))},e(Rn,"entries",function(r){return e(gn,"list",r)}(e(An,function(r){return e(An,function(t){return e(An,function(n){return e(An,function(e){return Mn({completed:r,description:t,editing:n,id:e})},e(Rn,"id",jn))},e(Rn,"editing",Fn))},e(Rn,"description",Un))},e(Rn,"completed",Fn)))))),_1:{ctor:"[]"}}})),$c={};if($c.Todo=$c.Todo||{},void 0!==Bc&&Bc($c.Todo,"Todo",void 0),"function"==typeof define&&define.amd)return void define([],function(){return $c});if("object"==typeof module)return void(module.exports=$c);var Qc=this.Elm;if(void 0===Qc)return void(this.Elm=$c);for(var qc in $c){if(qc in Qc)throw new Error("There are two Elm modules called `"+qc+"` on this page! Rename one of them.");Qc[qc]=$c[qc]}}).call(this);

ToC:
https://gist.github.com/tgecho/cb6f1364874df7bd1ae45d811719566b#file-original-js
https://gist.github.com/tgecho/cb6f1364874df7bd1ae45d811719566b#file-prepared-js
https://gist.github.com/tgecho/cb6f1364874df7bd1ae45d811719566b#file-uglify-beautified
https://gist.github.com/tgecho/cb6f1364874df7bd1ae45d811719566b#file-uglify-optimized-js